]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added Bryan's new icons
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafileDataObject swig_types[93]
2560 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
2561 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseState swig_types[98]
2565 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2567 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxObject swig_types[104]
2571 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2578 #define SWIGTYPE_p_wxPlatformInfo swig_types[112]
2579 #define SWIGTYPE_p_wxPoint swig_types[113]
2580 #define SWIGTYPE_p_wxPowerEvent swig_types[114]
2581 #define SWIGTYPE_p_wxProcessEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPyApp swig_types[116]
2583 #define SWIGTYPE_p_wxPyArtProvider swig_types[117]
2584 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[118]
2585 #define SWIGTYPE_p_wxPyCommandEvent swig_types[119]
2586 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropSource swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
2589 #define SWIGTYPE_p_wxPyEvent swig_types[123]
2590 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyImageHandler swig_types[125]
2592 #define SWIGTYPE_p_wxPyLog swig_types[126]
2593 #define SWIGTYPE_p_wxPyProcess swig_types[127]
2594 #define SWIGTYPE_p_wxPySizer swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDataObject swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[130]
2597 #define SWIGTYPE_p_wxPyTimer swig_types[131]
2598 #define SWIGTYPE_p_wxPyTipProvider swig_types[132]
2599 #define SWIGTYPE_p_wxPyValidator swig_types[133]
2600 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[134]
2601 #define SWIGTYPE_p_wxRect swig_types[135]
2602 #define SWIGTYPE_p_wxScrollEvent swig_types[136]
2603 #define SWIGTYPE_p_wxScrollWinEvent swig_types[137]
2604 #define SWIGTYPE_p_wxSetCursorEvent swig_types[138]
2605 #define SWIGTYPE_p_wxShowEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[140]
2607 #define SWIGTYPE_p_wxSize swig_types[141]
2608 #define SWIGTYPE_p_wxSizeEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSizer swig_types[143]
2610 #define SWIGTYPE_p_wxSizerItem swig_types[144]
2611 #define SWIGTYPE_p_wxSound swig_types[145]
2612 #define SWIGTYPE_p_wxStandardPaths swig_types[146]
2613 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStopWatch swig_types[149]
2616 #define SWIGTYPE_p_wxString swig_types[150]
2617 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[151]
2618 #define SWIGTYPE_p_wxSystemOptions swig_types[152]
2619 #define SWIGTYPE_p_wxSystemSettings swig_types[153]
2620 #define SWIGTYPE_p_wxTIFFHandler swig_types[154]
2621 #define SWIGTYPE_p_wxTextCtrl swig_types[155]
2622 #define SWIGTYPE_p_wxTextDataObject swig_types[156]
2623 #define SWIGTYPE_p_wxTimeSpan swig_types[157]
2624 #define SWIGTYPE_p_wxTimer swig_types[158]
2625 #define SWIGTYPE_p_wxTimerEvent swig_types[159]
2626 #define SWIGTYPE_p_wxTimerRunner swig_types[160]
2627 #define SWIGTYPE_p_wxTipProvider swig_types[161]
2628 #define SWIGTYPE_p_wxToolTip swig_types[162]
2629 #define SWIGTYPE_p_wxURLDataObject swig_types[163]
2630 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[164]
2631 #define SWIGTYPE_p_wxValidator swig_types[165]
2632 #define SWIGTYPE_p_wxVideoMode swig_types[166]
2633 #define SWIGTYPE_p_wxWindow swig_types[167]
2634 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDisabler swig_types[170]
2637 #define SWIGTYPE_p_wxXPMHandler swig_types[171]
2638 static swig_type_info *swig_types[173];
2639 static swig_module_info swig_module = {swig_types, 172, 0, 0, 0, 0};
2640 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2641 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2642
2643 /* -------- TYPES TABLE (END) -------- */
2644
2645 #if (PY_VERSION_HEX <= 0x02000000)
2646 # if !defined(SWIG_PYTHON_CLASSIC)
2647 # error "This python version requires to use swig with the '-classic' option"
2648 # endif
2649 #endif
2650 #if (PY_VERSION_HEX <= 0x02020000)
2651 # error "This python version requires to use swig with the '-nomodern' option"
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodernargs' option"
2655 #endif
2656 #ifndef METH_O
2657 # error "This python version requires to use swig with the '-nofastunpack' option"
2658 #endif
2659
2660 /*-----------------------------------------------
2661 @(target):= _misc_.so
2662 ------------------------------------------------*/
2663 #define SWIG_init init_misc_
2664
2665 #define SWIG_name "_misc_"
2666
2667 #define SWIGVERSION 0x010329
2668
2669
2670 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2671 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2672
2673
2674 #include <stdexcept>
2675
2676
2677 namespace swig {
2678 class PyObject_ptr {
2679 protected:
2680 PyObject *_obj;
2681
2682 public:
2683 PyObject_ptr() :_obj(0)
2684 {
2685 }
2686
2687 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2688 {
2689 Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2693 {
2694 if (initial_ref) Py_XINCREF(_obj);
2695 }
2696
2697 PyObject_ptr & operator=(const PyObject_ptr& item)
2698 {
2699 Py_XINCREF(item._obj);
2700 Py_XDECREF(_obj);
2701 _obj = item._obj;
2702 return *this;
2703 }
2704
2705 ~PyObject_ptr()
2706 {
2707 Py_XDECREF(_obj);
2708 }
2709
2710 operator PyObject *() const
2711 {
2712 return _obj;
2713 }
2714
2715 PyObject *operator->() const
2716 {
2717 return _obj;
2718 }
2719 };
2720 }
2721
2722
2723 namespace swig {
2724 struct PyObject_var : PyObject_ptr {
2725 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2726
2727 PyObject_var & operator = (PyObject* obj)
2728 {
2729 Py_XDECREF(_obj);
2730 _obj = obj;
2731 return *this;
2732 }
2733 };
2734 }
2735
2736
2737 #include "wx/wxPython/wxPython.h"
2738 #include "wx/wxPython/pyclasses.h"
2739 #include "wx/wxPython/pyistream.h"
2740
2741 static const wxString wxPyEmptyString(wxEmptyString);
2742
2743
2744
2745 #define SWIG_From_long PyInt_FromLong
2746
2747
2748 SWIGINTERNINLINE PyObject *
2749 SWIG_From_int (int value)
2750 {
2751 return SWIG_From_long (value);
2752 }
2753
2754
2755 #include <limits.h>
2756 #ifndef LLONG_MIN
2757 # define LLONG_MIN LONG_LONG_MIN
2758 #endif
2759 #ifndef LLONG_MAX
2760 # define LLONG_MAX LONG_LONG_MAX
2761 #endif
2762 #ifndef ULLONG_MAX
2763 # define ULLONG_MAX ULONG_LONG_MAX
2764 #endif
2765
2766
2767 SWIGINTERN int
2768 SWIG_AsVal_long (PyObject* obj, long* val)
2769 {
2770 if (PyNumber_Check(obj)) {
2771 if (val) *val = PyInt_AsLong(obj);
2772 return SWIG_OK;
2773 }
2774 return SWIG_TypeError;
2775 }
2776
2777
2778 SWIGINTERN int
2779 SWIG_AsVal_int (PyObject * obj, int *val)
2780 {
2781 long v;
2782 int res = SWIG_AsVal_long (obj, &v);
2783 if (SWIG_IsOK(res)) {
2784 if ((v < INT_MIN || v > INT_MAX)) {
2785 return SWIG_OverflowError;
2786 } else {
2787 if (val) *val = static_cast< int >(v);
2788 }
2789 }
2790 return res;
2791 }
2792
2793 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2794
2795 #include <wx/stockitem.h>
2796
2797 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2798 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2799 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2800
2801 SWIGINTERN int
2802 SWIG_AsVal_bool (PyObject *obj, bool *val)
2803 {
2804 if (obj == Py_True) {
2805 if (val) *val = true;
2806 return SWIG_OK;
2807 } else if (obj == Py_False) {
2808 if (val) *val = false;
2809 return SWIG_OK;
2810 } else {
2811 long v = 0;
2812 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2813 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2814 return res;
2815 }
2816 }
2817
2818
2819 wxMemorySize wxGetFreeMemory()
2820 { wxPyRaiseNotImplemented(); return 0; }
2821
2822
2823 SWIGINTERN int
2824 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2825 {
2826 long v = 0;
2827 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2828 return SWIG_TypeError;
2829 }
2830 else if (val)
2831 *val = (unsigned long)v;
2832 return SWIG_OK;
2833 }
2834
2835
2836 SWIGINTERNINLINE PyObject*
2837 SWIG_From_unsigned_SS_long (unsigned long value)
2838 {
2839 return (value > LONG_MAX) ?
2840 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2841 }
2842
2843
2844 void* wxGetXDisplay()
2845 {
2846 #ifdef __WXGTK__
2847 return wxGetDisplay();
2848 #else
2849 return NULL;
2850 #endif
2851 }
2852
2853
2854 wxWindow* FindWindowAtPointer() {
2855 wxPoint unused;
2856 return wxFindWindowAtPointer(unused);
2857 }
2858
2859
2860 void wxWakeUpMainThread() {}
2861
2862
2863 bool wxThread_IsMain() {
2864 #ifdef WXP_WITH_THREAD
2865 return wxThread::IsMain();
2866 #else
2867 return true;
2868 #endif
2869 }
2870
2871 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2872 delete self;
2873 }
2874
2875 #include <wx/snglinst.h>
2876
2877
2878 #ifdef __WXMSW__
2879 #include <wx/msw/private.h>
2880 #include <wx/dynload.h>
2881 #endif
2882
2883
2884
2885 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2886 #if 0
2887 , int method
2888 #endif
2889 )
2890 {
2891 #ifdef __WXMSW__
2892 #if 0
2893 switch (method)
2894 {
2895 case 1:
2896 // This one only partially works. Appears to be an undocumented
2897 // "standard" convention that not all widgets adhear to. For
2898 // example, for some widgets backgrounds or non-client areas may
2899 // not be painted.
2900 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2901 break;
2902
2903 case 2:
2904 #endif
2905 // This one works much better, nearly all widgets and their
2906 // children are captured correctly[**]. Prior to the big
2907 // background erase changes that Vadim did in 2004-2005 this
2908 // method failed badly on XP with Themes activated, most native
2909 // widgets draw only partially, if at all. Without themes it
2910 // worked just like on Win2k. After those changes this method
2911 // works very well.
2912 //
2913 // ** For example the radio buttons in a wxRadioBox are not its
2914 // children by default, but you can capture it via the panel
2915 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2916 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2917 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2918 PRF_ERASEBKGND | PRF_OWNED );
2919 return true;
2920 #if 0
2921 break;
2922
2923 case 3:
2924 // This one is only defined in the latest SDK and is only
2925 // available on XP. MSDN says it is similar to sending WM_PRINT
2926 // so I expect that it will work similar to the above. Since it
2927 // is avaialble only on XP, it can't be compiled like this and
2928 // will have to be loaded dynamically.
2929 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2930
2931 // fall through
2932
2933 case 4:
2934 // Use PrintWindow if available, or fallback to WM_PRINT
2935 // otherwise. Unfortunately using PrintWindow is even worse than
2936 // WM_PRINT. For most native widgets nothing is drawn to the dc
2937 // at all, with or without Themes.
2938 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2939 static bool s_triedToLoad = false;
2940 static PrintWindow_t pfnPrintWindow = NULL;
2941 if ( !s_triedToLoad )
2942 {
2943
2944 s_triedToLoad = true;
2945 wxDynamicLibrary dllUser32(_T("user32.dll"));
2946 if ( dllUser32.IsLoaded() )
2947 {
2948 wxLogNull nolog; // Don't report errors here
2949 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2950 }
2951 }
2952 if (pfnPrintWindow)
2953 {
2954 //printf("Using PrintWindow\n");
2955 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2956 }
2957 else
2958 {
2959 //printf("Using WM_PRINT\n");
2960 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2961 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2962 PRF_ERASEBKGND | PRF_OWNED );
2963 }
2964 }
2965 #endif // 0
2966 #else
2967 return false;
2968 #endif // __WXMSW__
2969 }
2970
2971
2972
2973 #include <wx/tipdlg.h>
2974
2975
2976 SWIGINTERNINLINE PyObject *
2977 SWIG_From_size_t (size_t value)
2978 {
2979 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2980 }
2981
2982
2983 class wxPyTipProvider : public wxTipProvider {
2984 public:
2985 wxPyTipProvider(size_t currentTip)
2986 : wxTipProvider(currentTip) {}
2987
2988 DEC_PYCALLBACK_STRING__pure(GetTip);
2989 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2990 PYPRIVATE;
2991 };
2992
2993 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2994 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2995
2996
2997 SWIGINTERNINLINE int
2998 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2999 {
3000 unsigned long v;
3001 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3002 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3003 return res;
3004 }
3005
3006
3007 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3008
3009 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3010
3011 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3012 : wxTimer(owner, id)
3013 {
3014 if (owner == NULL)
3015 SetOwner(this);
3016 }
3017
3018
3019 SWIGINTERN swig_type_info*
3020 SWIG_pchar_descriptor()
3021 {
3022 static int init = 0;
3023 static swig_type_info* info = 0;
3024 if (!init) {
3025 info = SWIG_TypeQuery("_p_char");
3026 init = 1;
3027 }
3028 return info;
3029 }
3030
3031
3032 SWIGINTERNINLINE PyObject *
3033 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3034 {
3035 if (carray) {
3036 if (size > INT_MAX) {
3037 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3038 return pchar_descriptor ?
3039 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3040 } else {
3041 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3042 }
3043 } else {
3044 return SWIG_Py_Void();
3045 }
3046 }
3047
3048
3049 SWIGINTERNINLINE PyObject *
3050 SWIG_FromCharPtr(const char *cptr)
3051 {
3052 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3053 }
3054
3055
3056 SWIGINTERN int
3057 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3058 {
3059 unsigned long v;
3060 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3061 if (SWIG_IsOK(res)) {
3062 if ((v > UINT_MAX)) {
3063 return SWIG_OverflowError;
3064 } else {
3065 if (val) *val = static_cast< unsigned int >(v);
3066 }
3067 }
3068 return res;
3069 }
3070
3071 SWIGINTERN wxString wxLog_TimeStamp(){
3072 wxString msg;
3073 wxLog::TimeStamp(&msg);
3074 return msg;
3075 }
3076 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3077 // Make some wrappers that double any % signs so they are 'escaped'
3078 void wxPyLogFatalError(const wxString& msg)
3079 {
3080 wxString m(msg);
3081 m.Replace(wxT("%"), wxT("%%"));
3082 wxLogFatalError(m);
3083 }
3084
3085 void wxPyLogError(const wxString& msg)
3086 {
3087 wxString m(msg);
3088 m.Replace(wxT("%"), wxT("%%"));
3089 wxLogError(m);
3090 }
3091
3092 void wxPyLogWarning(const wxString& msg)
3093 {
3094 wxString m(msg);
3095 m.Replace(wxT("%"), wxT("%%"));
3096 wxLogWarning(m);
3097 }
3098
3099 void wxPyLogMessage(const wxString& msg)
3100 {
3101 wxString m(msg);
3102 m.Replace(wxT("%"), wxT("%%"));
3103 wxLogMessage(m);
3104 }
3105
3106 void wxPyLogInfo(const wxString& msg)
3107 {
3108 wxString m(msg);
3109 m.Replace(wxT("%"), wxT("%%"));
3110 wxLogInfo(m);
3111 }
3112
3113 void wxPyLogDebug(const wxString& msg)
3114 {
3115 wxString m(msg);
3116 m.Replace(wxT("%"), wxT("%%"));
3117 wxLogDebug(m);
3118 }
3119
3120 void wxPyLogVerbose(const wxString& msg)
3121 {
3122 wxString m(msg);
3123 m.Replace(wxT("%"), wxT("%%"));
3124 wxLogVerbose(m);
3125 }
3126
3127 void wxPyLogStatus(const wxString& msg)
3128 {
3129 wxString m(msg);
3130 m.Replace(wxT("%"), wxT("%%"));
3131 wxLogStatus(m);
3132 }
3133
3134 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3135 {
3136 wxString m(msg);
3137 m.Replace(wxT("%"), wxT("%%"));
3138 wxLogStatus(pFrame, m);
3139 }
3140
3141 void wxPyLogSysError(const wxString& msg)
3142 {
3143 wxString m(msg);
3144 m.Replace(wxT("%"), wxT("%%"));
3145 wxLogSysError(m);
3146 }
3147
3148 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3149 {
3150 wxString m(msg);
3151 m.Replace(wxT("%"), wxT("%%"));
3152 wxLogGeneric(level, m);
3153 }
3154
3155 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3156 {
3157 wxString m(msg);
3158 m.Replace(wxT("%"), wxT("%%"));
3159 wxLogTrace(mask, m);
3160 }
3161
3162 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3163 {
3164 wxString m(msg);
3165 m.Replace(wxT("%"), wxT("%%"));
3166 wxLogTrace(mask, m);
3167 }
3168
3169
3170
3171 // A wxLog class that can be derived from in wxPython
3172 class wxPyLog : public wxLog {
3173 public:
3174 wxPyLog() : wxLog() {}
3175
3176 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3177 bool found;
3178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3179 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3180 PyObject* s = wx2PyString(szString);
3181 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3182 Py_DECREF(s);
3183 }
3184 wxPyEndBlockThreads(blocked);
3185 if (! found)
3186 wxLog::DoLog(level, szString, t);
3187 }
3188
3189 virtual void DoLogString(const wxChar *szString, time_t t) {
3190 bool found;
3191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3192 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3193 PyObject* s = wx2PyString(szString);
3194 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3195 Py_DECREF(s);
3196 }
3197 wxPyEndBlockThreads(blocked);
3198 if (! found)
3199 wxLog::DoLogString(szString, t);
3200 }
3201
3202 DEC_PYCALLBACK_VOID_(Flush);
3203 PYPRIVATE;
3204 };
3205 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3206
3207
3208
3209
3210 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3211
3212
3213 #include <wx/joystick.h>
3214
3215
3216 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3217 // A C++ stub class for wxJoystick for platforms that don't have it.
3218 class wxJoystick : public wxObject {
3219 public:
3220 wxJoystick(int joystick = wxJOYSTICK1) {
3221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3222 PyErr_SetString(PyExc_NotImplementedError,
3223 "wxJoystick is not available on this platform.");
3224 wxPyEndBlockThreads(blocked);
3225 }
3226 wxPoint GetPosition() { return wxPoint(-1,-1); }
3227 int GetZPosition() { return -1; }
3228 int GetButtonState() { return -1; }
3229 int GetPOVPosition() { return -1; }
3230 int GetPOVCTSPosition() { return -1; }
3231 int GetRudderPosition() { return -1; }
3232 int GetUPosition() { return -1; }
3233 int GetVPosition() { return -1; }
3234 int GetMovementThreshold() { return -1; }
3235 void SetMovementThreshold(int threshold) {}
3236
3237 bool IsOk(void) { return false; }
3238 int GetNumberJoysticks() { return -1; }
3239 int GetManufacturerId() { return -1; }
3240 int GetProductId() { return -1; }
3241 wxString GetProductName() { return wxEmptyString; }
3242 int GetXMin() { return -1; }
3243 int GetYMin() { return -1; }
3244 int GetZMin() { return -1; }
3245 int GetXMax() { return -1; }
3246 int GetYMax() { return -1; }
3247 int GetZMax() { return -1; }
3248 int GetNumberButtons() { return -1; }
3249 int GetNumberAxes() { return -1; }
3250 int GetMaxButtons() { return -1; }
3251 int GetMaxAxes() { return -1; }
3252 int GetPollingMin() { return -1; }
3253 int GetPollingMax() { return -1; }
3254 int GetRudderMin() { return -1; }
3255 int GetRudderMax() { return -1; }
3256 int GetUMin() { return -1; }
3257 int GetUMax() { return -1; }
3258 int GetVMin() { return -1; }
3259 int GetVMax() { return -1; }
3260
3261 bool HasRudder() { return false; }
3262 bool HasZ() { return false; }
3263 bool HasU() { return false; }
3264 bool HasV() { return false; }
3265 bool HasPOV() { return false; }
3266 bool HasPOV4Dir() { return false; }
3267 bool HasPOVCTS() { return false; }
3268
3269 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3270 bool ReleaseCapture() { return false; }
3271 };
3272 #endif
3273
3274
3275 #include <wx/sound.h>
3276
3277
3278 #if !wxUSE_SOUND
3279 // A C++ stub class for wxWave for platforms that don't have it.
3280 class wxSound : public wxObject
3281 {
3282 public:
3283 wxSound() {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289 wxSound(const wxString&/*, bool*/) {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295 wxSound(int, const wxByte*) {
3296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3297 PyErr_SetString(PyExc_NotImplementedError,
3298 "wxSound is not available on this platform.");
3299 wxPyEndBlockThreads(blocked);
3300 }
3301
3302 ~wxSound() {};
3303
3304 bool Create(const wxString&/*, bool*/) { return false; }
3305 bool Create(int, const wxByte*) { return false; };
3306 bool IsOk() { return false; };
3307 bool Play(unsigned) const { return false; }
3308 static bool Play(const wxString&, unsigned) { return false; }
3309 static void Stop() {}
3310 };
3311
3312 #endif
3313
3314 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3315 if (fileName.Length() == 0)
3316 return new wxSound;
3317 else
3318 return new wxSound(fileName);
3319 }
3320 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3321 unsigned char* buffer; int size;
3322 wxSound *sound = NULL;
3323
3324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3325 if (!PyArg_Parse(data, "t#", &buffer, &size))
3326 goto done;
3327 sound = new wxSound(size, buffer);
3328 done:
3329 wxPyEndBlockThreads(blocked);
3330 return sound;
3331 }
3332 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3333 #ifndef __WXMAC__
3334 unsigned char* buffer;
3335 int size;
3336 bool rv = false;
3337
3338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3339 if (!PyArg_Parse(data, "t#", &buffer, &size))
3340 goto done;
3341 rv = self->Create(size, buffer);
3342 done:
3343 wxPyEndBlockThreads(blocked);
3344 return rv;
3345 #else
3346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3347 PyErr_SetString(PyExc_NotImplementedError,
3348 "Create from data is not available on this platform.");
3349 wxPyEndBlockThreads(blocked);
3350 return false;
3351 #endif
3352 }
3353
3354 #include <wx/mimetype.h>
3355
3356 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3357 wxString str;
3358 if (self->GetMimeType(&str))
3359 return wx2PyString(str);
3360 else
3361 RETURN_NONE();
3362 }
3363 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3364 wxArrayString arr;
3365 if (self->GetMimeTypes(arr))
3366 return wxArrayString2PyList_helper(arr);
3367 else
3368 RETURN_NONE();
3369 }
3370 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3371 wxArrayString arr;
3372 if (self->GetExtensions(arr))
3373 return wxArrayString2PyList_helper(arr);
3374 else
3375 RETURN_NONE();
3376 }
3377 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3378 wxIconLocation loc;
3379 if (self->GetIcon(&loc))
3380 return new wxIcon(loc);
3381 else
3382 return NULL;
3383 }
3384 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3385 wxIconLocation loc;
3386 if (self->GetIcon(&loc)) {
3387 wxString iconFile = loc.GetFileName();
3388 int iconIndex = -1;
3389
3390
3391
3392 // Make a tuple and put the values in it
3393 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3394 PyObject* tuple = PyTuple_New(3);
3395 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3396 wxT("wxIcon"), true));
3397 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3398 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3399 wxPyEndBlockThreads(blocked);
3400 return tuple;
3401 }
3402 else
3403 RETURN_NONE();
3404 }
3405 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3406 wxString str;
3407 if (self->GetDescription(&str))
3408 return wx2PyString(str);
3409 else
3410 RETURN_NONE();
3411 }
3412 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3413 wxString str;
3414 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3415 return wx2PyString(str);
3416 else
3417 RETURN_NONE();
3418 }
3419 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3420 wxString str;
3421 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3422 return wx2PyString(str);
3423 else
3424 RETURN_NONE();
3425 }
3426 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3427 wxArrayString verbs;
3428 wxArrayString commands;
3429 if (self->GetAllCommands(&verbs, &commands,
3430 wxFileType::MessageParameters(filename, mimetype))) {
3431 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3432 PyObject* tuple = PyTuple_New(2);
3433 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3434 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3435 wxPyEndBlockThreads(blocked);
3436 return tuple;
3437 }
3438 else
3439 RETURN_NONE();
3440 }
3441 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3442 return wxFileType::ExpandCommand(command,
3443 wxFileType::MessageParameters(filename, mimetype));
3444 }
3445 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3446 wxArrayString arr;
3447 self->EnumAllFileTypes(arr);
3448 return wxArrayString2PyList_helper(arr);
3449 }
3450
3451 #include <wx/artprov.h>
3452
3453 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3454 static const wxString wxPyART_MENU(wxART_MENU);
3455 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3456 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3457 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3458 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3459 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3460 static const wxString wxPyART_OTHER(wxART_OTHER);
3461 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3462 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3463 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3464 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3465 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3466 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3467 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3468 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3469 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3470 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3471 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3472 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3473 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3474 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3475 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3476 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3477 static const wxString wxPyART_PRINT(wxART_PRINT);
3478 static const wxString wxPyART_HELP(wxART_HELP);
3479 static const wxString wxPyART_TIP(wxART_TIP);
3480 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3481 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3482 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3483 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3484 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3485 static const wxString wxPyART_CDROM(wxART_CDROM);
3486 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3487 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3488 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3489 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3490 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3491 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3492 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3493 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3494 static const wxString wxPyART_ERROR(wxART_ERROR);
3495 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3496 static const wxString wxPyART_WARNING(wxART_WARNING);
3497 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3498 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3499 static const wxString wxPyART_COPY(wxART_COPY);
3500 static const wxString wxPyART_CUT(wxART_CUT);
3501 static const wxString wxPyART_PASTE(wxART_PASTE);
3502 static const wxString wxPyART_DELETE(wxART_DELETE);
3503 static const wxString wxPyART_NEW(wxART_NEW);
3504 static const wxString wxPyART_UNDO(wxART_UNDO);
3505 static const wxString wxPyART_REDO(wxART_REDO);
3506 static const wxString wxPyART_QUIT(wxART_QUIT);
3507 static const wxString wxPyART_FIND(wxART_FIND);
3508 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3509 // Python aware wxArtProvider
3510 class wxPyArtProvider : public wxArtProvider {
3511 public:
3512
3513 virtual wxBitmap CreateBitmap(const wxArtID& id,
3514 const wxArtClient& client,
3515 const wxSize& size) {
3516 wxBitmap rval = wxNullBitmap;
3517 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3518 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3519 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3520 PyObject* ro;
3521 wxBitmap* ptr;
3522 PyObject* s1, *s2;
3523 s1 = wx2PyString(id);
3524 s2 = wx2PyString(client);
3525 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3526 Py_DECREF(so);
3527 Py_DECREF(s1);
3528 Py_DECREF(s2);
3529 if (ro) {
3530 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3531 rval = *ptr;
3532 Py_DECREF(ro);
3533 }
3534 }
3535 wxPyEndBlockThreads(blocked);
3536 return rval;
3537 }
3538
3539 PYPRIVATE;
3540 };
3541
3542 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3543
3544
3545
3546 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3547 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3548 PyObject* ret = PyTuple_New(3);
3549 if (ret) {
3550 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3551 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3552 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3553 }
3554 wxPyEndBlockThreads(blocked);
3555 return ret;
3556 }
3557
3558 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3559 bool cont;
3560 long index = 0;
3561 wxString value;
3562
3563 cont = self->GetFirstGroup(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3567 bool cont;
3568 wxString value;
3569
3570 cont = self->GetNextGroup(value, index);
3571 return __EnumerationHelper(cont, value, index);
3572 }
3573 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3574 bool cont;
3575 long index = 0;
3576 wxString value;
3577
3578 cont = self->GetFirstEntry(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3582 bool cont;
3583 wxString value;
3584
3585 cont = self->GetNextEntry(value, index);
3586 return __EnumerationHelper(cont, value, index);
3587 }
3588 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3589 long rv;
3590 self->Read(key, &rv, defaultVal);
3591 return rv;
3592 }
3593
3594 SWIGINTERN int
3595 SWIG_AsVal_double (PyObject *obj, double* val)
3596 {
3597 if (PyNumber_Check(obj)) {
3598 if (val) *val = PyFloat_AsDouble(obj);
3599 return SWIG_OK;
3600 }
3601 return SWIG_TypeError;
3602 }
3603
3604 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3605 double rv;
3606 self->Read(key, &rv, defaultVal);
3607 return rv;
3608 }
3609
3610 #define SWIG_From_double PyFloat_FromDouble
3611
3612 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3613 bool rv;
3614 self->Read(key, &rv, defaultVal);
3615 return rv;
3616 }
3617
3618 #include <wx/datetime.h>
3619
3620 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3621 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3622
3623 #define LOCAL_TZ wxDateTime::Local
3624
3625 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3626 wxString am;
3627 wxString pm;
3628 wxDateTime::GetAmPmStrings(&am, &pm);
3629 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3630 PyObject* tup = PyTuple_New(2);
3631 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3632 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3633 wxPyEndBlockThreads(blocked);
3634 return tup;
3635 }
3636
3637 SWIGINTERNINLINE PyObject *
3638 SWIG_From_unsigned_SS_int (unsigned int value)
3639 {
3640 return SWIG_From_unsigned_SS_long (value);
3641 }
3642
3643 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3644 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3645 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3646 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3647 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3648 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3649 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3650 return (*self < *other);
3651 }
3652 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3653 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3654 return (*self <= *other);
3655 }
3656 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3658 return (*self > *other);
3659 }
3660 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3662 return (*self >= *other);
3663 }
3664 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3665 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3666 return (*self == *other);
3667 }
3668 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3669 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3670 return (*self != *other);
3671 }
3672 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3673 const wxChar* rv;
3674 const wxChar* _date = date;
3675 rv = self->ParseRfc822Date(_date);
3676 if (rv == NULL) return -1;
3677 return rv - _date;
3678 }
3679 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3680 const wxChar* rv;
3681 const wxChar* _date = date;
3682 rv = self->ParseFormat(_date, format, dateDef);
3683 if (rv == NULL) return -1;
3684 return rv - _date;
3685 }
3686 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3687 const wxChar* rv;
3688 const wxChar* _datetime = datetime;
3689 rv = self->ParseDateTime(_datetime);
3690 if (rv == NULL) return -1;
3691 return rv - _datetime;
3692 }
3693 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3694 const wxChar* rv;
3695 const wxChar* _date = date;
3696 rv = self->ParseDate(_date);
3697 if (rv == NULL) return -1;
3698 return rv - _date;
3699 }
3700 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3701 const wxChar* rv;
3702 const wxChar* _time = time;
3703 rv = self->ParseTime(_time);
3704 if (rv == NULL) return -1;
3705 return rv - _time;
3706 }
3707 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3711 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3712 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3713 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3714 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3715 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3716 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3717 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3718 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3719 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3720 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3721 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3722 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3723
3724 #include <wx/dataobj.h>
3725
3726 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3727 size_t count = self->GetFormatCount(dir);
3728 wxDataFormat* formats = new wxDataFormat[count];
3729 self->GetAllFormats(formats, dir);
3730
3731 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3732 PyObject* list = PyList_New(count);
3733 for (size_t i=0; i<count; i++) {
3734 wxDataFormat* format = new wxDataFormat(formats[i]);
3735 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3736 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3737 }
3738 wxPyEndBlockThreads(blocked);
3739 delete [] formats;
3740 return list;
3741 }
3742 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3743 PyObject* rval = NULL;
3744 size_t size = self->GetDataSize(format);
3745 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3746 if (size) {
3747 char* buf = new char[size];
3748 if (self->GetDataHere(format, buf))
3749 rval = PyString_FromStringAndSize(buf, size);
3750 delete [] buf;
3751 }
3752 if (! rval) {
3753 rval = Py_None;
3754 Py_INCREF(rval);
3755 }
3756 wxPyEndBlockThreads(blocked);
3757 return rval;
3758 }
3759 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3760 bool rval;
3761 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3762 if (PyString_Check(data)) {
3763 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3764 }
3765 else {
3766 // raise a TypeError if not a string
3767 PyErr_SetString(PyExc_TypeError, "String expected.");
3768 rval = false;
3769 }
3770 wxPyEndBlockThreads(blocked);
3771 return rval;
3772 }
3773 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3774 PyObject* rval = NULL;
3775 size_t size = self->GetDataSize();
3776 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3777 if (size) {
3778 char* buf = new char[size];
3779 if (self->GetDataHere(buf))
3780 rval = PyString_FromStringAndSize(buf, size);
3781 delete [] buf;
3782 }
3783 if (! rval) {
3784 rval = Py_None;
3785 Py_INCREF(rval);
3786 }
3787 wxPyEndBlockThreads(blocked);
3788 return rval;
3789 }
3790 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3791 bool rval;
3792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3793 if (PyString_Check(data)) {
3794 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3795 }
3796 else {
3797 // raise a TypeError if not a string
3798 PyErr_SetString(PyExc_TypeError, "String expected.");
3799 rval = false;
3800 }
3801 wxPyEndBlockThreads(blocked);
3802 return rval;
3803 }
3804 // Create a new class for wxPython to use
3805 class wxPyDataObjectSimple : public wxDataObjectSimple {
3806 public:
3807 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3808 : wxDataObjectSimple(format) {}
3809
3810 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3811 bool GetDataHere(void *buf) const;
3812 bool SetData(size_t len, const void *buf);
3813 PYPRIVATE;
3814 };
3815
3816 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3817
3818 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3819 // We need to get the data for this object and write it to buf. I think
3820 // the best way to do this for wxPython is to have the Python method
3821 // return either a string or None and then act appropriately with the
3822 // C++ version.
3823
3824 bool rval = false;
3825 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3826 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3827 PyObject* ro;
3828 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3829 if (ro) {
3830 rval = (ro != Py_None && PyString_Check(ro));
3831 if (rval)
3832 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3833 Py_DECREF(ro);
3834 }
3835 }
3836 wxPyEndBlockThreads(blocked);
3837 return rval;
3838 }
3839
3840 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3841 // For this one we simply need to make a string from buf and len
3842 // and send it to the Python method.
3843 bool rval = false;
3844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3845 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3846 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3847 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3848 Py_DECREF(data);
3849 }
3850 wxPyEndBlockThreads(blocked);
3851 return rval;
3852 }
3853
3854 // Create a new class for wxPython to use
3855 class wxPyTextDataObject : public wxTextDataObject {
3856 public:
3857 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3858 : wxTextDataObject(text) {}
3859
3860 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3861 DEC_PYCALLBACK_STRING__const(GetText);
3862 DEC_PYCALLBACK__STRING(SetText);
3863 PYPRIVATE;
3864 };
3865
3866 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3867 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3868 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3869
3870
3871 // Create a new class for wxPython to use
3872 class wxPyBitmapDataObject : public wxBitmapDataObject {
3873 public:
3874 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3875 : wxBitmapDataObject(bitmap) {}
3876
3877 wxBitmap GetBitmap() const;
3878 void SetBitmap(const wxBitmap& bitmap);
3879 PYPRIVATE;
3880 };
3881
3882 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3883 wxBitmap* rval = &wxNullBitmap;
3884 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3885 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3886 PyObject* ro;
3887 wxBitmap* ptr;
3888 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3889 if (ro) {
3890 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3891 rval = ptr;
3892 Py_DECREF(ro);
3893 }
3894 }
3895 wxPyEndBlockThreads(blocked);
3896 return *rval;
3897 }
3898
3899 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3900 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3901 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3902 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3903 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3904 Py_DECREF(bo);
3905 }
3906 wxPyEndBlockThreads(blocked);
3907 }
3908
3909 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3910 return new wxCustomDataObject(wxDataFormat(formatName));
3911 }
3912 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3913 bool rval;
3914 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3915 if (PyString_Check(data)) {
3916 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3917 }
3918 else {
3919 // raise a TypeError if not a string
3920 PyErr_SetString(PyExc_TypeError, "String expected.");
3921 rval = false;
3922 }
3923 wxPyEndBlockThreads(blocked);
3924 return rval;
3925 }
3926 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3927 PyObject* obj;
3928 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3929 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3930 wxPyEndBlockThreads(blocked);
3931 return obj;
3932 }
3933
3934 class wxMetafileDataObject : public wxDataObjectSimple
3935 {
3936 public:
3937 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3938 };
3939
3940
3941 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3942
3943
3944 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3945 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3946 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3947 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3948 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3949
3950
3951 class wxPyTextDropTarget : public wxTextDropTarget {
3952 public:
3953 wxPyTextDropTarget() {}
3954
3955 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3956
3957 DEC_PYCALLBACK__(OnLeave);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3960 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3961 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3962
3963 PYPRIVATE;
3964 };
3965
3966 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3967 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3970 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3971 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3972
3973
3974
3975 class wxPyFileDropTarget : public wxFileDropTarget {
3976 public:
3977 wxPyFileDropTarget() {}
3978
3979 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3980
3981 DEC_PYCALLBACK__(OnLeave);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3984 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3985 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3986
3987 PYPRIVATE;
3988 };
3989
3990 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3991 const wxArrayString& filenames) {
3992 bool rval = false;
3993 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3994 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3995 PyObject* list = wxArrayString2PyList_helper(filenames);
3996 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3997 Py_DECREF(list);
3998 }
3999 wxPyEndBlockThreads(blocked);
4000 return rval;
4001 }
4002
4003
4004
4005 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4008 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4009 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4010
4011
4012
4013
4014 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4015
4016 #include <wx/display.h>
4017
4018 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4019 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4020
4021 #if !wxUSE_DISPLAY
4022 const wxVideoMode wxDefaultVideoMode;
4023 #endif
4024
4025 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4026 #if wxUSE_DISPLAY
4027 PyObject* pyList = NULL;
4028 wxArrayVideoModes arr = self->GetModes(mode);
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 pyList = PyList_New(0);
4031 for (size_t i=0; i < arr.GetCount(); i++)
4032 {
4033 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4034 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4035 PyList_Append(pyList, pyObj);
4036 Py_DECREF(pyObj);
4037 }
4038 wxPyEndBlockThreads(blocked);
4039 return pyList;
4040 #else
4041 wxPyRaiseNotImplemented();
4042 return NULL;
4043 #endif
4044 }
4045 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4046 #if wxUSE_DISPLAY
4047 return self->GetCurrentMode();
4048 #else
4049 wxPyRaiseNotImplemented();
4050 return wxDefaultVideoMode;
4051 #endif
4052 }
4053 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4054 #if wxUSE_DISPLAY
4055 return self->ChangeMode(mode);
4056 #else
4057 wxPyRaiseNotImplemented();
4058 return false;
4059 #endif
4060 }
4061 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4062 #if wxUSE_DISPLAY
4063 self->ResetMode();
4064 #else
4065 wxPyRaiseNotImplemented();
4066 #endif
4067 }
4068
4069 #include <wx/stdpaths.h>
4070
4071 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4072 return (wxStandardPaths*) &wxStandardPaths::Get();
4073 }
4074
4075 #ifndef wxHAS_POWER_EVENTS
4076 // Dummy class and other definitions for platforms that don't have them
4077
4078 // See wxPython_int.h for wxPowerEvent
4079
4080 enum {
4081 wxEVT_POWER_SUSPENDING,
4082 wxEVT_POWER_SUSPENDED,
4083 wxEVT_POWER_SUSPEND_CANCEL,
4084 wxEVT_POWER_RESUME,
4085 };
4086
4087 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4088 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4089
4090 #endif
4091
4092 #ifdef __cplusplus
4093 extern "C" {
4094 #endif
4095 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4096 PyObject *resultobj = 0;
4097 wxSystemColour arg1 ;
4098 wxColour result;
4099 int val1 ;
4100 int ecode1 = 0 ;
4101 PyObject * obj0 = 0 ;
4102 char * kwnames[] = {
4103 (char *) "index", NULL
4104 };
4105
4106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4107 ecode1 = SWIG_AsVal_int(obj0, &val1);
4108 if (!SWIG_IsOK(ecode1)) {
4109 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4110 }
4111 arg1 = static_cast< wxSystemColour >(val1);
4112 {
4113 if (!wxPyCheckForApp()) SWIG_fail;
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 result = wxSystemSettings::GetColour(arg1);
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj = 0;
4128 wxSystemFont arg1 ;
4129 wxFont result;
4130 int val1 ;
4131 int ecode1 = 0 ;
4132 PyObject * obj0 = 0 ;
4133 char * kwnames[] = {
4134 (char *) "index", NULL
4135 };
4136
4137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4138 ecode1 = SWIG_AsVal_int(obj0, &val1);
4139 if (!SWIG_IsOK(ecode1)) {
4140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4141 }
4142 arg1 = static_cast< wxSystemFont >(val1);
4143 {
4144 if (!wxPyCheckForApp()) SWIG_fail;
4145 PyThreadState* __tstate = wxPyBeginAllowThreads();
4146 result = wxSystemSettings::GetFont(arg1);
4147 wxPyEndAllowThreads(__tstate);
4148 if (PyErr_Occurred()) SWIG_fail;
4149 }
4150 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4151 return resultobj;
4152 fail:
4153 return NULL;
4154 }
4155
4156
4157 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4158 PyObject *resultobj = 0;
4159 wxSystemMetric arg1 ;
4160 wxWindow *arg2 = (wxWindow *) NULL ;
4161 int result;
4162 int val1 ;
4163 int ecode1 = 0 ;
4164 void *argp2 = 0 ;
4165 int res2 = 0 ;
4166 PyObject * obj0 = 0 ;
4167 PyObject * obj1 = 0 ;
4168 char * kwnames[] = {
4169 (char *) "index",(char *) "win", NULL
4170 };
4171
4172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4173 ecode1 = SWIG_AsVal_int(obj0, &val1);
4174 if (!SWIG_IsOK(ecode1)) {
4175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4176 }
4177 arg1 = static_cast< wxSystemMetric >(val1);
4178 if (obj1) {
4179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4180 if (!SWIG_IsOK(res2)) {
4181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4182 }
4183 arg2 = reinterpret_cast< wxWindow * >(argp2);
4184 }
4185 {
4186 if (!wxPyCheckForApp()) SWIG_fail;
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4189 wxPyEndAllowThreads(__tstate);
4190 if (PyErr_Occurred()) SWIG_fail;
4191 }
4192 resultobj = SWIG_From_int(static_cast< int >(result));
4193 return resultobj;
4194 fail:
4195 return NULL;
4196 }
4197
4198
4199 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4200 PyObject *resultobj = 0;
4201 wxSystemFeature arg1 ;
4202 bool result;
4203 int val1 ;
4204 int ecode1 = 0 ;
4205 PyObject * obj0 = 0 ;
4206 char * kwnames[] = {
4207 (char *) "index", NULL
4208 };
4209
4210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4211 ecode1 = SWIG_AsVal_int(obj0, &val1);
4212 if (!SWIG_IsOK(ecode1)) {
4213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4214 }
4215 arg1 = static_cast< wxSystemFeature >(val1);
4216 {
4217 if (!wxPyCheckForApp()) SWIG_fail;
4218 PyThreadState* __tstate = wxPyBeginAllowThreads();
4219 result = (bool)wxSystemSettings::HasFeature(arg1);
4220 wxPyEndAllowThreads(__tstate);
4221 if (PyErr_Occurred()) SWIG_fail;
4222 }
4223 {
4224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4225 }
4226 return resultobj;
4227 fail:
4228 return NULL;
4229 }
4230
4231
4232 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4233 PyObject *resultobj = 0;
4234 wxSystemScreenType result;
4235
4236 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4237 {
4238 if (!wxPyCheckForApp()) SWIG_fail;
4239 PyThreadState* __tstate = wxPyBeginAllowThreads();
4240 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4241 wxPyEndAllowThreads(__tstate);
4242 if (PyErr_Occurred()) SWIG_fail;
4243 }
4244 resultobj = SWIG_From_int(static_cast< int >(result));
4245 return resultobj;
4246 fail:
4247 return NULL;
4248 }
4249
4250
4251 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4252 PyObject *resultobj = 0;
4253 wxSystemScreenType arg1 ;
4254 int val1 ;
4255 int ecode1 = 0 ;
4256 PyObject * obj0 = 0 ;
4257 char * kwnames[] = {
4258 (char *) "screen", NULL
4259 };
4260
4261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4262 ecode1 = SWIG_AsVal_int(obj0, &val1);
4263 if (!SWIG_IsOK(ecode1)) {
4264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4265 }
4266 arg1 = static_cast< wxSystemScreenType >(val1);
4267 {
4268 if (!wxPyCheckForApp()) SWIG_fail;
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 wxSystemSettings::SetScreenType(arg1);
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 resultobj = SWIG_Py_Void();
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4282 PyObject *obj;
4283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4284 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4285 return SWIG_Py_Void();
4286 }
4287
4288 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4289 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4290 return 1;
4291 }
4292
4293
4294 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4295 PyObject *pyobj = 0;
4296
4297 {
4298 #if wxUSE_UNICODE
4299 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4300 #else
4301 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4302 #endif
4303 }
4304 return pyobj;
4305 }
4306
4307
4308 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309 PyObject *resultobj = 0;
4310 wxSystemOptions *result = 0 ;
4311
4312 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4313 {
4314 PyThreadState* __tstate = wxPyBeginAllowThreads();
4315 result = (wxSystemOptions *)new wxSystemOptions();
4316 wxPyEndAllowThreads(__tstate);
4317 if (PyErr_Occurred()) SWIG_fail;
4318 }
4319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4327 PyObject *resultobj = 0;
4328 wxString *arg1 = 0 ;
4329 wxString *arg2 = 0 ;
4330 bool temp1 = false ;
4331 bool temp2 = false ;
4332 PyObject * obj0 = 0 ;
4333 PyObject * obj1 = 0 ;
4334 char * kwnames[] = {
4335 (char *) "name",(char *) "value", NULL
4336 };
4337
4338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4339 {
4340 arg1 = wxString_in_helper(obj0);
4341 if (arg1 == NULL) SWIG_fail;
4342 temp1 = true;
4343 }
4344 {
4345 arg2 = wxString_in_helper(obj1);
4346 if (arg2 == NULL) SWIG_fail;
4347 temp2 = true;
4348 }
4349 {
4350 PyThreadState* __tstate = wxPyBeginAllowThreads();
4351 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4352 wxPyEndAllowThreads(__tstate);
4353 if (PyErr_Occurred()) SWIG_fail;
4354 }
4355 resultobj = SWIG_Py_Void();
4356 {
4357 if (temp1)
4358 delete arg1;
4359 }
4360 {
4361 if (temp2)
4362 delete arg2;
4363 }
4364 return resultobj;
4365 fail:
4366 {
4367 if (temp1)
4368 delete arg1;
4369 }
4370 {
4371 if (temp2)
4372 delete arg2;
4373 }
4374 return NULL;
4375 }
4376
4377
4378 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4379 PyObject *resultobj = 0;
4380 wxString *arg1 = 0 ;
4381 int arg2 ;
4382 bool temp1 = false ;
4383 int val2 ;
4384 int ecode2 = 0 ;
4385 PyObject * obj0 = 0 ;
4386 PyObject * obj1 = 0 ;
4387 char * kwnames[] = {
4388 (char *) "name",(char *) "value", NULL
4389 };
4390
4391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4392 {
4393 arg1 = wxString_in_helper(obj0);
4394 if (arg1 == NULL) SWIG_fail;
4395 temp1 = true;
4396 }
4397 ecode2 = SWIG_AsVal_int(obj1, &val2);
4398 if (!SWIG_IsOK(ecode2)) {
4399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4400 }
4401 arg2 = static_cast< int >(val2);
4402 {
4403 PyThreadState* __tstate = wxPyBeginAllowThreads();
4404 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4405 wxPyEndAllowThreads(__tstate);
4406 if (PyErr_Occurred()) SWIG_fail;
4407 }
4408 resultobj = SWIG_Py_Void();
4409 {
4410 if (temp1)
4411 delete arg1;
4412 }
4413 return resultobj;
4414 fail:
4415 {
4416 if (temp1)
4417 delete arg1;
4418 }
4419 return NULL;
4420 }
4421
4422
4423 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4424 PyObject *resultobj = 0;
4425 wxString *arg1 = 0 ;
4426 wxString result;
4427 bool temp1 = false ;
4428 PyObject * obj0 = 0 ;
4429 char * kwnames[] = {
4430 (char *) "name", NULL
4431 };
4432
4433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4434 {
4435 arg1 = wxString_in_helper(obj0);
4436 if (arg1 == NULL) SWIG_fail;
4437 temp1 = true;
4438 }
4439 {
4440 PyThreadState* __tstate = wxPyBeginAllowThreads();
4441 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4442 wxPyEndAllowThreads(__tstate);
4443 if (PyErr_Occurred()) SWIG_fail;
4444 }
4445 {
4446 #if wxUSE_UNICODE
4447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4448 #else
4449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4450 #endif
4451 }
4452 {
4453 if (temp1)
4454 delete arg1;
4455 }
4456 return resultobj;
4457 fail:
4458 {
4459 if (temp1)
4460 delete arg1;
4461 }
4462 return NULL;
4463 }
4464
4465
4466 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4467 PyObject *resultobj = 0;
4468 wxString *arg1 = 0 ;
4469 int result;
4470 bool temp1 = false ;
4471 PyObject * obj0 = 0 ;
4472 char * kwnames[] = {
4473 (char *) "name", NULL
4474 };
4475
4476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4477 {
4478 arg1 = wxString_in_helper(obj0);
4479 if (arg1 == NULL) SWIG_fail;
4480 temp1 = true;
4481 }
4482 {
4483 PyThreadState* __tstate = wxPyBeginAllowThreads();
4484 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4485 wxPyEndAllowThreads(__tstate);
4486 if (PyErr_Occurred()) SWIG_fail;
4487 }
4488 resultobj = SWIG_From_int(static_cast< int >(result));
4489 {
4490 if (temp1)
4491 delete arg1;
4492 }
4493 return resultobj;
4494 fail:
4495 {
4496 if (temp1)
4497 delete arg1;
4498 }
4499 return NULL;
4500 }
4501
4502
4503 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj = 0;
4505 wxString *arg1 = 0 ;
4506 bool result;
4507 bool temp1 = false ;
4508 PyObject * obj0 = 0 ;
4509 char * kwnames[] = {
4510 (char *) "name", NULL
4511 };
4512
4513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4514 {
4515 arg1 = wxString_in_helper(obj0);
4516 if (arg1 == NULL) SWIG_fail;
4517 temp1 = true;
4518 }
4519 {
4520 PyThreadState* __tstate = wxPyBeginAllowThreads();
4521 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4522 wxPyEndAllowThreads(__tstate);
4523 if (PyErr_Occurred()) SWIG_fail;
4524 }
4525 {
4526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4527 }
4528 {
4529 if (temp1)
4530 delete arg1;
4531 }
4532 return resultobj;
4533 fail:
4534 {
4535 if (temp1)
4536 delete arg1;
4537 }
4538 return NULL;
4539 }
4540
4541
4542 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4543 PyObject *resultobj = 0;
4544 wxString *arg1 = 0 ;
4545 bool result;
4546 bool temp1 = false ;
4547 PyObject * obj0 = 0 ;
4548 char * kwnames[] = {
4549 (char *) "name", NULL
4550 };
4551
4552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4553 {
4554 arg1 = wxString_in_helper(obj0);
4555 if (arg1 == NULL) SWIG_fail;
4556 temp1 = true;
4557 }
4558 {
4559 PyThreadState* __tstate = wxPyBeginAllowThreads();
4560 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4561 wxPyEndAllowThreads(__tstate);
4562 if (PyErr_Occurred()) SWIG_fail;
4563 }
4564 {
4565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4566 }
4567 {
4568 if (temp1)
4569 delete arg1;
4570 }
4571 return resultobj;
4572 fail:
4573 {
4574 if (temp1)
4575 delete arg1;
4576 }
4577 return NULL;
4578 }
4579
4580
4581 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4582 PyObject *obj;
4583 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4584 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4585 return SWIG_Py_Void();
4586 }
4587
4588 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589 return SWIG_Python_InitShadowInstance(args);
4590 }
4591
4592 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4593 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4594 return 1;
4595 }
4596
4597
4598 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4599 PyObject *pyobj = 0;
4600
4601 {
4602 #if wxUSE_UNICODE
4603 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4604 #else
4605 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4606 #endif
4607 }
4608 return pyobj;
4609 }
4610
4611
4612 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4613 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4614 return 1;
4615 }
4616
4617
4618 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4619 PyObject *pyobj = 0;
4620
4621 {
4622 #if wxUSE_UNICODE
4623 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4624 #else
4625 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4626 #endif
4627 }
4628 return pyobj;
4629 }
4630
4631
4632 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4633 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4634 return 1;
4635 }
4636
4637
4638 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4639 PyObject *pyobj = 0;
4640
4641 {
4642 #if wxUSE_UNICODE
4643 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4644 #else
4645 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4646 #endif
4647 }
4648 return pyobj;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653 PyObject *resultobj = 0;
4654 long result;
4655
4656 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4657 {
4658 PyThreadState* __tstate = wxPyBeginAllowThreads();
4659 result = (long)wxNewId();
4660 wxPyEndAllowThreads(__tstate);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 resultobj = SWIG_From_long(static_cast< long >(result));
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj = 0;
4672 long arg1 ;
4673 long val1 ;
4674 int ecode1 = 0 ;
4675 PyObject * obj0 = 0 ;
4676 char * kwnames[] = {
4677 (char *) "id", NULL
4678 };
4679
4680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4681 ecode1 = SWIG_AsVal_long(obj0, &val1);
4682 if (!SWIG_IsOK(ecode1)) {
4683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4684 }
4685 arg1 = static_cast< long >(val1);
4686 {
4687 PyThreadState* __tstate = wxPyBeginAllowThreads();
4688 wxRegisterId(arg1);
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 resultobj = SWIG_Py_Void();
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4700 PyObject *resultobj = 0;
4701 long result;
4702
4703 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4704 {
4705 PyThreadState* __tstate = wxPyBeginAllowThreads();
4706 result = (long)wxGetCurrentId();
4707 wxPyEndAllowThreads(__tstate);
4708 if (PyErr_Occurred()) SWIG_fail;
4709 }
4710 resultobj = SWIG_From_long(static_cast< long >(result));
4711 return resultobj;
4712 fail:
4713 return NULL;
4714 }
4715
4716
4717 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4718 PyObject *resultobj = 0;
4719 int arg1 ;
4720 bool result;
4721 int val1 ;
4722 int ecode1 = 0 ;
4723 PyObject * obj0 = 0 ;
4724 char * kwnames[] = {
4725 (char *) "id", NULL
4726 };
4727
4728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4729 ecode1 = SWIG_AsVal_int(obj0, &val1);
4730 if (!SWIG_IsOK(ecode1)) {
4731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4732 }
4733 arg1 = static_cast< int >(val1);
4734 {
4735 PyThreadState* __tstate = wxPyBeginAllowThreads();
4736 result = (bool)wxIsStockID(arg1);
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 {
4741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4742 }
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4750 PyObject *resultobj = 0;
4751 int arg1 ;
4752 wxString *arg2 = 0 ;
4753 bool result;
4754 int val1 ;
4755 int ecode1 = 0 ;
4756 bool temp2 = false ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 char * kwnames[] = {
4760 (char *) "id",(char *) "label", NULL
4761 };
4762
4763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4764 ecode1 = SWIG_AsVal_int(obj0, &val1);
4765 if (!SWIG_IsOK(ecode1)) {
4766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4767 }
4768 arg1 = static_cast< int >(val1);
4769 {
4770 arg2 = wxString_in_helper(obj1);
4771 if (arg2 == NULL) SWIG_fail;
4772 temp2 = true;
4773 }
4774 {
4775 PyThreadState* __tstate = wxPyBeginAllowThreads();
4776 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 {
4781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4782 }
4783 {
4784 if (temp2)
4785 delete arg2;
4786 }
4787 return resultobj;
4788 fail:
4789 {
4790 if (temp2)
4791 delete arg2;
4792 }
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj = 0;
4799 int arg1 ;
4800 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4801 wxString result;
4802 int val1 ;
4803 int ecode1 = 0 ;
4804 long val2 ;
4805 int ecode2 = 0 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "id",(char *) "flags", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4813 ecode1 = SWIG_AsVal_int(obj0, &val1);
4814 if (!SWIG_IsOK(ecode1)) {
4815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4816 }
4817 arg1 = static_cast< int >(val1);
4818 if (obj1) {
4819 ecode2 = SWIG_AsVal_long(obj1, &val2);
4820 if (!SWIG_IsOK(ecode2)) {
4821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4822 }
4823 arg2 = static_cast< long >(val2);
4824 }
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 result = wxGetStockLabel(arg1,arg2);
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 {
4832 #if wxUSE_UNICODE
4833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4834 #else
4835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4836 #endif
4837 }
4838 return resultobj;
4839 fail:
4840 return NULL;
4841 }
4842
4843
4844 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4845 PyObject *resultobj = 0;
4846 int arg1 ;
4847 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4848 wxString result;
4849 int val1 ;
4850 int ecode1 = 0 ;
4851 int val2 ;
4852 int ecode2 = 0 ;
4853 PyObject * obj0 = 0 ;
4854 PyObject * obj1 = 0 ;
4855 char * kwnames[] = {
4856 (char *) "id",(char *) "client", NULL
4857 };
4858
4859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4860 ecode1 = SWIG_AsVal_int(obj0, &val1);
4861 if (!SWIG_IsOK(ecode1)) {
4862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4863 }
4864 arg1 = static_cast< int >(val1);
4865 if (obj1) {
4866 ecode2 = SWIG_AsVal_int(obj1, &val2);
4867 if (!SWIG_IsOK(ecode2)) {
4868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4869 }
4870 arg2 = static_cast< wxStockHelpStringClient >(val2);
4871 }
4872 {
4873 PyThreadState* __tstate = wxPyBeginAllowThreads();
4874 result = wxGetStockHelpString(arg1,arg2);
4875 wxPyEndAllowThreads(__tstate);
4876 if (PyErr_Occurred()) SWIG_fail;
4877 }
4878 {
4879 #if wxUSE_UNICODE
4880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4881 #else
4882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4883 #endif
4884 }
4885 return resultobj;
4886 fail:
4887 return NULL;
4888 }
4889
4890
4891 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4892 PyObject *resultobj = 0;
4893
4894 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4895 {
4896 if (!wxPyCheckForApp()) SWIG_fail;
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 wxBell();
4899 wxPyEndAllowThreads(__tstate);
4900 if (PyErr_Occurred()) SWIG_fail;
4901 }
4902 resultobj = SWIG_Py_Void();
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
4909 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4910 PyObject *resultobj = 0;
4911
4912 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4913 {
4914 if (!wxPyCheckForApp()) SWIG_fail;
4915 PyThreadState* __tstate = wxPyBeginAllowThreads();
4916 wxEndBusyCursor();
4917 wxPyEndAllowThreads(__tstate);
4918 if (PyErr_Occurred()) SWIG_fail;
4919 }
4920 resultobj = SWIG_Py_Void();
4921 return resultobj;
4922 fail:
4923 return NULL;
4924 }
4925
4926
4927 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4928 PyObject *resultobj = 0;
4929 bool arg1 = (bool) true ;
4930 long result;
4931 bool val1 ;
4932 int ecode1 = 0 ;
4933 PyObject * obj0 = 0 ;
4934 char * kwnames[] = {
4935 (char *) "resetTimer", NULL
4936 };
4937
4938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4939 if (obj0) {
4940 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4941 if (!SWIG_IsOK(ecode1)) {
4942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4943 }
4944 arg1 = static_cast< bool >(val1);
4945 }
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 result = (long)wxGetElapsedTime(arg1);
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 resultobj = SWIG_From_long(static_cast< long >(result));
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4960 PyObject *resultobj = 0;
4961 bool result;
4962
4963 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4964 {
4965 PyThreadState* __tstate = wxPyBeginAllowThreads();
4966 result = (bool)wxIsBusy();
4967 wxPyEndAllowThreads(__tstate);
4968 if (PyErr_Occurred()) SWIG_fail;
4969 }
4970 {
4971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4972 }
4973 return resultobj;
4974 fail:
4975 return NULL;
4976 }
4977
4978
4979 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4980 PyObject *resultobj = 0;
4981 wxString result;
4982
4983 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = wxNow();
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 #if wxUSE_UNICODE
4992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4993 #else
4994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4995 #endif
4996 }
4997 return resultobj;
4998 fail:
4999 return NULL;
5000 }
5001
5002
5003 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5004 PyObject *resultobj = 0;
5005 wxString const &arg1_defvalue = wxPyEmptyString ;
5006 wxString *arg1 = (wxString *) &arg1_defvalue ;
5007 bool result;
5008 bool temp1 = false ;
5009 PyObject * obj0 = 0 ;
5010 char * kwnames[] = {
5011 (char *) "command", NULL
5012 };
5013
5014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5015 if (obj0) {
5016 {
5017 arg1 = wxString_in_helper(obj0);
5018 if (arg1 == NULL) SWIG_fail;
5019 temp1 = true;
5020 }
5021 }
5022 {
5023 PyThreadState* __tstate = wxPyBeginAllowThreads();
5024 result = (bool)wxShell((wxString const &)*arg1);
5025 wxPyEndAllowThreads(__tstate);
5026 if (PyErr_Occurred()) SWIG_fail;
5027 }
5028 {
5029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5030 }
5031 {
5032 if (temp1)
5033 delete arg1;
5034 }
5035 return resultobj;
5036 fail:
5037 {
5038 if (temp1)
5039 delete arg1;
5040 }
5041 return NULL;
5042 }
5043
5044
5045 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5046 PyObject *resultobj = 0;
5047
5048 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5049 {
5050 PyThreadState* __tstate = wxPyBeginAllowThreads();
5051 wxStartTimer();
5052 wxPyEndAllowThreads(__tstate);
5053 if (PyErr_Occurred()) SWIG_fail;
5054 }
5055 resultobj = SWIG_Py_Void();
5056 return resultobj;
5057 fail:
5058 return NULL;
5059 }
5060
5061
5062 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5063 PyObject *resultobj = 0;
5064 int *arg1 = (int *) 0 ;
5065 int *arg2 = (int *) 0 ;
5066 int result;
5067 int temp1 ;
5068 int res1 = SWIG_TMPOBJ ;
5069 int temp2 ;
5070 int res2 = SWIG_TMPOBJ ;
5071
5072 arg1 = &temp1;
5073 arg2 = &temp2;
5074 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5075 {
5076 PyThreadState* __tstate = wxPyBeginAllowThreads();
5077 result = (int)wxGetOsVersion(arg1,arg2);
5078 wxPyEndAllowThreads(__tstate);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 resultobj = SWIG_From_int(static_cast< int >(result));
5082 if (SWIG_IsTmpObj(res1)) {
5083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5084 } else {
5085 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5087 }
5088 if (SWIG_IsTmpObj(res2)) {
5089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5090 } else {
5091 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5101 PyObject *resultobj = 0;
5102 wxString result;
5103
5104 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 result = wxGetOsDescription();
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 {
5112 #if wxUSE_UNICODE
5113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5114 #else
5115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5116 #endif
5117 }
5118 return resultobj;
5119 fail:
5120 return NULL;
5121 }
5122
5123
5124 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5125 PyObject *resultobj = 0;
5126 bool result;
5127
5128 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 result = (bool)wxIsPlatformLittleEndian();
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 {
5136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5137 }
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5145 PyObject *resultobj = 0;
5146 bool result;
5147
5148 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 result = (bool)wxIsPlatform64Bit();
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 {
5156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5157 }
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5165 PyObject *resultobj = 0;
5166 wxMemorySize result;
5167
5168 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 result = wxGetFreeMemory();
5172 wxPyEndAllowThreads(__tstate);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 {
5176 #if wxUSE_LONGLONG
5177 resultobj = PyLong_FromLongLong((&result)->GetValue());
5178 #else
5179 resultobj = PyInt_FromLong(result);
5180 #endif
5181 }
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5189 PyObject *resultobj = 0;
5190 wxShutdownFlags arg1 ;
5191 bool result;
5192 int val1 ;
5193 int ecode1 = 0 ;
5194 PyObject * obj0 = 0 ;
5195 char * kwnames[] = {
5196 (char *) "wFlags", NULL
5197 };
5198
5199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5200 ecode1 = SWIG_AsVal_int(obj0, &val1);
5201 if (!SWIG_IsOK(ecode1)) {
5202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5203 }
5204 arg1 = static_cast< wxShutdownFlags >(val1);
5205 {
5206 if (!wxPyCheckForApp()) SWIG_fail;
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 result = (bool)wxShutdown(arg1);
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 {
5213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5214 }
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj = 0;
5223 int arg1 ;
5224 int val1 ;
5225 int ecode1 = 0 ;
5226 PyObject * obj0 = 0 ;
5227 char * kwnames[] = {
5228 (char *) "secs", NULL
5229 };
5230
5231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5232 ecode1 = SWIG_AsVal_int(obj0, &val1);
5233 if (!SWIG_IsOK(ecode1)) {
5234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5235 }
5236 arg1 = static_cast< int >(val1);
5237 {
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 wxSleep(arg1);
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_Py_Void();
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj = 0;
5252 unsigned long arg1 ;
5253 unsigned long val1 ;
5254 int ecode1 = 0 ;
5255 PyObject * obj0 = 0 ;
5256 char * kwnames[] = {
5257 (char *) "milliseconds", NULL
5258 };
5259
5260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5261 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5262 if (!SWIG_IsOK(ecode1)) {
5263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5264 }
5265 arg1 = static_cast< unsigned long >(val1);
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 wxMilliSleep(arg1);
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 resultobj = SWIG_Py_Void();
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5280 PyObject *resultobj = 0;
5281 unsigned long arg1 ;
5282 unsigned long val1 ;
5283 int ecode1 = 0 ;
5284 PyObject * obj0 = 0 ;
5285 char * kwnames[] = {
5286 (char *) "microseconds", NULL
5287 };
5288
5289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5290 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5291 if (!SWIG_IsOK(ecode1)) {
5292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5293 }
5294 arg1 = static_cast< unsigned long >(val1);
5295 {
5296 PyThreadState* __tstate = wxPyBeginAllowThreads();
5297 wxMicroSleep(arg1);
5298 wxPyEndAllowThreads(__tstate);
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 resultobj = SWIG_Py_Void();
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5309 PyObject *resultobj = 0;
5310 bool arg1 ;
5311 bool val1 ;
5312 int ecode1 = 0 ;
5313 PyObject * obj0 = 0 ;
5314 char * kwnames[] = {
5315 (char *) "enable", NULL
5316 };
5317
5318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5319 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5320 if (!SWIG_IsOK(ecode1)) {
5321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5322 }
5323 arg1 = static_cast< bool >(val1);
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 wxEnableTopLevelWindows(arg1);
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = SWIG_Py_Void();
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5338 PyObject *resultobj = 0;
5339 wxString *arg1 = 0 ;
5340 wxString result;
5341 bool temp1 = false ;
5342 PyObject * obj0 = 0 ;
5343 char * kwnames[] = {
5344 (char *) "in", NULL
5345 };
5346
5347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5348 {
5349 arg1 = wxString_in_helper(obj0);
5350 if (arg1 == NULL) SWIG_fail;
5351 temp1 = true;
5352 }
5353 {
5354 PyThreadState* __tstate = wxPyBeginAllowThreads();
5355 result = wxStripMenuCodes((wxString const &)*arg1);
5356 wxPyEndAllowThreads(__tstate);
5357 if (PyErr_Occurred()) SWIG_fail;
5358 }
5359 {
5360 #if wxUSE_UNICODE
5361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5362 #else
5363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5364 #endif
5365 }
5366 {
5367 if (temp1)
5368 delete arg1;
5369 }
5370 return resultobj;
5371 fail:
5372 {
5373 if (temp1)
5374 delete arg1;
5375 }
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382 wxString result;
5383
5384 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 result = wxGetEmailAddress();
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 {
5392 #if wxUSE_UNICODE
5393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5394 #else
5395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5396 #endif
5397 }
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5405 PyObject *resultobj = 0;
5406 wxString result;
5407
5408 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = wxGetHostName();
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 #if wxUSE_UNICODE
5417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5418 #else
5419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5420 #endif
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5429 PyObject *resultobj = 0;
5430 wxString result;
5431
5432 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = wxGetFullHostName();
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 #if wxUSE_UNICODE
5441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5442 #else
5443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5444 #endif
5445 }
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5453 PyObject *resultobj = 0;
5454 wxString result;
5455
5456 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = wxGetUserId();
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 {
5464 #if wxUSE_UNICODE
5465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5466 #else
5467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5468 #endif
5469 }
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxString result;
5479
5480 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5481 {
5482 PyThreadState* __tstate = wxPyBeginAllowThreads();
5483 result = wxGetUserName();
5484 wxPyEndAllowThreads(__tstate);
5485 if (PyErr_Occurred()) SWIG_fail;
5486 }
5487 {
5488 #if wxUSE_UNICODE
5489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5490 #else
5491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5492 #endif
5493 }
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5501 PyObject *resultobj = 0;
5502 wxString result;
5503
5504 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = wxGetHomeDir();
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 {
5512 #if wxUSE_UNICODE
5513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5514 #else
5515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5516 #endif
5517 }
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj = 0;
5526 wxString const &arg1_defvalue = wxPyEmptyString ;
5527 wxString *arg1 = (wxString *) &arg1_defvalue ;
5528 wxString result;
5529 bool temp1 = false ;
5530 PyObject * obj0 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "user", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5536 if (obj0) {
5537 {
5538 arg1 = wxString_in_helper(obj0);
5539 if (arg1 == NULL) SWIG_fail;
5540 temp1 = true;
5541 }
5542 }
5543 {
5544 PyThreadState* __tstate = wxPyBeginAllowThreads();
5545 result = wxGetUserHome((wxString const &)*arg1);
5546 wxPyEndAllowThreads(__tstate);
5547 if (PyErr_Occurred()) SWIG_fail;
5548 }
5549 {
5550 #if wxUSE_UNICODE
5551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5552 #else
5553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5554 #endif
5555 }
5556 {
5557 if (temp1)
5558 delete arg1;
5559 }
5560 return resultobj;
5561 fail:
5562 {
5563 if (temp1)
5564 delete arg1;
5565 }
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 unsigned long result;
5573
5574 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5575 {
5576 PyThreadState* __tstate = wxPyBeginAllowThreads();
5577 result = (unsigned long)wxGetProcessId();
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *resultobj = 0;
5590
5591 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5592 {
5593 PyThreadState* __tstate = wxPyBeginAllowThreads();
5594 wxTrap();
5595 wxPyEndAllowThreads(__tstate);
5596 if (PyErr_Occurred()) SWIG_fail;
5597 }
5598 resultobj = SWIG_Py_Void();
5599 return resultobj;
5600 fail:
5601 return NULL;
5602 }
5603
5604
5605 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5606 PyObject *resultobj = 0;
5607 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5608 wxString *arg1 = (wxString *) &arg1_defvalue ;
5609 wxString const &arg2_defvalue = wxPyEmptyString ;
5610 wxString *arg2 = (wxString *) &arg2_defvalue ;
5611 wxString const &arg3_defvalue = wxPyEmptyString ;
5612 wxString *arg3 = (wxString *) &arg3_defvalue ;
5613 wxString const &arg4_defvalue = wxPyEmptyString ;
5614 wxString *arg4 = (wxString *) &arg4_defvalue ;
5615 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5616 wxString *arg5 = (wxString *) &arg5_defvalue ;
5617 int arg6 = (int) 0 ;
5618 wxWindow *arg7 = (wxWindow *) NULL ;
5619 int arg8 = (int) -1 ;
5620 int arg9 = (int) -1 ;
5621 wxString result;
5622 bool temp1 = false ;
5623 bool temp2 = false ;
5624 bool temp3 = false ;
5625 bool temp4 = false ;
5626 bool temp5 = false ;
5627 int val6 ;
5628 int ecode6 = 0 ;
5629 void *argp7 = 0 ;
5630 int res7 = 0 ;
5631 int val8 ;
5632 int ecode8 = 0 ;
5633 int val9 ;
5634 int ecode9 = 0 ;
5635 PyObject * obj0 = 0 ;
5636 PyObject * obj1 = 0 ;
5637 PyObject * obj2 = 0 ;
5638 PyObject * obj3 = 0 ;
5639 PyObject * obj4 = 0 ;
5640 PyObject * obj5 = 0 ;
5641 PyObject * obj6 = 0 ;
5642 PyObject * obj7 = 0 ;
5643 PyObject * obj8 = 0 ;
5644 char * kwnames[] = {
5645 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5646 };
5647
5648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5649 if (obj0) {
5650 {
5651 arg1 = wxString_in_helper(obj0);
5652 if (arg1 == NULL) SWIG_fail;
5653 temp1 = true;
5654 }
5655 }
5656 if (obj1) {
5657 {
5658 arg2 = wxString_in_helper(obj1);
5659 if (arg2 == NULL) SWIG_fail;
5660 temp2 = true;
5661 }
5662 }
5663 if (obj2) {
5664 {
5665 arg3 = wxString_in_helper(obj2);
5666 if (arg3 == NULL) SWIG_fail;
5667 temp3 = true;
5668 }
5669 }
5670 if (obj3) {
5671 {
5672 arg4 = wxString_in_helper(obj3);
5673 if (arg4 == NULL) SWIG_fail;
5674 temp4 = true;
5675 }
5676 }
5677 if (obj4) {
5678 {
5679 arg5 = wxString_in_helper(obj4);
5680 if (arg5 == NULL) SWIG_fail;
5681 temp5 = true;
5682 }
5683 }
5684 if (obj5) {
5685 ecode6 = SWIG_AsVal_int(obj5, &val6);
5686 if (!SWIG_IsOK(ecode6)) {
5687 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5688 }
5689 arg6 = static_cast< int >(val6);
5690 }
5691 if (obj6) {
5692 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5693 if (!SWIG_IsOK(res7)) {
5694 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5695 }
5696 arg7 = reinterpret_cast< wxWindow * >(argp7);
5697 }
5698 if (obj7) {
5699 ecode8 = SWIG_AsVal_int(obj7, &val8);
5700 if (!SWIG_IsOK(ecode8)) {
5701 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5702 }
5703 arg8 = static_cast< int >(val8);
5704 }
5705 if (obj8) {
5706 ecode9 = SWIG_AsVal_int(obj8, &val9);
5707 if (!SWIG_IsOK(ecode9)) {
5708 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5709 }
5710 arg9 = static_cast< int >(val9);
5711 }
5712 {
5713 if (!wxPyCheckForApp()) SWIG_fail;
5714 PyThreadState* __tstate = wxPyBeginAllowThreads();
5715 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5716 wxPyEndAllowThreads(__tstate);
5717 if (PyErr_Occurred()) SWIG_fail;
5718 }
5719 {
5720 #if wxUSE_UNICODE
5721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5722 #else
5723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5724 #endif
5725 }
5726 {
5727 if (temp1)
5728 delete arg1;
5729 }
5730 {
5731 if (temp2)
5732 delete arg2;
5733 }
5734 {
5735 if (temp3)
5736 delete arg3;
5737 }
5738 {
5739 if (temp4)
5740 delete arg4;
5741 }
5742 {
5743 if (temp5)
5744 delete arg5;
5745 }
5746 return resultobj;
5747 fail:
5748 {
5749 if (temp1)
5750 delete arg1;
5751 }
5752 {
5753 if (temp2)
5754 delete arg2;
5755 }
5756 {
5757 if (temp3)
5758 delete arg3;
5759 }
5760 {
5761 if (temp4)
5762 delete arg4;
5763 }
5764 {
5765 if (temp5)
5766 delete arg5;
5767 }
5768 return NULL;
5769 }
5770
5771
5772 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj = 0;
5774 wxString *arg1 = 0 ;
5775 wxString *arg2 = 0 ;
5776 wxString const &arg3_defvalue = wxPyEmptyString ;
5777 wxString *arg3 = (wxString *) &arg3_defvalue ;
5778 wxWindow *arg4 = (wxWindow *) NULL ;
5779 wxString result;
5780 bool temp1 = false ;
5781 bool temp2 = false ;
5782 bool temp3 = false ;
5783 void *argp4 = 0 ;
5784 int res4 = 0 ;
5785 PyObject * obj0 = 0 ;
5786 PyObject * obj1 = 0 ;
5787 PyObject * obj2 = 0 ;
5788 PyObject * obj3 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5794 {
5795 arg1 = wxString_in_helper(obj0);
5796 if (arg1 == NULL) SWIG_fail;
5797 temp1 = true;
5798 }
5799 {
5800 arg2 = wxString_in_helper(obj1);
5801 if (arg2 == NULL) SWIG_fail;
5802 temp2 = true;
5803 }
5804 if (obj2) {
5805 {
5806 arg3 = wxString_in_helper(obj2);
5807 if (arg3 == NULL) SWIG_fail;
5808 temp3 = true;
5809 }
5810 }
5811 if (obj3) {
5812 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5813 if (!SWIG_IsOK(res4)) {
5814 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5815 }
5816 arg4 = reinterpret_cast< wxWindow * >(argp4);
5817 }
5818 {
5819 if (!wxPyCheckForApp()) SWIG_fail;
5820 PyThreadState* __tstate = wxPyBeginAllowThreads();
5821 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5822 wxPyEndAllowThreads(__tstate);
5823 if (PyErr_Occurred()) SWIG_fail;
5824 }
5825 {
5826 #if wxUSE_UNICODE
5827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5828 #else
5829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5830 #endif
5831 }
5832 {
5833 if (temp1)
5834 delete arg1;
5835 }
5836 {
5837 if (temp2)
5838 delete arg2;
5839 }
5840 {
5841 if (temp3)
5842 delete arg3;
5843 }
5844 return resultobj;
5845 fail:
5846 {
5847 if (temp1)
5848 delete arg1;
5849 }
5850 {
5851 if (temp2)
5852 delete arg2;
5853 }
5854 {
5855 if (temp3)
5856 delete arg3;
5857 }
5858 return NULL;
5859 }
5860
5861
5862 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5863 PyObject *resultobj = 0;
5864 wxString *arg1 = 0 ;
5865 wxString *arg2 = 0 ;
5866 wxString const &arg3_defvalue = wxPyEmptyString ;
5867 wxString *arg3 = (wxString *) &arg3_defvalue ;
5868 wxWindow *arg4 = (wxWindow *) NULL ;
5869 wxString result;
5870 bool temp1 = false ;
5871 bool temp2 = false ;
5872 bool temp3 = false ;
5873 void *argp4 = 0 ;
5874 int res4 = 0 ;
5875 PyObject * obj0 = 0 ;
5876 PyObject * obj1 = 0 ;
5877 PyObject * obj2 = 0 ;
5878 PyObject * obj3 = 0 ;
5879 char * kwnames[] = {
5880 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5881 };
5882
5883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5884 {
5885 arg1 = wxString_in_helper(obj0);
5886 if (arg1 == NULL) SWIG_fail;
5887 temp1 = true;
5888 }
5889 {
5890 arg2 = wxString_in_helper(obj1);
5891 if (arg2 == NULL) SWIG_fail;
5892 temp2 = true;
5893 }
5894 if (obj2) {
5895 {
5896 arg3 = wxString_in_helper(obj2);
5897 if (arg3 == NULL) SWIG_fail;
5898 temp3 = true;
5899 }
5900 }
5901 if (obj3) {
5902 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5903 if (!SWIG_IsOK(res4)) {
5904 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5905 }
5906 arg4 = reinterpret_cast< wxWindow * >(argp4);
5907 }
5908 {
5909 if (!wxPyCheckForApp()) SWIG_fail;
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5912 wxPyEndAllowThreads(__tstate);
5913 if (PyErr_Occurred()) SWIG_fail;
5914 }
5915 {
5916 #if wxUSE_UNICODE
5917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5918 #else
5919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5920 #endif
5921 }
5922 {
5923 if (temp1)
5924 delete arg1;
5925 }
5926 {
5927 if (temp2)
5928 delete arg2;
5929 }
5930 {
5931 if (temp3)
5932 delete arg3;
5933 }
5934 return resultobj;
5935 fail:
5936 {
5937 if (temp1)
5938 delete arg1;
5939 }
5940 {
5941 if (temp2)
5942 delete arg2;
5943 }
5944 {
5945 if (temp3)
5946 delete arg3;
5947 }
5948 return NULL;
5949 }
5950
5951
5952 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5953 PyObject *resultobj = 0;
5954 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5955 wxString *arg1 = (wxString *) &arg1_defvalue ;
5956 wxString const &arg2_defvalue = wxPyEmptyString ;
5957 wxString *arg2 = (wxString *) &arg2_defvalue ;
5958 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5959 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5960 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5961 wxWindow *arg5 = (wxWindow *) NULL ;
5962 wxString result;
5963 bool temp1 = false ;
5964 bool temp2 = false ;
5965 long val3 ;
5966 int ecode3 = 0 ;
5967 wxPoint temp4 ;
5968 void *argp5 = 0 ;
5969 int res5 = 0 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 PyObject * obj2 = 0 ;
5973 PyObject * obj3 = 0 ;
5974 PyObject * obj4 = 0 ;
5975 char * kwnames[] = {
5976 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5977 };
5978
5979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5980 if (obj0) {
5981 {
5982 arg1 = wxString_in_helper(obj0);
5983 if (arg1 == NULL) SWIG_fail;
5984 temp1 = true;
5985 }
5986 }
5987 if (obj1) {
5988 {
5989 arg2 = wxString_in_helper(obj1);
5990 if (arg2 == NULL) SWIG_fail;
5991 temp2 = true;
5992 }
5993 }
5994 if (obj2) {
5995 ecode3 = SWIG_AsVal_long(obj2, &val3);
5996 if (!SWIG_IsOK(ecode3)) {
5997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5998 }
5999 arg3 = static_cast< long >(val3);
6000 }
6001 if (obj3) {
6002 {
6003 arg4 = &temp4;
6004 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6005 }
6006 }
6007 if (obj4) {
6008 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6009 if (!SWIG_IsOK(res5)) {
6010 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6011 }
6012 arg5 = reinterpret_cast< wxWindow * >(argp5);
6013 }
6014 {
6015 if (!wxPyCheckForApp()) SWIG_fail;
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 {
6022 #if wxUSE_UNICODE
6023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6024 #else
6025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6026 #endif
6027 }
6028 {
6029 if (temp1)
6030 delete arg1;
6031 }
6032 {
6033 if (temp2)
6034 delete arg2;
6035 }
6036 return resultobj;
6037 fail:
6038 {
6039 if (temp1)
6040 delete arg1;
6041 }
6042 {
6043 if (temp2)
6044 delete arg2;
6045 }
6046 return NULL;
6047 }
6048
6049
6050 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj = 0;
6052 wxString *arg1 = 0 ;
6053 wxString const &arg2_defvalue = wxPyEmptyString ;
6054 wxString *arg2 = (wxString *) &arg2_defvalue ;
6055 wxString const &arg3_defvalue = wxPyEmptyString ;
6056 wxString *arg3 = (wxString *) &arg3_defvalue ;
6057 wxWindow *arg4 = (wxWindow *) NULL ;
6058 int arg5 = (int) -1 ;
6059 int arg6 = (int) -1 ;
6060 bool arg7 = (bool) true ;
6061 wxString result;
6062 bool temp1 = false ;
6063 bool temp2 = false ;
6064 bool temp3 = false ;
6065 void *argp4 = 0 ;
6066 int res4 = 0 ;
6067 int val5 ;
6068 int ecode5 = 0 ;
6069 int val6 ;
6070 int ecode6 = 0 ;
6071 bool val7 ;
6072 int ecode7 = 0 ;
6073 PyObject * obj0 = 0 ;
6074 PyObject * obj1 = 0 ;
6075 PyObject * obj2 = 0 ;
6076 PyObject * obj3 = 0 ;
6077 PyObject * obj4 = 0 ;
6078 PyObject * obj5 = 0 ;
6079 PyObject * obj6 = 0 ;
6080 char * kwnames[] = {
6081 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6082 };
6083
6084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6085 {
6086 arg1 = wxString_in_helper(obj0);
6087 if (arg1 == NULL) SWIG_fail;
6088 temp1 = true;
6089 }
6090 if (obj1) {
6091 {
6092 arg2 = wxString_in_helper(obj1);
6093 if (arg2 == NULL) SWIG_fail;
6094 temp2 = true;
6095 }
6096 }
6097 if (obj2) {
6098 {
6099 arg3 = wxString_in_helper(obj2);
6100 if (arg3 == NULL) SWIG_fail;
6101 temp3 = true;
6102 }
6103 }
6104 if (obj3) {
6105 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6106 if (!SWIG_IsOK(res4)) {
6107 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6108 }
6109 arg4 = reinterpret_cast< wxWindow * >(argp4);
6110 }
6111 if (obj4) {
6112 ecode5 = SWIG_AsVal_int(obj4, &val5);
6113 if (!SWIG_IsOK(ecode5)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6115 }
6116 arg5 = static_cast< int >(val5);
6117 }
6118 if (obj5) {
6119 ecode6 = SWIG_AsVal_int(obj5, &val6);
6120 if (!SWIG_IsOK(ecode6)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6122 }
6123 arg6 = static_cast< int >(val6);
6124 }
6125 if (obj6) {
6126 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6127 if (!SWIG_IsOK(ecode7)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6129 }
6130 arg7 = static_cast< bool >(val7);
6131 }
6132 {
6133 if (!wxPyCheckForApp()) SWIG_fail;
6134 PyThreadState* __tstate = wxPyBeginAllowThreads();
6135 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 {
6140 #if wxUSE_UNICODE
6141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6142 #else
6143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6144 #endif
6145 }
6146 {
6147 if (temp1)
6148 delete arg1;
6149 }
6150 {
6151 if (temp2)
6152 delete arg2;
6153 }
6154 {
6155 if (temp3)
6156 delete arg3;
6157 }
6158 return resultobj;
6159 fail:
6160 {
6161 if (temp1)
6162 delete arg1;
6163 }
6164 {
6165 if (temp2)
6166 delete arg2;
6167 }
6168 {
6169 if (temp3)
6170 delete arg3;
6171 }
6172 return NULL;
6173 }
6174
6175
6176 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6177 PyObject *resultobj = 0;
6178 wxString *arg1 = 0 ;
6179 wxString const &arg2_defvalue = wxPyEmptyString ;
6180 wxString *arg2 = (wxString *) &arg2_defvalue ;
6181 wxString const &arg3_defvalue = wxPyEmptyString ;
6182 wxString *arg3 = (wxString *) &arg3_defvalue ;
6183 wxWindow *arg4 = (wxWindow *) NULL ;
6184 wxString result;
6185 bool temp1 = false ;
6186 bool temp2 = false ;
6187 bool temp3 = false ;
6188 void *argp4 = 0 ;
6189 int res4 = 0 ;
6190 PyObject * obj0 = 0 ;
6191 PyObject * obj1 = 0 ;
6192 PyObject * obj2 = 0 ;
6193 PyObject * obj3 = 0 ;
6194 char * kwnames[] = {
6195 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6196 };
6197
6198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6199 {
6200 arg1 = wxString_in_helper(obj0);
6201 if (arg1 == NULL) SWIG_fail;
6202 temp1 = true;
6203 }
6204 if (obj1) {
6205 {
6206 arg2 = wxString_in_helper(obj1);
6207 if (arg2 == NULL) SWIG_fail;
6208 temp2 = true;
6209 }
6210 }
6211 if (obj2) {
6212 {
6213 arg3 = wxString_in_helper(obj2);
6214 if (arg3 == NULL) SWIG_fail;
6215 temp3 = true;
6216 }
6217 }
6218 if (obj3) {
6219 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6220 if (!SWIG_IsOK(res4)) {
6221 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6222 }
6223 arg4 = reinterpret_cast< wxWindow * >(argp4);
6224 }
6225 {
6226 if (!wxPyCheckForApp()) SWIG_fail;
6227 PyThreadState* __tstate = wxPyBeginAllowThreads();
6228 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 {
6233 #if wxUSE_UNICODE
6234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6235 #else
6236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6237 #endif
6238 }
6239 {
6240 if (temp1)
6241 delete arg1;
6242 }
6243 {
6244 if (temp2)
6245 delete arg2;
6246 }
6247 {
6248 if (temp3)
6249 delete arg3;
6250 }
6251 return resultobj;
6252 fail:
6253 {
6254 if (temp1)
6255 delete arg1;
6256 }
6257 {
6258 if (temp2)
6259 delete arg2;
6260 }
6261 {
6262 if (temp3)
6263 delete arg3;
6264 }
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxString *arg1 = 0 ;
6272 wxString *arg2 = 0 ;
6273 int arg3 ;
6274 wxString *arg4 = (wxString *) 0 ;
6275 wxWindow *arg5 = (wxWindow *) NULL ;
6276 int arg6 = (int) -1 ;
6277 int arg7 = (int) -1 ;
6278 bool arg8 = (bool) true ;
6279 int arg9 = (int) 150 ;
6280 int arg10 = (int) 200 ;
6281 wxString result;
6282 bool temp1 = false ;
6283 bool temp2 = false ;
6284 void *argp5 = 0 ;
6285 int res5 = 0 ;
6286 int val6 ;
6287 int ecode6 = 0 ;
6288 int val7 ;
6289 int ecode7 = 0 ;
6290 bool val8 ;
6291 int ecode8 = 0 ;
6292 int val9 ;
6293 int ecode9 = 0 ;
6294 int val10 ;
6295 int ecode10 = 0 ;
6296 PyObject * obj0 = 0 ;
6297 PyObject * obj1 = 0 ;
6298 PyObject * obj2 = 0 ;
6299 PyObject * obj3 = 0 ;
6300 PyObject * obj4 = 0 ;
6301 PyObject * obj5 = 0 ;
6302 PyObject * obj6 = 0 ;
6303 PyObject * obj7 = 0 ;
6304 PyObject * obj8 = 0 ;
6305 char * kwnames[] = {
6306 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6307 };
6308
6309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6310 {
6311 arg1 = wxString_in_helper(obj0);
6312 if (arg1 == NULL) SWIG_fail;
6313 temp1 = true;
6314 }
6315 {
6316 arg2 = wxString_in_helper(obj1);
6317 if (arg2 == NULL) SWIG_fail;
6318 temp2 = true;
6319 }
6320 {
6321 arg3 = PyList_Size(obj2);
6322 arg4 = wxString_LIST_helper(obj2);
6323 if (arg4 == NULL) SWIG_fail;
6324 }
6325 if (obj3) {
6326 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6327 if (!SWIG_IsOK(res5)) {
6328 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6329 }
6330 arg5 = reinterpret_cast< wxWindow * >(argp5);
6331 }
6332 if (obj4) {
6333 ecode6 = SWIG_AsVal_int(obj4, &val6);
6334 if (!SWIG_IsOK(ecode6)) {
6335 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6336 }
6337 arg6 = static_cast< int >(val6);
6338 }
6339 if (obj5) {
6340 ecode7 = SWIG_AsVal_int(obj5, &val7);
6341 if (!SWIG_IsOK(ecode7)) {
6342 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6343 }
6344 arg7 = static_cast< int >(val7);
6345 }
6346 if (obj6) {
6347 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6348 if (!SWIG_IsOK(ecode8)) {
6349 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6350 }
6351 arg8 = static_cast< bool >(val8);
6352 }
6353 if (obj7) {
6354 ecode9 = SWIG_AsVal_int(obj7, &val9);
6355 if (!SWIG_IsOK(ecode9)) {
6356 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6357 }
6358 arg9 = static_cast< int >(val9);
6359 }
6360 if (obj8) {
6361 ecode10 = SWIG_AsVal_int(obj8, &val10);
6362 if (!SWIG_IsOK(ecode10)) {
6363 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6364 }
6365 arg10 = static_cast< int >(val10);
6366 }
6367 {
6368 if (!wxPyCheckForApp()) SWIG_fail;
6369 PyThreadState* __tstate = wxPyBeginAllowThreads();
6370 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6371 wxPyEndAllowThreads(__tstate);
6372 if (PyErr_Occurred()) SWIG_fail;
6373 }
6374 {
6375 #if wxUSE_UNICODE
6376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6377 #else
6378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6379 #endif
6380 }
6381 {
6382 if (temp1)
6383 delete arg1;
6384 }
6385 {
6386 if (temp2)
6387 delete arg2;
6388 }
6389 {
6390 if (arg4) delete [] arg4;
6391 }
6392 return resultobj;
6393 fail:
6394 {
6395 if (temp1)
6396 delete arg1;
6397 }
6398 {
6399 if (temp2)
6400 delete arg2;
6401 }
6402 {
6403 if (arg4) delete [] arg4;
6404 }
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = 0;
6411 wxString *arg1 = 0 ;
6412 wxString *arg2 = 0 ;
6413 int arg3 ;
6414 wxString *arg4 = (wxString *) 0 ;
6415 wxWindow *arg5 = (wxWindow *) NULL ;
6416 int arg6 = (int) -1 ;
6417 int arg7 = (int) -1 ;
6418 bool arg8 = (bool) true ;
6419 int arg9 = (int) 150 ;
6420 int arg10 = (int) 200 ;
6421 int result;
6422 bool temp1 = false ;
6423 bool temp2 = false ;
6424 void *argp5 = 0 ;
6425 int res5 = 0 ;
6426 int val6 ;
6427 int ecode6 = 0 ;
6428 int val7 ;
6429 int ecode7 = 0 ;
6430 bool val8 ;
6431 int ecode8 = 0 ;
6432 int val9 ;
6433 int ecode9 = 0 ;
6434 int val10 ;
6435 int ecode10 = 0 ;
6436 PyObject * obj0 = 0 ;
6437 PyObject * obj1 = 0 ;
6438 PyObject * obj2 = 0 ;
6439 PyObject * obj3 = 0 ;
6440 PyObject * obj4 = 0 ;
6441 PyObject * obj5 = 0 ;
6442 PyObject * obj6 = 0 ;
6443 PyObject * obj7 = 0 ;
6444 PyObject * obj8 = 0 ;
6445 char * kwnames[] = {
6446 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6447 };
6448
6449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6450 {
6451 arg1 = wxString_in_helper(obj0);
6452 if (arg1 == NULL) SWIG_fail;
6453 temp1 = true;
6454 }
6455 {
6456 arg2 = wxString_in_helper(obj1);
6457 if (arg2 == NULL) SWIG_fail;
6458 temp2 = true;
6459 }
6460 {
6461 arg3 = PyList_Size(obj2);
6462 arg4 = wxString_LIST_helper(obj2);
6463 if (arg4 == NULL) SWIG_fail;
6464 }
6465 if (obj3) {
6466 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6467 if (!SWIG_IsOK(res5)) {
6468 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6469 }
6470 arg5 = reinterpret_cast< wxWindow * >(argp5);
6471 }
6472 if (obj4) {
6473 ecode6 = SWIG_AsVal_int(obj4, &val6);
6474 if (!SWIG_IsOK(ecode6)) {
6475 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6476 }
6477 arg6 = static_cast< int >(val6);
6478 }
6479 if (obj5) {
6480 ecode7 = SWIG_AsVal_int(obj5, &val7);
6481 if (!SWIG_IsOK(ecode7)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6483 }
6484 arg7 = static_cast< int >(val7);
6485 }
6486 if (obj6) {
6487 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6488 if (!SWIG_IsOK(ecode8)) {
6489 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6490 }
6491 arg8 = static_cast< bool >(val8);
6492 }
6493 if (obj7) {
6494 ecode9 = SWIG_AsVal_int(obj7, &val9);
6495 if (!SWIG_IsOK(ecode9)) {
6496 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6497 }
6498 arg9 = static_cast< int >(val9);
6499 }
6500 if (obj8) {
6501 ecode10 = SWIG_AsVal_int(obj8, &val10);
6502 if (!SWIG_IsOK(ecode10)) {
6503 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6504 }
6505 arg10 = static_cast< int >(val10);
6506 }
6507 {
6508 if (!wxPyCheckForApp()) SWIG_fail;
6509 PyThreadState* __tstate = wxPyBeginAllowThreads();
6510 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 resultobj = SWIG_From_int(static_cast< int >(result));
6515 {
6516 if (temp1)
6517 delete arg1;
6518 }
6519 {
6520 if (temp2)
6521 delete arg2;
6522 }
6523 {
6524 if (arg4) delete [] arg4;
6525 }
6526 return resultobj;
6527 fail:
6528 {
6529 if (temp1)
6530 delete arg1;
6531 }
6532 {
6533 if (temp2)
6534 delete arg2;
6535 }
6536 {
6537 if (arg4) delete [] arg4;
6538 }
6539 return NULL;
6540 }
6541
6542
6543 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6544 PyObject *resultobj = 0;
6545 wxString *arg1 = 0 ;
6546 wxString const &arg2_defvalue = wxPyEmptyString ;
6547 wxString *arg2 = (wxString *) &arg2_defvalue ;
6548 int arg3 = (int) wxOK|wxCENTRE ;
6549 wxWindow *arg4 = (wxWindow *) NULL ;
6550 int arg5 = (int) -1 ;
6551 int arg6 = (int) -1 ;
6552 int result;
6553 bool temp1 = false ;
6554 bool temp2 = false ;
6555 int val3 ;
6556 int ecode3 = 0 ;
6557 void *argp4 = 0 ;
6558 int res4 = 0 ;
6559 int val5 ;
6560 int ecode5 = 0 ;
6561 int val6 ;
6562 int ecode6 = 0 ;
6563 PyObject * obj0 = 0 ;
6564 PyObject * obj1 = 0 ;
6565 PyObject * obj2 = 0 ;
6566 PyObject * obj3 = 0 ;
6567 PyObject * obj4 = 0 ;
6568 PyObject * obj5 = 0 ;
6569 char * kwnames[] = {
6570 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6571 };
6572
6573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6574 {
6575 arg1 = wxString_in_helper(obj0);
6576 if (arg1 == NULL) SWIG_fail;
6577 temp1 = true;
6578 }
6579 if (obj1) {
6580 {
6581 arg2 = wxString_in_helper(obj1);
6582 if (arg2 == NULL) SWIG_fail;
6583 temp2 = true;
6584 }
6585 }
6586 if (obj2) {
6587 ecode3 = SWIG_AsVal_int(obj2, &val3);
6588 if (!SWIG_IsOK(ecode3)) {
6589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6590 }
6591 arg3 = static_cast< int >(val3);
6592 }
6593 if (obj3) {
6594 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6595 if (!SWIG_IsOK(res4)) {
6596 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6597 }
6598 arg4 = reinterpret_cast< wxWindow * >(argp4);
6599 }
6600 if (obj4) {
6601 ecode5 = SWIG_AsVal_int(obj4, &val5);
6602 if (!SWIG_IsOK(ecode5)) {
6603 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6604 }
6605 arg5 = static_cast< int >(val5);
6606 }
6607 if (obj5) {
6608 ecode6 = SWIG_AsVal_int(obj5, &val6);
6609 if (!SWIG_IsOK(ecode6)) {
6610 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6611 }
6612 arg6 = static_cast< int >(val6);
6613 }
6614 {
6615 if (!wxPyCheckForApp()) SWIG_fail;
6616 PyThreadState* __tstate = wxPyBeginAllowThreads();
6617 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6618 wxPyEndAllowThreads(__tstate);
6619 if (PyErr_Occurred()) SWIG_fail;
6620 }
6621 resultobj = SWIG_From_int(static_cast< int >(result));
6622 {
6623 if (temp1)
6624 delete arg1;
6625 }
6626 {
6627 if (temp2)
6628 delete arg2;
6629 }
6630 return resultobj;
6631 fail:
6632 {
6633 if (temp1)
6634 delete arg1;
6635 }
6636 {
6637 if (temp2)
6638 delete arg2;
6639 }
6640 return NULL;
6641 }
6642
6643
6644 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6645 PyObject *resultobj = 0;
6646 wxString *arg1 = 0 ;
6647 wxString *arg2 = 0 ;
6648 wxString *arg3 = 0 ;
6649 long arg4 ;
6650 long arg5 = (long) 0 ;
6651 long arg6 = (long) 100 ;
6652 wxWindow *arg7 = (wxWindow *) NULL ;
6653 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6654 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6655 long result;
6656 bool temp1 = false ;
6657 bool temp2 = false ;
6658 bool temp3 = false ;
6659 long val4 ;
6660 int ecode4 = 0 ;
6661 long val5 ;
6662 int ecode5 = 0 ;
6663 long val6 ;
6664 int ecode6 = 0 ;
6665 void *argp7 = 0 ;
6666 int res7 = 0 ;
6667 wxPoint temp8 ;
6668 PyObject * obj0 = 0 ;
6669 PyObject * obj1 = 0 ;
6670 PyObject * obj2 = 0 ;
6671 PyObject * obj3 = 0 ;
6672 PyObject * obj4 = 0 ;
6673 PyObject * obj5 = 0 ;
6674 PyObject * obj6 = 0 ;
6675 PyObject * obj7 = 0 ;
6676 char * kwnames[] = {
6677 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6678 };
6679
6680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6681 {
6682 arg1 = wxString_in_helper(obj0);
6683 if (arg1 == NULL) SWIG_fail;
6684 temp1 = true;
6685 }
6686 {
6687 arg2 = wxString_in_helper(obj1);
6688 if (arg2 == NULL) SWIG_fail;
6689 temp2 = true;
6690 }
6691 {
6692 arg3 = wxString_in_helper(obj2);
6693 if (arg3 == NULL) SWIG_fail;
6694 temp3 = true;
6695 }
6696 ecode4 = SWIG_AsVal_long(obj3, &val4);
6697 if (!SWIG_IsOK(ecode4)) {
6698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6699 }
6700 arg4 = static_cast< long >(val4);
6701 if (obj4) {
6702 ecode5 = SWIG_AsVal_long(obj4, &val5);
6703 if (!SWIG_IsOK(ecode5)) {
6704 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6705 }
6706 arg5 = static_cast< long >(val5);
6707 }
6708 if (obj5) {
6709 ecode6 = SWIG_AsVal_long(obj5, &val6);
6710 if (!SWIG_IsOK(ecode6)) {
6711 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6712 }
6713 arg6 = static_cast< long >(val6);
6714 }
6715 if (obj6) {
6716 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6717 if (!SWIG_IsOK(res7)) {
6718 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6719 }
6720 arg7 = reinterpret_cast< wxWindow * >(argp7);
6721 }
6722 if (obj7) {
6723 {
6724 arg8 = &temp8;
6725 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6726 }
6727 }
6728 {
6729 if (!wxPyCheckForApp()) SWIG_fail;
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6732 wxPyEndAllowThreads(__tstate);
6733 if (PyErr_Occurred()) SWIG_fail;
6734 }
6735 resultobj = SWIG_From_long(static_cast< long >(result));
6736 {
6737 if (temp1)
6738 delete arg1;
6739 }
6740 {
6741 if (temp2)
6742 delete arg2;
6743 }
6744 {
6745 if (temp3)
6746 delete arg3;
6747 }
6748 return resultobj;
6749 fail:
6750 {
6751 if (temp1)
6752 delete arg1;
6753 }
6754 {
6755 if (temp2)
6756 delete arg2;
6757 }
6758 {
6759 if (temp3)
6760 delete arg3;
6761 }
6762 return NULL;
6763 }
6764
6765
6766 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6767 PyObject *resultobj = 0;
6768 bool result;
6769
6770 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6771 {
6772 if (!wxPyCheckForApp()) SWIG_fail;
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (bool)wxColourDisplay();
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 {
6779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6780 }
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6788 PyObject *resultobj = 0;
6789 int result;
6790
6791 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6792 {
6793 if (!wxPyCheckForApp()) SWIG_fail;
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = (int)wxDisplayDepth();
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_From_int(static_cast< int >(result));
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6807 PyObject *resultobj = 0;
6808 int result;
6809
6810 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6811 {
6812 if (!wxPyCheckForApp()) SWIG_fail;
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (int)wxGetDisplayDepth();
6815 wxPyEndAllowThreads(__tstate);
6816 if (PyErr_Occurred()) SWIG_fail;
6817 }
6818 resultobj = SWIG_From_int(static_cast< int >(result));
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6826 PyObject *resultobj = 0;
6827 int *arg1 = (int *) 0 ;
6828 int *arg2 = (int *) 0 ;
6829 int temp1 ;
6830 int res1 = SWIG_TMPOBJ ;
6831 int temp2 ;
6832 int res2 = SWIG_TMPOBJ ;
6833
6834 arg1 = &temp1;
6835 arg2 = &temp2;
6836 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6837 {
6838 if (!wxPyCheckForApp()) SWIG_fail;
6839 PyThreadState* __tstate = wxPyBeginAllowThreads();
6840 wxDisplaySize(arg1,arg2);
6841 wxPyEndAllowThreads(__tstate);
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 resultobj = SWIG_Py_Void();
6845 if (SWIG_IsTmpObj(res1)) {
6846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6847 } else {
6848 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6850 }
6851 if (SWIG_IsTmpObj(res2)) {
6852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6853 } else {
6854 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6856 }
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6864 PyObject *resultobj = 0;
6865 wxSize result;
6866
6867 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6868 {
6869 if (!wxPyCheckForApp()) SWIG_fail;
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 result = wxGetDisplaySize();
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6883 PyObject *resultobj = 0;
6884 int *arg1 = (int *) 0 ;
6885 int *arg2 = (int *) 0 ;
6886 int temp1 ;
6887 int res1 = SWIG_TMPOBJ ;
6888 int temp2 ;
6889 int res2 = SWIG_TMPOBJ ;
6890
6891 arg1 = &temp1;
6892 arg2 = &temp2;
6893 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6894 {
6895 if (!wxPyCheckForApp()) SWIG_fail;
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 wxDisplaySizeMM(arg1,arg2);
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 resultobj = SWIG_Py_Void();
6902 if (SWIG_IsTmpObj(res1)) {
6903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6904 } else {
6905 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6907 }
6908 if (SWIG_IsTmpObj(res2)) {
6909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6910 } else {
6911 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6913 }
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6921 PyObject *resultobj = 0;
6922 wxSize result;
6923
6924 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6925 {
6926 if (!wxPyCheckForApp()) SWIG_fail;
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = wxGetDisplaySizeMM();
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6940 PyObject *resultobj = 0;
6941 int *arg1 = (int *) 0 ;
6942 int *arg2 = (int *) 0 ;
6943 int *arg3 = (int *) 0 ;
6944 int *arg4 = (int *) 0 ;
6945 int temp1 ;
6946 int res1 = SWIG_TMPOBJ ;
6947 int temp2 ;
6948 int res2 = SWIG_TMPOBJ ;
6949 int temp3 ;
6950 int res3 = SWIG_TMPOBJ ;
6951 int temp4 ;
6952 int res4 = SWIG_TMPOBJ ;
6953
6954 arg1 = &temp1;
6955 arg2 = &temp2;
6956 arg3 = &temp3;
6957 arg4 = &temp4;
6958 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6959 {
6960 if (!wxPyCheckForApp()) SWIG_fail;
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6963 wxPyEndAllowThreads(__tstate);
6964 if (PyErr_Occurred()) SWIG_fail;
6965 }
6966 resultobj = SWIG_Py_Void();
6967 if (SWIG_IsTmpObj(res1)) {
6968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6969 } else {
6970 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6972 }
6973 if (SWIG_IsTmpObj(res2)) {
6974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6975 } else {
6976 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6978 }
6979 if (SWIG_IsTmpObj(res3)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6984 }
6985 if (SWIG_IsTmpObj(res4)) {
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6987 } else {
6988 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6990 }
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6998 PyObject *resultobj = 0;
6999 wxRect result;
7000
7001 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7002 {
7003 if (!wxPyCheckForApp()) SWIG_fail;
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 result = wxGetClientDisplayRect();
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxCursor *arg1 = 0 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 PyObject * obj0 = 0 ;
7022 char * kwnames[] = {
7023 (char *) "cursor", NULL
7024 };
7025
7026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7027 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7028 if (!SWIG_IsOK(res1)) {
7029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7030 }
7031 if (!argp1) {
7032 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7033 }
7034 arg1 = reinterpret_cast< wxCursor * >(argp1);
7035 {
7036 if (!wxPyCheckForApp()) SWIG_fail;
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 wxSetCursor(*arg1);
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 resultobj = SWIG_Py_Void();
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7050 PyObject *resultobj = 0;
7051 void *result = 0 ;
7052
7053 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7054 {
7055 if (!wxPyCheckForApp()) SWIG_fail;
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 result = (void *)wxGetXDisplay();
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7069 PyObject *resultobj = 0;
7070 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7071 void *argp1 = 0 ;
7072 int res1 = 0 ;
7073 PyObject * obj0 = 0 ;
7074 char * kwnames[] = {
7075 (char *) "cursor", NULL
7076 };
7077
7078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7079 if (obj0) {
7080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7081 if (!SWIG_IsOK(res1)) {
7082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7083 }
7084 arg1 = reinterpret_cast< wxCursor * >(argp1);
7085 }
7086 {
7087 if (!wxPyCheckForApp()) SWIG_fail;
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 wxBeginBusyCursor(arg1);
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 resultobj = SWIG_Py_Void();
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7101 PyObject *resultobj = 0;
7102 wxPoint result;
7103
7104 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7105 {
7106 if (!wxPyCheckForApp()) SWIG_fail;
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 result = wxGetMousePosition();
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7120 PyObject *resultobj = 0;
7121 wxWindow *result = 0 ;
7122
7123 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7124 {
7125 if (!wxPyCheckForApp()) SWIG_fail;
7126 PyThreadState* __tstate = wxPyBeginAllowThreads();
7127 result = (wxWindow *)FindWindowAtPointer();
7128 wxPyEndAllowThreads(__tstate);
7129 if (PyErr_Occurred()) SWIG_fail;
7130 }
7131 {
7132 resultobj = wxPyMake_wxObject(result, 0);
7133 }
7134 return resultobj;
7135 fail:
7136 return NULL;
7137 }
7138
7139
7140 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7141 PyObject *resultobj = 0;
7142 wxWindow *result = 0 ;
7143
7144 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7145 {
7146 if (!wxPyCheckForApp()) SWIG_fail;
7147 PyThreadState* __tstate = wxPyBeginAllowThreads();
7148 result = (wxWindow *)wxGetActiveWindow();
7149 wxPyEndAllowThreads(__tstate);
7150 if (PyErr_Occurred()) SWIG_fail;
7151 }
7152 {
7153 resultobj = wxPyMake_wxObject(result, 0);
7154 }
7155 return resultobj;
7156 fail:
7157 return NULL;
7158 }
7159
7160
7161 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7162 PyObject *resultobj = 0;
7163 wxPoint *arg1 = 0 ;
7164 wxWindow *result = 0 ;
7165 wxPoint temp1 ;
7166 PyObject * obj0 = 0 ;
7167 char * kwnames[] = {
7168 (char *) "pt", NULL
7169 };
7170
7171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7172 {
7173 arg1 = &temp1;
7174 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7175 }
7176 {
7177 if (!wxPyCheckForApp()) SWIG_fail;
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 {
7184 resultobj = wxPyMake_wxObject(result, 0);
7185 }
7186 return resultobj;
7187 fail:
7188 return NULL;
7189 }
7190
7191
7192 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7193 PyObject *resultobj = 0;
7194 wxPoint *arg1 = 0 ;
7195 wxWindow *result = 0 ;
7196 wxPoint temp1 ;
7197 PyObject * obj0 = 0 ;
7198 char * kwnames[] = {
7199 (char *) "pt", NULL
7200 };
7201
7202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7203 {
7204 arg1 = &temp1;
7205 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7206 }
7207 {
7208 if (!wxPyCheckForApp()) SWIG_fail;
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 {
7215 resultobj = wxPyMake_wxObject(result, 0);
7216 }
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7224 PyObject *resultobj = 0;
7225 wxWindow *arg1 = (wxWindow *) 0 ;
7226 wxWindow *result = 0 ;
7227 void *argp1 = 0 ;
7228 int res1 = 0 ;
7229 PyObject * obj0 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "win", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7238 }
7239 arg1 = reinterpret_cast< wxWindow * >(argp1);
7240 {
7241 if (!wxPyCheckForApp()) SWIG_fail;
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 result = (wxWindow *)wxGetTopLevelParent(arg1);
7244 wxPyEndAllowThreads(__tstate);
7245 if (PyErr_Occurred()) SWIG_fail;
7246 }
7247 {
7248 resultobj = wxPyMake_wxObject(result, 0);
7249 }
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = 0;
7258 wxString *arg1 = 0 ;
7259 bool result;
7260 bool temp1 = false ;
7261 PyObject * obj0 = 0 ;
7262 char * kwnames[] = {
7263 (char *) "url", NULL
7264 };
7265
7266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7267 {
7268 arg1 = wxString_in_helper(obj0);
7269 if (arg1 == NULL) SWIG_fail;
7270 temp1 = true;
7271 }
7272 {
7273 PyThreadState* __tstate = wxPyBeginAllowThreads();
7274 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7275 wxPyEndAllowThreads(__tstate);
7276 if (PyErr_Occurred()) SWIG_fail;
7277 }
7278 {
7279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7280 }
7281 {
7282 if (temp1)
7283 delete arg1;
7284 }
7285 return resultobj;
7286 fail:
7287 {
7288 if (temp1)
7289 delete arg1;
7290 }
7291 return NULL;
7292 }
7293
7294
7295 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj = 0;
7297 wxKeyCode arg1 ;
7298 bool result;
7299 int val1 ;
7300 int ecode1 = 0 ;
7301 PyObject * obj0 = 0 ;
7302 char * kwnames[] = {
7303 (char *) "key", NULL
7304 };
7305
7306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7307 ecode1 = SWIG_AsVal_int(obj0, &val1);
7308 if (!SWIG_IsOK(ecode1)) {
7309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7310 }
7311 arg1 = static_cast< wxKeyCode >(val1);
7312 {
7313 if (!wxPyCheckForApp()) SWIG_fail;
7314 PyThreadState* __tstate = wxPyBeginAllowThreads();
7315 result = (bool)wxGetKeyState(arg1);
7316 wxPyEndAllowThreads(__tstate);
7317 if (PyErr_Occurred()) SWIG_fail;
7318 }
7319 {
7320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7321 }
7322 return resultobj;
7323 fail:
7324 return NULL;
7325 }
7326
7327
7328 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7329 PyObject *resultobj = 0;
7330 wxMouseState *result = 0 ;
7331
7332 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 result = (wxMouseState *)new wxMouseState();
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7347 PyObject *resultobj = 0;
7348 wxMouseState *arg1 = (wxMouseState *) 0 ;
7349 void *argp1 = 0 ;
7350 int res1 = 0 ;
7351 PyObject *swig_obj[1] ;
7352
7353 if (!args) SWIG_fail;
7354 swig_obj[0] = args;
7355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7358 }
7359 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 delete arg1;
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 resultobj = SWIG_Py_Void();
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7375 PyObject *resultobj = 0;
7376 wxMouseState *arg1 = (wxMouseState *) 0 ;
7377 int result;
7378 void *argp1 = 0 ;
7379 int res1 = 0 ;
7380 PyObject *swig_obj[1] ;
7381
7382 if (!args) SWIG_fail;
7383 swig_obj[0] = args;
7384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7387 }
7388 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7389 {
7390 PyThreadState* __tstate = wxPyBeginAllowThreads();
7391 result = (int)(arg1)->GetX();
7392 wxPyEndAllowThreads(__tstate);
7393 if (PyErr_Occurred()) SWIG_fail;
7394 }
7395 resultobj = SWIG_From_int(static_cast< int >(result));
7396 return resultobj;
7397 fail:
7398 return NULL;
7399 }
7400
7401
7402 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7403 PyObject *resultobj = 0;
7404 wxMouseState *arg1 = (wxMouseState *) 0 ;
7405 int result;
7406 void *argp1 = 0 ;
7407 int res1 = 0 ;
7408 PyObject *swig_obj[1] ;
7409
7410 if (!args) SWIG_fail;
7411 swig_obj[0] = args;
7412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7413 if (!SWIG_IsOK(res1)) {
7414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7415 }
7416 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7417 {
7418 PyThreadState* __tstate = wxPyBeginAllowThreads();
7419 result = (int)(arg1)->GetY();
7420 wxPyEndAllowThreads(__tstate);
7421 if (PyErr_Occurred()) SWIG_fail;
7422 }
7423 resultobj = SWIG_From_int(static_cast< int >(result));
7424 return resultobj;
7425 fail:
7426 return NULL;
7427 }
7428
7429
7430 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7431 PyObject *resultobj = 0;
7432 wxMouseState *arg1 = (wxMouseState *) 0 ;
7433 bool result;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 PyObject *swig_obj[1] ;
7437
7438 if (!args) SWIG_fail;
7439 swig_obj[0] = args;
7440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7441 if (!SWIG_IsOK(res1)) {
7442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7443 }
7444 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 result = (bool)(arg1)->LeftDown();
7448 wxPyEndAllowThreads(__tstate);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7461 PyObject *resultobj = 0;
7462 wxMouseState *arg1 = (wxMouseState *) 0 ;
7463 bool result;
7464 void *argp1 = 0 ;
7465 int res1 = 0 ;
7466 PyObject *swig_obj[1] ;
7467
7468 if (!args) SWIG_fail;
7469 swig_obj[0] = args;
7470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7471 if (!SWIG_IsOK(res1)) {
7472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7473 }
7474 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (bool)(arg1)->MiddleDown();
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 {
7482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7483 }
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7491 PyObject *resultobj = 0;
7492 wxMouseState *arg1 = (wxMouseState *) 0 ;
7493 bool result;
7494 void *argp1 = 0 ;
7495 int res1 = 0 ;
7496 PyObject *swig_obj[1] ;
7497
7498 if (!args) SWIG_fail;
7499 swig_obj[0] = args;
7500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7503 }
7504 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7505 {
7506 PyThreadState* __tstate = wxPyBeginAllowThreads();
7507 result = (bool)(arg1)->RightDown();
7508 wxPyEndAllowThreads(__tstate);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 {
7512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7513 }
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7521 PyObject *resultobj = 0;
7522 wxMouseState *arg1 = (wxMouseState *) 0 ;
7523 bool result;
7524 void *argp1 = 0 ;
7525 int res1 = 0 ;
7526 PyObject *swig_obj[1] ;
7527
7528 if (!args) SWIG_fail;
7529 swig_obj[0] = args;
7530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7531 if (!SWIG_IsOK(res1)) {
7532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7533 }
7534 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 result = (bool)(arg1)->ControlDown();
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 {
7542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7543 }
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7551 PyObject *resultobj = 0;
7552 wxMouseState *arg1 = (wxMouseState *) 0 ;
7553 bool result;
7554 void *argp1 = 0 ;
7555 int res1 = 0 ;
7556 PyObject *swig_obj[1] ;
7557
7558 if (!args) SWIG_fail;
7559 swig_obj[0] = args;
7560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7563 }
7564 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7565 {
7566 PyThreadState* __tstate = wxPyBeginAllowThreads();
7567 result = (bool)(arg1)->ShiftDown();
7568 wxPyEndAllowThreads(__tstate);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 {
7572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7573 }
7574 return resultobj;
7575 fail:
7576 return NULL;
7577 }
7578
7579
7580 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7581 PyObject *resultobj = 0;
7582 wxMouseState *arg1 = (wxMouseState *) 0 ;
7583 bool result;
7584 void *argp1 = 0 ;
7585 int res1 = 0 ;
7586 PyObject *swig_obj[1] ;
7587
7588 if (!args) SWIG_fail;
7589 swig_obj[0] = args;
7590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7593 }
7594 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 result = (bool)(arg1)->AltDown();
7598 wxPyEndAllowThreads(__tstate);
7599 if (PyErr_Occurred()) SWIG_fail;
7600 }
7601 {
7602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7603 }
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7611 PyObject *resultobj = 0;
7612 wxMouseState *arg1 = (wxMouseState *) 0 ;
7613 bool result;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 PyObject *swig_obj[1] ;
7617
7618 if (!args) SWIG_fail;
7619 swig_obj[0] = args;
7620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7621 if (!SWIG_IsOK(res1)) {
7622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7623 }
7624 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 result = (bool)(arg1)->MetaDown();
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 {
7632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7633 }
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7641 PyObject *resultobj = 0;
7642 wxMouseState *arg1 = (wxMouseState *) 0 ;
7643 bool result;
7644 void *argp1 = 0 ;
7645 int res1 = 0 ;
7646 PyObject *swig_obj[1] ;
7647
7648 if (!args) SWIG_fail;
7649 swig_obj[0] = args;
7650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7651 if (!SWIG_IsOK(res1)) {
7652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7653 }
7654 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 result = (bool)(arg1)->CmdDown();
7658 wxPyEndAllowThreads(__tstate);
7659 if (PyErr_Occurred()) SWIG_fail;
7660 }
7661 {
7662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7663 }
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj = 0;
7672 wxMouseState *arg1 = (wxMouseState *) 0 ;
7673 int arg2 ;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 int val2 ;
7677 int ecode2 = 0 ;
7678 PyObject * obj0 = 0 ;
7679 PyObject * obj1 = 0 ;
7680 char * kwnames[] = {
7681 (char *) "self",(char *) "x", NULL
7682 };
7683
7684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7686 if (!SWIG_IsOK(res1)) {
7687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7688 }
7689 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7690 ecode2 = SWIG_AsVal_int(obj1, &val2);
7691 if (!SWIG_IsOK(ecode2)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7693 }
7694 arg2 = static_cast< int >(val2);
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 (arg1)->SetX(arg2);
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 resultobj = SWIG_Py_Void();
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj = 0;
7710 wxMouseState *arg1 = (wxMouseState *) 0 ;
7711 int arg2 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 PyObject * obj0 = 0 ;
7717 PyObject * obj1 = 0 ;
7718 char * kwnames[] = {
7719 (char *) "self",(char *) "y", NULL
7720 };
7721
7722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7724 if (!SWIG_IsOK(res1)) {
7725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7726 }
7727 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7728 ecode2 = SWIG_AsVal_int(obj1, &val2);
7729 if (!SWIG_IsOK(ecode2)) {
7730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7731 }
7732 arg2 = static_cast< int >(val2);
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 (arg1)->SetY(arg2);
7736 wxPyEndAllowThreads(__tstate);
7737 if (PyErr_Occurred()) SWIG_fail;
7738 }
7739 resultobj = SWIG_Py_Void();
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7747 PyObject *resultobj = 0;
7748 wxMouseState *arg1 = (wxMouseState *) 0 ;
7749 bool arg2 ;
7750 void *argp1 = 0 ;
7751 int res1 = 0 ;
7752 bool val2 ;
7753 int ecode2 = 0 ;
7754 PyObject * obj0 = 0 ;
7755 PyObject * obj1 = 0 ;
7756 char * kwnames[] = {
7757 (char *) "self",(char *) "down", NULL
7758 };
7759
7760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7764 }
7765 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7767 if (!SWIG_IsOK(ecode2)) {
7768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7769 }
7770 arg2 = static_cast< bool >(val2);
7771 {
7772 PyThreadState* __tstate = wxPyBeginAllowThreads();
7773 (arg1)->SetLeftDown(arg2);
7774 wxPyEndAllowThreads(__tstate);
7775 if (PyErr_Occurred()) SWIG_fail;
7776 }
7777 resultobj = SWIG_Py_Void();
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj = 0;
7786 wxMouseState *arg1 = (wxMouseState *) 0 ;
7787 bool arg2 ;
7788 void *argp1 = 0 ;
7789 int res1 = 0 ;
7790 bool val2 ;
7791 int ecode2 = 0 ;
7792 PyObject * obj0 = 0 ;
7793 PyObject * obj1 = 0 ;
7794 char * kwnames[] = {
7795 (char *) "self",(char *) "down", NULL
7796 };
7797
7798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7800 if (!SWIG_IsOK(res1)) {
7801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7802 }
7803 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7805 if (!SWIG_IsOK(ecode2)) {
7806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7807 }
7808 arg2 = static_cast< bool >(val2);
7809 {
7810 PyThreadState* __tstate = wxPyBeginAllowThreads();
7811 (arg1)->SetMiddleDown(arg2);
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 resultobj = SWIG_Py_Void();
7816 return resultobj;
7817 fail:
7818 return NULL;
7819 }
7820
7821
7822 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7823 PyObject *resultobj = 0;
7824 wxMouseState *arg1 = (wxMouseState *) 0 ;
7825 bool arg2 ;
7826 void *argp1 = 0 ;
7827 int res1 = 0 ;
7828 bool val2 ;
7829 int ecode2 = 0 ;
7830 PyObject * obj0 = 0 ;
7831 PyObject * obj1 = 0 ;
7832 char * kwnames[] = {
7833 (char *) "self",(char *) "down", NULL
7834 };
7835
7836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7838 if (!SWIG_IsOK(res1)) {
7839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7840 }
7841 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7843 if (!SWIG_IsOK(ecode2)) {
7844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7845 }
7846 arg2 = static_cast< bool >(val2);
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 (arg1)->SetRightDown(arg2);
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = SWIG_Py_Void();
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj = 0;
7862 wxMouseState *arg1 = (wxMouseState *) 0 ;
7863 bool arg2 ;
7864 void *argp1 = 0 ;
7865 int res1 = 0 ;
7866 bool val2 ;
7867 int ecode2 = 0 ;
7868 PyObject * obj0 = 0 ;
7869 PyObject * obj1 = 0 ;
7870 char * kwnames[] = {
7871 (char *) "self",(char *) "down", NULL
7872 };
7873
7874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7876 if (!SWIG_IsOK(res1)) {
7877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7878 }
7879 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7880 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7881 if (!SWIG_IsOK(ecode2)) {
7882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7883 }
7884 arg2 = static_cast< bool >(val2);
7885 {
7886 PyThreadState* __tstate = wxPyBeginAllowThreads();
7887 (arg1)->SetControlDown(arg2);
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj = 0;
7900 wxMouseState *arg1 = (wxMouseState *) 0 ;
7901 bool arg2 ;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 bool val2 ;
7905 int ecode2 = 0 ;
7906 PyObject * obj0 = 0 ;
7907 PyObject * obj1 = 0 ;
7908 char * kwnames[] = {
7909 (char *) "self",(char *) "down", NULL
7910 };
7911
7912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7914 if (!SWIG_IsOK(res1)) {
7915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7916 }
7917 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7918 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7919 if (!SWIG_IsOK(ecode2)) {
7920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7921 }
7922 arg2 = static_cast< bool >(val2);
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 (arg1)->SetShiftDown(arg2);
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 resultobj = SWIG_Py_Void();
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj = 0;
7938 wxMouseState *arg1 = (wxMouseState *) 0 ;
7939 bool arg2 ;
7940 void *argp1 = 0 ;
7941 int res1 = 0 ;
7942 bool val2 ;
7943 int ecode2 = 0 ;
7944 PyObject * obj0 = 0 ;
7945 PyObject * obj1 = 0 ;
7946 char * kwnames[] = {
7947 (char *) "self",(char *) "down", NULL
7948 };
7949
7950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7952 if (!SWIG_IsOK(res1)) {
7953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7954 }
7955 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7957 if (!SWIG_IsOK(ecode2)) {
7958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7959 }
7960 arg2 = static_cast< bool >(val2);
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 (arg1)->SetAltDown(arg2);
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 resultobj = SWIG_Py_Void();
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7975 PyObject *resultobj = 0;
7976 wxMouseState *arg1 = (wxMouseState *) 0 ;
7977 bool arg2 ;
7978 void *argp1 = 0 ;
7979 int res1 = 0 ;
7980 bool val2 ;
7981 int ecode2 = 0 ;
7982 PyObject * obj0 = 0 ;
7983 PyObject * obj1 = 0 ;
7984 char * kwnames[] = {
7985 (char *) "self",(char *) "down", NULL
7986 };
7987
7988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7992 }
7993 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7995 if (!SWIG_IsOK(ecode2)) {
7996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7997 }
7998 arg2 = static_cast< bool >(val2);
7999 {
8000 PyThreadState* __tstate = wxPyBeginAllowThreads();
8001 (arg1)->SetMetaDown(arg2);
8002 wxPyEndAllowThreads(__tstate);
8003 if (PyErr_Occurred()) SWIG_fail;
8004 }
8005 resultobj = SWIG_Py_Void();
8006 return resultobj;
8007 fail:
8008 return NULL;
8009 }
8010
8011
8012 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8013 PyObject *obj;
8014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8015 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8016 return SWIG_Py_Void();
8017 }
8018
8019 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8020 return SWIG_Python_InitShadowInstance(args);
8021 }
8022
8023 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxMouseState result;
8026
8027 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 result = wxGetMouseState();
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8035 return resultobj;
8036 fail:
8037 return NULL;
8038 }
8039
8040
8041 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8042 PyObject *resultobj = 0;
8043
8044 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8045 {
8046 if (!wxPyCheckForApp()) SWIG_fail;
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 wxWakeUpMainThread();
8049 wxPyEndAllowThreads(__tstate);
8050 if (PyErr_Occurred()) SWIG_fail;
8051 }
8052 resultobj = SWIG_Py_Void();
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8060 PyObject *resultobj = 0;
8061
8062 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8063 {
8064 if (!wxPyCheckForApp()) SWIG_fail;
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 wxMutexGuiEnter();
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 resultobj = SWIG_Py_Void();
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079
8080 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8081 {
8082 if (!wxPyCheckForApp()) SWIG_fail;
8083 PyThreadState* __tstate = wxPyBeginAllowThreads();
8084 wxMutexGuiLeave();
8085 wxPyEndAllowThreads(__tstate);
8086 if (PyErr_Occurred()) SWIG_fail;
8087 }
8088 resultobj = SWIG_Py_Void();
8089 return resultobj;
8090 fail:
8091 return NULL;
8092 }
8093
8094
8095 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8096 PyObject *resultobj = 0;
8097 wxMutexGuiLocker *result = 0 ;
8098
8099 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8100 {
8101 if (!wxPyCheckForApp()) SWIG_fail;
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8115 PyObject *resultobj = 0;
8116 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8117 void *argp1 = 0 ;
8118 int res1 = 0 ;
8119 PyObject *swig_obj[1] ;
8120
8121 if (!args) SWIG_fail;
8122 swig_obj[0] = args;
8123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8124 if (!SWIG_IsOK(res1)) {
8125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8126 }
8127 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8128 {
8129 PyThreadState* __tstate = wxPyBeginAllowThreads();
8130 delete arg1;
8131
8132 wxPyEndAllowThreads(__tstate);
8133 if (PyErr_Occurred()) SWIG_fail;
8134 }
8135 resultobj = SWIG_Py_Void();
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8143 PyObject *obj;
8144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8145 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8146 return SWIG_Py_Void();
8147 }
8148
8149 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 return SWIG_Python_InitShadowInstance(args);
8151 }
8152
8153 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8154 PyObject *resultobj = 0;
8155 bool result;
8156
8157 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 result = (bool)wxThread_IsMain();
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 {
8165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8166 }
8167 return resultobj;
8168 fail:
8169 return NULL;
8170 }
8171
8172
8173 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8174 PyObject *resultobj = 0;
8175 wxString *arg1 = 0 ;
8176 wxToolTip *result = 0 ;
8177 bool temp1 = false ;
8178 PyObject * obj0 = 0 ;
8179 char * kwnames[] = {
8180 (char *) "tip", NULL
8181 };
8182
8183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8184 {
8185 arg1 = wxString_in_helper(obj0);
8186 if (arg1 == NULL) SWIG_fail;
8187 temp1 = true;
8188 }
8189 {
8190 if (!wxPyCheckForApp()) SWIG_fail;
8191 PyThreadState* __tstate = wxPyBeginAllowThreads();
8192 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8197 {
8198 if (temp1)
8199 delete arg1;
8200 }
8201 return resultobj;
8202 fail:
8203 {
8204 if (temp1)
8205 delete arg1;
8206 }
8207 return NULL;
8208 }
8209
8210
8211 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8212 PyObject *resultobj = 0;
8213 wxToolTip *arg1 = (wxToolTip *) 0 ;
8214 void *argp1 = 0 ;
8215 int res1 = 0 ;
8216 PyObject *swig_obj[1] ;
8217
8218 if (!args) SWIG_fail;
8219 swig_obj[0] = args;
8220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8223 }
8224 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 delete arg1;
8228
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_Py_Void();
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = 0;
8241 wxToolTip *arg1 = (wxToolTip *) 0 ;
8242 wxString *arg2 = 0 ;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 bool temp2 = false ;
8246 PyObject * obj0 = 0 ;
8247 PyObject * obj1 = 0 ;
8248 char * kwnames[] = {
8249 (char *) "self",(char *) "tip", NULL
8250 };
8251
8252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8254 if (!SWIG_IsOK(res1)) {
8255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8256 }
8257 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8258 {
8259 arg2 = wxString_in_helper(obj1);
8260 if (arg2 == NULL) SWIG_fail;
8261 temp2 = true;
8262 }
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 (arg1)->SetTip((wxString const &)*arg2);
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_Py_Void();
8270 {
8271 if (temp2)
8272 delete arg2;
8273 }
8274 return resultobj;
8275 fail:
8276 {
8277 if (temp2)
8278 delete arg2;
8279 }
8280 return NULL;
8281 }
8282
8283
8284 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8285 PyObject *resultobj = 0;
8286 wxToolTip *arg1 = (wxToolTip *) 0 ;
8287 wxString result;
8288 void *argp1 = 0 ;
8289 int res1 = 0 ;
8290 PyObject *swig_obj[1] ;
8291
8292 if (!args) SWIG_fail;
8293 swig_obj[0] = args;
8294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8295 if (!SWIG_IsOK(res1)) {
8296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8297 }
8298 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 result = (arg1)->GetTip();
8302 wxPyEndAllowThreads(__tstate);
8303 if (PyErr_Occurred()) SWIG_fail;
8304 }
8305 {
8306 #if wxUSE_UNICODE
8307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8308 #else
8309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8310 #endif
8311 }
8312 return resultobj;
8313 fail:
8314 return NULL;
8315 }
8316
8317
8318 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8319 PyObject *resultobj = 0;
8320 wxToolTip *arg1 = (wxToolTip *) 0 ;
8321 wxWindow *result = 0 ;
8322 void *argp1 = 0 ;
8323 int res1 = 0 ;
8324 PyObject *swig_obj[1] ;
8325
8326 if (!args) SWIG_fail;
8327 swig_obj[0] = args;
8328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8329 if (!SWIG_IsOK(res1)) {
8330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8331 }
8332 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 result = (wxWindow *)(arg1)->GetWindow();
8336 wxPyEndAllowThreads(__tstate);
8337 if (PyErr_Occurred()) SWIG_fail;
8338 }
8339 {
8340 resultobj = wxPyMake_wxObject(result, 0);
8341 }
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj = 0;
8350 bool arg1 ;
8351 bool val1 ;
8352 int ecode1 = 0 ;
8353 PyObject * obj0 = 0 ;
8354 char * kwnames[] = {
8355 (char *) "flag", NULL
8356 };
8357
8358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8359 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8360 if (!SWIG_IsOK(ecode1)) {
8361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8362 }
8363 arg1 = static_cast< bool >(val1);
8364 {
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 wxToolTip::Enable(arg1);
8367 wxPyEndAllowThreads(__tstate);
8368 if (PyErr_Occurred()) SWIG_fail;
8369 }
8370 resultobj = SWIG_Py_Void();
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj = 0;
8379 long arg1 ;
8380 long val1 ;
8381 int ecode1 = 0 ;
8382 PyObject * obj0 = 0 ;
8383 char * kwnames[] = {
8384 (char *) "milliseconds", NULL
8385 };
8386
8387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8388 ecode1 = SWIG_AsVal_long(obj0, &val1);
8389 if (!SWIG_IsOK(ecode1)) {
8390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8391 }
8392 arg1 = static_cast< long >(val1);
8393 {
8394 PyThreadState* __tstate = wxPyBeginAllowThreads();
8395 wxToolTip::SetDelay(arg1);
8396 wxPyEndAllowThreads(__tstate);
8397 if (PyErr_Occurred()) SWIG_fail;
8398 }
8399 resultobj = SWIG_Py_Void();
8400 return resultobj;
8401 fail:
8402 return NULL;
8403 }
8404
8405
8406 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8407 PyObject *obj;
8408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8409 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8410 return SWIG_Py_Void();
8411 }
8412
8413 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414 return SWIG_Python_InitShadowInstance(args);
8415 }
8416
8417 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8418 PyObject *resultobj = 0;
8419 wxWindow *arg1 = (wxWindow *) 0 ;
8420 wxSize *arg2 = 0 ;
8421 wxCaret *result = 0 ;
8422 void *argp1 = 0 ;
8423 int res1 = 0 ;
8424 wxSize temp2 ;
8425 PyObject * obj0 = 0 ;
8426 PyObject * obj1 = 0 ;
8427 char * kwnames[] = {
8428 (char *) "window",(char *) "size", NULL
8429 };
8430
8431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8433 if (!SWIG_IsOK(res1)) {
8434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8435 }
8436 arg1 = reinterpret_cast< wxWindow * >(argp1);
8437 {
8438 arg2 = &temp2;
8439 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8440 }
8441 {
8442 if (!wxPyCheckForApp()) SWIG_fail;
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8445 wxPyEndAllowThreads(__tstate);
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 wxCaret *arg1 = (wxCaret *) 0 ;
8458 void *argp1 = 0 ;
8459 int res1 = 0 ;
8460 PyObject *swig_obj[1] ;
8461
8462 if (!args) SWIG_fail;
8463 swig_obj[0] = args;
8464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8465 if (!SWIG_IsOK(res1)) {
8466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8467 }
8468 arg1 = reinterpret_cast< wxCaret * >(argp1);
8469 {
8470 PyThreadState* __tstate = wxPyBeginAllowThreads();
8471 delete arg1;
8472
8473 wxPyEndAllowThreads(__tstate);
8474 if (PyErr_Occurred()) SWIG_fail;
8475 }
8476 resultobj = SWIG_Py_Void();
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8484 PyObject *resultobj = 0;
8485 wxCaret *arg1 = (wxCaret *) 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 PyObject *swig_obj[1] ;
8489
8490 if (!args) SWIG_fail;
8491 swig_obj[0] = args;
8492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8493 if (!SWIG_IsOK(res1)) {
8494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8495 }
8496 arg1 = reinterpret_cast< wxCaret * >(argp1);
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 wxCaret_Destroy(arg1);
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_Py_Void();
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8511 PyObject *resultobj = 0;
8512 wxCaret *arg1 = (wxCaret *) 0 ;
8513 bool result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 PyObject *swig_obj[1] ;
8517
8518 if (!args) SWIG_fail;
8519 swig_obj[0] = args;
8520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8521 if (!SWIG_IsOK(res1)) {
8522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8523 }
8524 arg1 = reinterpret_cast< wxCaret * >(argp1);
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (bool)(arg1)->IsOk();
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 {
8532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8533 }
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8541 PyObject *resultobj = 0;
8542 wxCaret *arg1 = (wxCaret *) 0 ;
8543 bool result;
8544 void *argp1 = 0 ;
8545 int res1 = 0 ;
8546 PyObject *swig_obj[1] ;
8547
8548 if (!args) SWIG_fail;
8549 swig_obj[0] = args;
8550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8551 if (!SWIG_IsOK(res1)) {
8552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8553 }
8554 arg1 = reinterpret_cast< wxCaret * >(argp1);
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (bool)(arg1)->IsVisible();
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 {
8562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8563 }
8564 return resultobj;
8565 fail:
8566 return NULL;
8567 }
8568
8569
8570 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8571 PyObject *resultobj = 0;
8572 wxCaret *arg1 = (wxCaret *) 0 ;
8573 wxPoint result;
8574 void *argp1 = 0 ;
8575 int res1 = 0 ;
8576 PyObject *swig_obj[1] ;
8577
8578 if (!args) SWIG_fail;
8579 swig_obj[0] = args;
8580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8581 if (!SWIG_IsOK(res1)) {
8582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8583 }
8584 arg1 = reinterpret_cast< wxCaret * >(argp1);
8585 {
8586 PyThreadState* __tstate = wxPyBeginAllowThreads();
8587 result = (arg1)->GetPosition();
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8599 PyObject *resultobj = 0;
8600 wxCaret *arg1 = (wxCaret *) 0 ;
8601 int *arg2 = (int *) 0 ;
8602 int *arg3 = (int *) 0 ;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 int temp2 ;
8606 int res2 = SWIG_TMPOBJ ;
8607 int temp3 ;
8608 int res3 = SWIG_TMPOBJ ;
8609 PyObject *swig_obj[1] ;
8610
8611 arg2 = &temp2;
8612 arg3 = &temp3;
8613 if (!args) SWIG_fail;
8614 swig_obj[0] = args;
8615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8616 if (!SWIG_IsOK(res1)) {
8617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8618 }
8619 arg1 = reinterpret_cast< wxCaret * >(argp1);
8620 {
8621 PyThreadState* __tstate = wxPyBeginAllowThreads();
8622 (arg1)->GetPosition(arg2,arg3);
8623 wxPyEndAllowThreads(__tstate);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 resultobj = SWIG_Py_Void();
8627 if (SWIG_IsTmpObj(res2)) {
8628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8629 } else {
8630 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8632 }
8633 if (SWIG_IsTmpObj(res3)) {
8634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8635 } else {
8636 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8638 }
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8646 PyObject *resultobj = 0;
8647 wxCaret *arg1 = (wxCaret *) 0 ;
8648 wxSize result;
8649 void *argp1 = 0 ;
8650 int res1 = 0 ;
8651 PyObject *swig_obj[1] ;
8652
8653 if (!args) SWIG_fail;
8654 swig_obj[0] = args;
8655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8656 if (!SWIG_IsOK(res1)) {
8657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8658 }
8659 arg1 = reinterpret_cast< wxCaret * >(argp1);
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 result = (arg1)->GetSize();
8663 wxPyEndAllowThreads(__tstate);
8664 if (PyErr_Occurred()) SWIG_fail;
8665 }
8666 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8674 PyObject *resultobj = 0;
8675 wxCaret *arg1 = (wxCaret *) 0 ;
8676 int *arg2 = (int *) 0 ;
8677 int *arg3 = (int *) 0 ;
8678 void *argp1 = 0 ;
8679 int res1 = 0 ;
8680 int temp2 ;
8681 int res2 = SWIG_TMPOBJ ;
8682 int temp3 ;
8683 int res3 = SWIG_TMPOBJ ;
8684 PyObject *swig_obj[1] ;
8685
8686 arg2 = &temp2;
8687 arg3 = &temp3;
8688 if (!args) SWIG_fail;
8689 swig_obj[0] = args;
8690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8693 }
8694 arg1 = reinterpret_cast< wxCaret * >(argp1);
8695 {
8696 PyThreadState* __tstate = wxPyBeginAllowThreads();
8697 (arg1)->GetSize(arg2,arg3);
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 resultobj = SWIG_Py_Void();
8702 if (SWIG_IsTmpObj(res2)) {
8703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8704 } else {
8705 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8707 }
8708 if (SWIG_IsTmpObj(res3)) {
8709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8710 } else {
8711 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8713 }
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8721 PyObject *resultobj = 0;
8722 wxCaret *arg1 = (wxCaret *) 0 ;
8723 wxWindow *result = 0 ;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 PyObject *swig_obj[1] ;
8727
8728 if (!args) SWIG_fail;
8729 swig_obj[0] = args;
8730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8731 if (!SWIG_IsOK(res1)) {
8732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8733 }
8734 arg1 = reinterpret_cast< wxCaret * >(argp1);
8735 {
8736 PyThreadState* __tstate = wxPyBeginAllowThreads();
8737 result = (wxWindow *)(arg1)->GetWindow();
8738 wxPyEndAllowThreads(__tstate);
8739 if (PyErr_Occurred()) SWIG_fail;
8740 }
8741 {
8742 resultobj = wxPyMake_wxObject(result, 0);
8743 }
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj = 0;
8752 wxCaret *arg1 = (wxCaret *) 0 ;
8753 int arg2 ;
8754 int arg3 ;
8755 void *argp1 = 0 ;
8756 int res1 = 0 ;
8757 int val2 ;
8758 int ecode2 = 0 ;
8759 int val3 ;
8760 int ecode3 = 0 ;
8761 PyObject * obj0 = 0 ;
8762 PyObject * obj1 = 0 ;
8763 PyObject * obj2 = 0 ;
8764 char * kwnames[] = {
8765 (char *) "self",(char *) "x",(char *) "y", NULL
8766 };
8767
8768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8770 if (!SWIG_IsOK(res1)) {
8771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8772 }
8773 arg1 = reinterpret_cast< wxCaret * >(argp1);
8774 ecode2 = SWIG_AsVal_int(obj1, &val2);
8775 if (!SWIG_IsOK(ecode2)) {
8776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8777 }
8778 arg2 = static_cast< int >(val2);
8779 ecode3 = SWIG_AsVal_int(obj2, &val3);
8780 if (!SWIG_IsOK(ecode3)) {
8781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8782 }
8783 arg3 = static_cast< int >(val3);
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 (arg1)->Move(arg2,arg3);
8787 wxPyEndAllowThreads(__tstate);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_Py_Void();
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxCaret *arg1 = (wxCaret *) 0 ;
8800 wxPoint *arg2 = 0 ;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 wxPoint temp2 ;
8804 PyObject * obj0 = 0 ;
8805 PyObject * obj1 = 0 ;
8806 char * kwnames[] = {
8807 (char *) "self",(char *) "pt", NULL
8808 };
8809
8810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8814 }
8815 arg1 = reinterpret_cast< wxCaret * >(argp1);
8816 {
8817 arg2 = &temp2;
8818 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8819 }
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 (arg1)->Move((wxPoint const &)*arg2);
8823 wxPyEndAllowThreads(__tstate);
8824 if (PyErr_Occurred()) SWIG_fail;
8825 }
8826 resultobj = SWIG_Py_Void();
8827 return resultobj;
8828 fail:
8829 return NULL;
8830 }
8831
8832
8833 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8834 PyObject *resultobj = 0;
8835 wxCaret *arg1 = (wxCaret *) 0 ;
8836 int arg2 ;
8837 int arg3 ;
8838 void *argp1 = 0 ;
8839 int res1 = 0 ;
8840 int val2 ;
8841 int ecode2 = 0 ;
8842 int val3 ;
8843 int ecode3 = 0 ;
8844 PyObject * obj0 = 0 ;
8845 PyObject * obj1 = 0 ;
8846 PyObject * obj2 = 0 ;
8847 char * kwnames[] = {
8848 (char *) "self",(char *) "width",(char *) "height", NULL
8849 };
8850
8851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8853 if (!SWIG_IsOK(res1)) {
8854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8855 }
8856 arg1 = reinterpret_cast< wxCaret * >(argp1);
8857 ecode2 = SWIG_AsVal_int(obj1, &val2);
8858 if (!SWIG_IsOK(ecode2)) {
8859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8860 }
8861 arg2 = static_cast< int >(val2);
8862 ecode3 = SWIG_AsVal_int(obj2, &val3);
8863 if (!SWIG_IsOK(ecode3)) {
8864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8865 }
8866 arg3 = static_cast< int >(val3);
8867 {
8868 PyThreadState* __tstate = wxPyBeginAllowThreads();
8869 (arg1)->SetSize(arg2,arg3);
8870 wxPyEndAllowThreads(__tstate);
8871 if (PyErr_Occurred()) SWIG_fail;
8872 }
8873 resultobj = SWIG_Py_Void();
8874 return resultobj;
8875 fail:
8876 return NULL;
8877 }
8878
8879
8880 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj = 0;
8882 wxCaret *arg1 = (wxCaret *) 0 ;
8883 wxSize *arg2 = 0 ;
8884 void *argp1 = 0 ;
8885 int res1 = 0 ;
8886 wxSize temp2 ;
8887 PyObject * obj0 = 0 ;
8888 PyObject * obj1 = 0 ;
8889 char * kwnames[] = {
8890 (char *) "self",(char *) "size", NULL
8891 };
8892
8893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8895 if (!SWIG_IsOK(res1)) {
8896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8897 }
8898 arg1 = reinterpret_cast< wxCaret * >(argp1);
8899 {
8900 arg2 = &temp2;
8901 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8902 }
8903 {
8904 PyThreadState* __tstate = wxPyBeginAllowThreads();
8905 (arg1)->SetSize((wxSize const &)*arg2);
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 resultobj = SWIG_Py_Void();
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj = 0;
8918 wxCaret *arg1 = (wxCaret *) 0 ;
8919 int arg2 = (int) true ;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 int val2 ;
8923 int ecode2 = 0 ;
8924 PyObject * obj0 = 0 ;
8925 PyObject * obj1 = 0 ;
8926 char * kwnames[] = {
8927 (char *) "self",(char *) "show", NULL
8928 };
8929
8930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8932 if (!SWIG_IsOK(res1)) {
8933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8934 }
8935 arg1 = reinterpret_cast< wxCaret * >(argp1);
8936 if (obj1) {
8937 ecode2 = SWIG_AsVal_int(obj1, &val2);
8938 if (!SWIG_IsOK(ecode2)) {
8939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8940 }
8941 arg2 = static_cast< int >(val2);
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 (arg1)->Show(arg2);
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxCaret *arg1 = (wxCaret *) 0 ;
8959 void *argp1 = 0 ;
8960 int res1 = 0 ;
8961 PyObject *swig_obj[1] ;
8962
8963 if (!args) SWIG_fail;
8964 swig_obj[0] = args;
8965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8966 if (!SWIG_IsOK(res1)) {
8967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8968 }
8969 arg1 = reinterpret_cast< wxCaret * >(argp1);
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 (arg1)->Hide();
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 resultobj = SWIG_Py_Void();
8977 return resultobj;
8978 fail:
8979 return NULL;
8980 }
8981
8982
8983 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8984 PyObject *resultobj = 0;
8985 int result;
8986
8987 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 result = (int)wxCaret::GetBlinkTime();
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 resultobj = SWIG_From_int(static_cast< int >(result));
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj = 0;
9003 int arg1 ;
9004 int val1 ;
9005 int ecode1 = 0 ;
9006 PyObject * obj0 = 0 ;
9007 char * kwnames[] = {
9008 (char *) "milliseconds", NULL
9009 };
9010
9011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9012 ecode1 = SWIG_AsVal_int(obj0, &val1);
9013 if (!SWIG_IsOK(ecode1)) {
9014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9015 }
9016 arg1 = static_cast< int >(val1);
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxCaret::SetBlinkTime(arg1);
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 resultobj = SWIG_Py_Void();
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9031 PyObject *obj;
9032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9033 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9034 return SWIG_Py_Void();
9035 }
9036
9037 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9038 return SWIG_Python_InitShadowInstance(args);
9039 }
9040
9041 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj = 0;
9043 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9044 wxBusyCursor *result = 0 ;
9045 void *argp1 = 0 ;
9046 int res1 = 0 ;
9047 PyObject * obj0 = 0 ;
9048 char * kwnames[] = {
9049 (char *) "cursor", NULL
9050 };
9051
9052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9053 if (obj0) {
9054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9055 if (!SWIG_IsOK(res1)) {
9056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9057 }
9058 arg1 = reinterpret_cast< wxCursor * >(argp1);
9059 }
9060 {
9061 if (!wxPyCheckForApp()) SWIG_fail;
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9068 return resultobj;
9069 fail:
9070 return NULL;
9071 }
9072
9073
9074 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9075 PyObject *resultobj = 0;
9076 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9077 void *argp1 = 0 ;
9078 int res1 = 0 ;
9079 PyObject *swig_obj[1] ;
9080
9081 if (!args) SWIG_fail;
9082 swig_obj[0] = args;
9083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9084 if (!SWIG_IsOK(res1)) {
9085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9086 }
9087 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9088 {
9089 PyThreadState* __tstate = wxPyBeginAllowThreads();
9090 delete arg1;
9091
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_Py_Void();
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *obj;
9104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9105 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9106 return SWIG_Py_Void();
9107 }
9108
9109 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9110 return SWIG_Python_InitShadowInstance(args);
9111 }
9112
9113 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj = 0;
9115 wxWindow *arg1 = (wxWindow *) NULL ;
9116 wxWindowDisabler *result = 0 ;
9117 void *argp1 = 0 ;
9118 int res1 = 0 ;
9119 PyObject * obj0 = 0 ;
9120 char * kwnames[] = {
9121 (char *) "winToSkip", NULL
9122 };
9123
9124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9125 if (obj0) {
9126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9127 if (!SWIG_IsOK(res1)) {
9128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9129 }
9130 arg1 = reinterpret_cast< wxWindow * >(argp1);
9131 }
9132 {
9133 if (!wxPyCheckForApp()) SWIG_fail;
9134 PyThreadState* __tstate = wxPyBeginAllowThreads();
9135 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9140 return resultobj;
9141 fail:
9142 return NULL;
9143 }
9144
9145
9146 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147 PyObject *resultobj = 0;
9148 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9149 void *argp1 = 0 ;
9150 int res1 = 0 ;
9151 PyObject *swig_obj[1] ;
9152
9153 if (!args) SWIG_fail;
9154 swig_obj[0] = args;
9155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9156 if (!SWIG_IsOK(res1)) {
9157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9158 }
9159 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 delete arg1;
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 resultobj = SWIG_Py_Void();
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9175 PyObject *obj;
9176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9177 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9178 return SWIG_Py_Void();
9179 }
9180
9181 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9182 return SWIG_Python_InitShadowInstance(args);
9183 }
9184
9185 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj = 0;
9187 wxString *arg1 = 0 ;
9188 wxBusyInfo *result = 0 ;
9189 bool temp1 = false ;
9190 PyObject * obj0 = 0 ;
9191 char * kwnames[] = {
9192 (char *) "message", NULL
9193 };
9194
9195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9196 {
9197 arg1 = wxString_in_helper(obj0);
9198 if (arg1 == NULL) SWIG_fail;
9199 temp1 = true;
9200 }
9201 {
9202 if (!wxPyCheckForApp()) SWIG_fail;
9203 PyThreadState* __tstate = wxPyBeginAllowThreads();
9204 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9205 wxPyEndAllowThreads(__tstate);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9209 {
9210 if (temp1)
9211 delete arg1;
9212 }
9213 return resultobj;
9214 fail:
9215 {
9216 if (temp1)
9217 delete arg1;
9218 }
9219 return NULL;
9220 }
9221
9222
9223 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9224 PyObject *resultobj = 0;
9225 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9226 void *argp1 = 0 ;
9227 int res1 = 0 ;
9228 PyObject *swig_obj[1] ;
9229
9230 if (!args) SWIG_fail;
9231 swig_obj[0] = args;
9232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9233 if (!SWIG_IsOK(res1)) {
9234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9235 }
9236 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 delete arg1;
9240
9241 wxPyEndAllowThreads(__tstate);
9242 if (PyErr_Occurred()) SWIG_fail;
9243 }
9244 resultobj = SWIG_Py_Void();
9245 return resultobj;
9246 fail:
9247 return NULL;
9248 }
9249
9250
9251 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9252 PyObject *obj;
9253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9254 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9255 return SWIG_Py_Void();
9256 }
9257
9258 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 return SWIG_Python_InitShadowInstance(args);
9260 }
9261
9262 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 PyObject *resultobj = 0;
9264 wxStopWatch *result = 0 ;
9265
9266 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9267 {
9268 PyThreadState* __tstate = wxPyBeginAllowThreads();
9269 result = (wxStopWatch *)new wxStopWatch();
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj = 0;
9282 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9283 long arg2 = (long) 0 ;
9284 void *argp1 = 0 ;
9285 int res1 = 0 ;
9286 long val2 ;
9287 int ecode2 = 0 ;
9288 PyObject * obj0 = 0 ;
9289 PyObject * obj1 = 0 ;
9290 char * kwnames[] = {
9291 (char *) "self",(char *) "t0", NULL
9292 };
9293
9294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9296 if (!SWIG_IsOK(res1)) {
9297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9298 }
9299 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9300 if (obj1) {
9301 ecode2 = SWIG_AsVal_long(obj1, &val2);
9302 if (!SWIG_IsOK(ecode2)) {
9303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9304 }
9305 arg2 = static_cast< long >(val2);
9306 }
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 (arg1)->Start(arg2);
9310 wxPyEndAllowThreads(__tstate);
9311 if (PyErr_Occurred()) SWIG_fail;
9312 }
9313 resultobj = SWIG_Py_Void();
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9321 PyObject *resultobj = 0;
9322 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9323 void *argp1 = 0 ;
9324 int res1 = 0 ;
9325 PyObject *swig_obj[1] ;
9326
9327 if (!args) SWIG_fail;
9328 swig_obj[0] = args;
9329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9330 if (!SWIG_IsOK(res1)) {
9331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9332 }
9333 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9334 {
9335 PyThreadState* __tstate = wxPyBeginAllowThreads();
9336 (arg1)->Pause();
9337 wxPyEndAllowThreads(__tstate);
9338 if (PyErr_Occurred()) SWIG_fail;
9339 }
9340 resultobj = SWIG_Py_Void();
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9348 PyObject *resultobj = 0;
9349 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9350 void *argp1 = 0 ;
9351 int res1 = 0 ;
9352 PyObject *swig_obj[1] ;
9353
9354 if (!args) SWIG_fail;
9355 swig_obj[0] = args;
9356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9357 if (!SWIG_IsOK(res1)) {
9358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9359 }
9360 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9361 {
9362 PyThreadState* __tstate = wxPyBeginAllowThreads();
9363 (arg1)->Resume();
9364 wxPyEndAllowThreads(__tstate);
9365 if (PyErr_Occurred()) SWIG_fail;
9366 }
9367 resultobj = SWIG_Py_Void();
9368 return resultobj;
9369 fail:
9370 return NULL;
9371 }
9372
9373
9374 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9375 PyObject *resultobj = 0;
9376 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9377 long result;
9378 void *argp1 = 0 ;
9379 int res1 = 0 ;
9380 PyObject *swig_obj[1] ;
9381
9382 if (!args) SWIG_fail;
9383 swig_obj[0] = args;
9384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9385 if (!SWIG_IsOK(res1)) {
9386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9387 }
9388 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9389 {
9390 PyThreadState* __tstate = wxPyBeginAllowThreads();
9391 result = (long)((wxStopWatch const *)arg1)->Time();
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 resultobj = SWIG_From_long(static_cast< long >(result));
9396 return resultobj;
9397 fail:
9398 return NULL;
9399 }
9400
9401
9402 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9403 PyObject *obj;
9404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9405 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9406 return SWIG_Py_Void();
9407 }
9408
9409 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9410 return SWIG_Python_InitShadowInstance(args);
9411 }
9412
9413 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9414 PyObject *resultobj = 0;
9415 int arg1 = (int) 9 ;
9416 int arg2 = (int) wxID_FILE1 ;
9417 wxFileHistory *result = 0 ;
9418 int val1 ;
9419 int ecode1 = 0 ;
9420 int val2 ;
9421 int ecode2 = 0 ;
9422 PyObject * obj0 = 0 ;
9423 PyObject * obj1 = 0 ;
9424 char * kwnames[] = {
9425 (char *) "maxFiles",(char *) "idBase", NULL
9426 };
9427
9428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9429 if (obj0) {
9430 ecode1 = SWIG_AsVal_int(obj0, &val1);
9431 if (!SWIG_IsOK(ecode1)) {
9432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9433 }
9434 arg1 = static_cast< int >(val1);
9435 }
9436 if (obj1) {
9437 ecode2 = SWIG_AsVal_int(obj1, &val2);
9438 if (!SWIG_IsOK(ecode2)) {
9439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9440 }
9441 arg2 = static_cast< int >(val2);
9442 }
9443 {
9444 PyThreadState* __tstate = wxPyBeginAllowThreads();
9445 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9446 wxPyEndAllowThreads(__tstate);
9447 if (PyErr_Occurred()) SWIG_fail;
9448 }
9449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9450 return resultobj;
9451 fail:
9452 return NULL;
9453 }
9454
9455
9456 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9457 PyObject *resultobj = 0;
9458 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9459 void *argp1 = 0 ;
9460 int res1 = 0 ;
9461 PyObject *swig_obj[1] ;
9462
9463 if (!args) SWIG_fail;
9464 swig_obj[0] = args;
9465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9466 if (!SWIG_IsOK(res1)) {
9467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9468 }
9469 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 delete arg1;
9473
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 resultobj = SWIG_Py_Void();
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj = 0;
9486 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9487 wxString *arg2 = 0 ;
9488 void *argp1 = 0 ;
9489 int res1 = 0 ;
9490 bool temp2 = false ;
9491 PyObject * obj0 = 0 ;
9492 PyObject * obj1 = 0 ;
9493 char * kwnames[] = {
9494 (char *) "self",(char *) "file", NULL
9495 };
9496
9497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9499 if (!SWIG_IsOK(res1)) {
9500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9501 }
9502 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9503 {
9504 arg2 = wxString_in_helper(obj1);
9505 if (arg2 == NULL) SWIG_fail;
9506 temp2 = true;
9507 }
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 (arg1)->AddFileToHistory((wxString const &)*arg2);
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_Py_Void();
9515 {
9516 if (temp2)
9517 delete arg2;
9518 }
9519 return resultobj;
9520 fail:
9521 {
9522 if (temp2)
9523 delete arg2;
9524 }
9525 return NULL;
9526 }
9527
9528
9529 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj = 0;
9531 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9532 int arg2 ;
9533 void *argp1 = 0 ;
9534 int res1 = 0 ;
9535 int val2 ;
9536 int ecode2 = 0 ;
9537 PyObject * obj0 = 0 ;
9538 PyObject * obj1 = 0 ;
9539 char * kwnames[] = {
9540 (char *) "self",(char *) "i", NULL
9541 };
9542
9543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9545 if (!SWIG_IsOK(res1)) {
9546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9547 }
9548 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9549 ecode2 = SWIG_AsVal_int(obj1, &val2);
9550 if (!SWIG_IsOK(ecode2)) {
9551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9552 }
9553 arg2 = static_cast< int >(val2);
9554 {
9555 PyThreadState* __tstate = wxPyBeginAllowThreads();
9556 (arg1)->RemoveFileFromHistory(arg2);
9557 wxPyEndAllowThreads(__tstate);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 resultobj = SWIG_Py_Void();
9561 return resultobj;
9562 fail:
9563 return NULL;
9564 }
9565
9566
9567 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9568 PyObject *resultobj = 0;
9569 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9570 int result;
9571 void *argp1 = 0 ;
9572 int res1 = 0 ;
9573 PyObject *swig_obj[1] ;
9574
9575 if (!args) SWIG_fail;
9576 swig_obj[0] = args;
9577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9578 if (!SWIG_IsOK(res1)) {
9579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9580 }
9581 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_From_int(static_cast< int >(result));
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj = 0;
9597 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9598 wxMenu *arg2 = (wxMenu *) 0 ;
9599 void *argp1 = 0 ;
9600 int res1 = 0 ;
9601 void *argp2 = 0 ;
9602 int res2 = 0 ;
9603 PyObject * obj0 = 0 ;
9604 PyObject * obj1 = 0 ;
9605 char * kwnames[] = {
9606 (char *) "self",(char *) "menu", NULL
9607 };
9608
9609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9611 if (!SWIG_IsOK(res1)) {
9612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9613 }
9614 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9616 if (!SWIG_IsOK(res2)) {
9617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9618 }
9619 arg2 = reinterpret_cast< wxMenu * >(argp2);
9620 {
9621 PyThreadState* __tstate = wxPyBeginAllowThreads();
9622 (arg1)->UseMenu(arg2);
9623 wxPyEndAllowThreads(__tstate);
9624 if (PyErr_Occurred()) SWIG_fail;
9625 }
9626 resultobj = SWIG_Py_Void();
9627 return resultobj;
9628 fail:
9629 return NULL;
9630 }
9631
9632
9633 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj = 0;
9635 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9636 wxMenu *arg2 = (wxMenu *) 0 ;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 void *argp2 = 0 ;
9640 int res2 = 0 ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 char * kwnames[] = {
9644 (char *) "self",(char *) "menu", NULL
9645 };
9646
9647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9649 if (!SWIG_IsOK(res1)) {
9650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9651 }
9652 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9654 if (!SWIG_IsOK(res2)) {
9655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9656 }
9657 arg2 = reinterpret_cast< wxMenu * >(argp2);
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 (arg1)->RemoveMenu(arg2);
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 resultobj = SWIG_Py_Void();
9665 return resultobj;
9666 fail:
9667 return NULL;
9668 }
9669
9670
9671 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9672 PyObject *resultobj = 0;
9673 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9674 wxConfigBase *arg2 = 0 ;
9675 void *argp1 = 0 ;
9676 int res1 = 0 ;
9677 void *argp2 = 0 ;
9678 int res2 = 0 ;
9679 PyObject * obj0 = 0 ;
9680 PyObject * obj1 = 0 ;
9681 char * kwnames[] = {
9682 (char *) "self",(char *) "config", NULL
9683 };
9684
9685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9687 if (!SWIG_IsOK(res1)) {
9688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9689 }
9690 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9691 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9692 if (!SWIG_IsOK(res2)) {
9693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9694 }
9695 if (!argp2) {
9696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9697 }
9698 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9699 {
9700 PyThreadState* __tstate = wxPyBeginAllowThreads();
9701 (arg1)->Load(*arg2);
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 resultobj = SWIG_Py_Void();
9706 return resultobj;
9707 fail:
9708 return NULL;
9709 }
9710
9711
9712 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9713 PyObject *resultobj = 0;
9714 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9715 wxConfigBase *arg2 = 0 ;
9716 void *argp1 = 0 ;
9717 int res1 = 0 ;
9718 void *argp2 = 0 ;
9719 int res2 = 0 ;
9720 PyObject * obj0 = 0 ;
9721 PyObject * obj1 = 0 ;
9722 char * kwnames[] = {
9723 (char *) "self",(char *) "config", NULL
9724 };
9725
9726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9728 if (!SWIG_IsOK(res1)) {
9729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9730 }
9731 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9733 if (!SWIG_IsOK(res2)) {
9734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9735 }
9736 if (!argp2) {
9737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9738 }
9739 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9740 {
9741 PyThreadState* __tstate = wxPyBeginAllowThreads();
9742 (arg1)->Save(*arg2);
9743 wxPyEndAllowThreads(__tstate);
9744 if (PyErr_Occurred()) SWIG_fail;
9745 }
9746 resultobj = SWIG_Py_Void();
9747 return resultobj;
9748 fail:
9749 return NULL;
9750 }
9751
9752
9753 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9754 PyObject *resultobj = 0;
9755 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9756 void *argp1 = 0 ;
9757 int res1 = 0 ;
9758 PyObject *swig_obj[1] ;
9759
9760 if (!args) SWIG_fail;
9761 swig_obj[0] = args;
9762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9763 if (!SWIG_IsOK(res1)) {
9764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9765 }
9766 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 (arg1)->AddFilesToMenu();
9770 wxPyEndAllowThreads(__tstate);
9771 if (PyErr_Occurred()) SWIG_fail;
9772 }
9773 resultobj = SWIG_Py_Void();
9774 return resultobj;
9775 fail:
9776 return NULL;
9777 }
9778
9779
9780 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9781 PyObject *resultobj = 0;
9782 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9783 wxMenu *arg2 = (wxMenu *) 0 ;
9784 void *argp1 = 0 ;
9785 int res1 = 0 ;
9786 void *argp2 = 0 ;
9787 int res2 = 0 ;
9788 PyObject * obj0 = 0 ;
9789 PyObject * obj1 = 0 ;
9790 char * kwnames[] = {
9791 (char *) "self",(char *) "menu", NULL
9792 };
9793
9794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9796 if (!SWIG_IsOK(res1)) {
9797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9798 }
9799 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9801 if (!SWIG_IsOK(res2)) {
9802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9803 }
9804 arg2 = reinterpret_cast< wxMenu * >(argp2);
9805 {
9806 PyThreadState* __tstate = wxPyBeginAllowThreads();
9807 (arg1)->AddFilesToMenu(arg2);
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 resultobj = SWIG_Py_Void();
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9819 PyObject *resultobj = 0;
9820 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9821 int arg2 ;
9822 wxString result;
9823 void *argp1 = 0 ;
9824 int res1 = 0 ;
9825 int val2 ;
9826 int ecode2 = 0 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char * kwnames[] = {
9830 (char *) "self",(char *) "i", NULL
9831 };
9832
9833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9837 }
9838 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9839 ecode2 = SWIG_AsVal_int(obj1, &val2);
9840 if (!SWIG_IsOK(ecode2)) {
9841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9842 }
9843 arg2 = static_cast< int >(val2);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 {
9851 #if wxUSE_UNICODE
9852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9853 #else
9854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9855 #endif
9856 }
9857 return resultobj;
9858 fail:
9859 return NULL;
9860 }
9861
9862
9863 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9864 PyObject *resultobj = 0;
9865 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9866 int result;
9867 void *argp1 = 0 ;
9868 int res1 = 0 ;
9869 PyObject *swig_obj[1] ;
9870
9871 if (!args) SWIG_fail;
9872 swig_obj[0] = args;
9873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9874 if (!SWIG_IsOK(res1)) {
9875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9876 }
9877 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 result = (int)((wxFileHistory const *)arg1)->GetCount();
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 resultobj = SWIG_From_int(static_cast< int >(result));
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9892 PyObject *obj;
9893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9894 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9895 return SWIG_Py_Void();
9896 }
9897
9898 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9899 return SWIG_Python_InitShadowInstance(args);
9900 }
9901
9902 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9903 PyObject *resultobj = 0;
9904 wxString *arg1 = 0 ;
9905 wxString const &arg2_defvalue = wxPyEmptyString ;
9906 wxString *arg2 = (wxString *) &arg2_defvalue ;
9907 wxSingleInstanceChecker *result = 0 ;
9908 bool temp1 = false ;
9909 bool temp2 = false ;
9910 PyObject * obj0 = 0 ;
9911 PyObject * obj1 = 0 ;
9912 char * kwnames[] = {
9913 (char *) "name",(char *) "path", NULL
9914 };
9915
9916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9917 {
9918 arg1 = wxString_in_helper(obj0);
9919 if (arg1 == NULL) SWIG_fail;
9920 temp1 = true;
9921 }
9922 if (obj1) {
9923 {
9924 arg2 = wxString_in_helper(obj1);
9925 if (arg2 == NULL) SWIG_fail;
9926 temp2 = true;
9927 }
9928 }
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9936 {
9937 if (temp1)
9938 delete arg1;
9939 }
9940 {
9941 if (temp2)
9942 delete arg2;
9943 }
9944 return resultobj;
9945 fail:
9946 {
9947 if (temp1)
9948 delete arg1;
9949 }
9950 {
9951 if (temp2)
9952 delete arg2;
9953 }
9954 return NULL;
9955 }
9956
9957
9958 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9959 PyObject *resultobj = 0;
9960 wxSingleInstanceChecker *result = 0 ;
9961
9962 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9966 wxPyEndAllowThreads(__tstate);
9967 if (PyErr_Occurred()) SWIG_fail;
9968 }
9969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9977 PyObject *resultobj = 0;
9978 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 PyObject *swig_obj[1] ;
9982
9983 if (!args) SWIG_fail;
9984 swig_obj[0] = args;
9985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9986 if (!SWIG_IsOK(res1)) {
9987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9988 }
9989 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 delete arg1;
9993
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_Py_Void();
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj = 0;
10006 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10007 wxString *arg2 = 0 ;
10008 wxString const &arg3_defvalue = wxPyEmptyString ;
10009 wxString *arg3 = (wxString *) &arg3_defvalue ;
10010 bool result;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 bool temp2 = false ;
10014 bool temp3 = false ;
10015 PyObject * obj0 = 0 ;
10016 PyObject * obj1 = 0 ;
10017 PyObject * obj2 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "name",(char *) "path", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10026 }
10027 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10028 {
10029 arg2 = wxString_in_helper(obj1);
10030 if (arg2 == NULL) SWIG_fail;
10031 temp2 = true;
10032 }
10033 if (obj2) {
10034 {
10035 arg3 = wxString_in_helper(obj2);
10036 if (arg3 == NULL) SWIG_fail;
10037 temp3 = true;
10038 }
10039 }
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10043 wxPyEndAllowThreads(__tstate);
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 {
10047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10048 }
10049 {
10050 if (temp2)
10051 delete arg2;
10052 }
10053 {
10054 if (temp3)
10055 delete arg3;
10056 }
10057 return resultobj;
10058 fail:
10059 {
10060 if (temp2)
10061 delete arg2;
10062 }
10063 {
10064 if (temp3)
10065 delete arg3;
10066 }
10067 return NULL;
10068 }
10069
10070
10071 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10072 PyObject *resultobj = 0;
10073 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10074 bool result;
10075 void *argp1 = 0 ;
10076 int res1 = 0 ;
10077 PyObject *swig_obj[1] ;
10078
10079 if (!args) SWIG_fail;
10080 swig_obj[0] = args;
10081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10082 if (!SWIG_IsOK(res1)) {
10083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10084 }
10085 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10086 {
10087 PyThreadState* __tstate = wxPyBeginAllowThreads();
10088 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10089 wxPyEndAllowThreads(__tstate);
10090 if (PyErr_Occurred()) SWIG_fail;
10091 }
10092 {
10093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10094 }
10095 return resultobj;
10096 fail:
10097 return NULL;
10098 }
10099
10100
10101 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10102 PyObject *obj;
10103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10104 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10105 return SWIG_Py_Void();
10106 }
10107
10108 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10109 return SWIG_Python_InitShadowInstance(args);
10110 }
10111
10112 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10113 PyObject *resultobj = 0;
10114 wxPlatformInfo *result = 0 ;
10115
10116 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 result = (wxPlatformInfo *)new wxPlatformInfo();
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj = 0;
10132 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10133 wxPlatformInfo *arg2 = 0 ;
10134 bool result;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 void *argp2 = 0 ;
10138 int res2 = 0 ;
10139 PyObject * obj0 = 0 ;
10140 PyObject * obj1 = 0 ;
10141 char * kwnames[] = {
10142 (char *) "self",(char *) "t", NULL
10143 };
10144
10145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10149 }
10150 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10152 if (!SWIG_IsOK(res2)) {
10153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10154 }
10155 if (!argp2) {
10156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10157 }
10158 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10162 wxPyEndAllowThreads(__tstate);
10163 if (PyErr_Occurred()) SWIG_fail;
10164 }
10165 {
10166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10167 }
10168 return resultobj;
10169 fail:
10170 return NULL;
10171 }
10172
10173
10174 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj = 0;
10176 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10177 wxPlatformInfo *arg2 = 0 ;
10178 bool result;
10179 void *argp1 = 0 ;
10180 int res1 = 0 ;
10181 void *argp2 = 0 ;
10182 int res2 = 0 ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char * kwnames[] = {
10186 (char *) "self",(char *) "t", NULL
10187 };
10188
10189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10191 if (!SWIG_IsOK(res1)) {
10192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10193 }
10194 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10196 if (!SWIG_IsOK(res2)) {
10197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10198 }
10199 if (!argp2) {
10200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10201 }
10202 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 {
10210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10211 }
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10219 PyObject *resultobj = 0;
10220 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10221 int result;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 PyObject *swig_obj[1] ;
10225
10226 if (!args) SWIG_fail;
10227 swig_obj[0] = args;
10228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10229 if (!SWIG_IsOK(res1)) {
10230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10231 }
10232 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10233 {
10234 PyThreadState* __tstate = wxPyBeginAllowThreads();
10235 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10236 wxPyEndAllowThreads(__tstate);
10237 if (PyErr_Occurred()) SWIG_fail;
10238 }
10239 resultobj = SWIG_From_int(static_cast< int >(result));
10240 return resultobj;
10241 fail:
10242 return NULL;
10243 }
10244
10245
10246 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10247 PyObject *resultobj = 0;
10248 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10249 int result;
10250 void *argp1 = 0 ;
10251 int res1 = 0 ;
10252 PyObject *swig_obj[1] ;
10253
10254 if (!args) SWIG_fail;
10255 swig_obj[0] = args;
10256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10257 if (!SWIG_IsOK(res1)) {
10258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10259 }
10260 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10261 {
10262 PyThreadState* __tstate = wxPyBeginAllowThreads();
10263 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 resultobj = SWIG_From_int(static_cast< int >(result));
10268 return resultobj;
10269 fail:
10270 return NULL;
10271 }
10272
10273
10274 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10275 PyObject *resultobj = 0;
10276 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10277 int result;
10278 void *argp1 = 0 ;
10279 int res1 = 0 ;
10280 PyObject *swig_obj[1] ;
10281
10282 if (!args) SWIG_fail;
10283 swig_obj[0] = args;
10284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10285 if (!SWIG_IsOK(res1)) {
10286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10287 }
10288 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10289 {
10290 PyThreadState* __tstate = wxPyBeginAllowThreads();
10291 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10292 wxPyEndAllowThreads(__tstate);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 resultobj = SWIG_From_int(static_cast< int >(result));
10296 return resultobj;
10297 fail:
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10303 PyObject *resultobj = 0;
10304 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10305 int result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 PyObject *swig_obj[1] ;
10309
10310 if (!args) SWIG_fail;
10311 swig_obj[0] = args;
10312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10313 if (!SWIG_IsOK(res1)) {
10314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10315 }
10316 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 resultobj = SWIG_From_int(static_cast< int >(result));
10324 return resultobj;
10325 fail:
10326 return NULL;
10327 }
10328
10329
10330 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10331 PyObject *resultobj = 0;
10332 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10333 bool result;
10334 void *argp1 = 0 ;
10335 int res1 = 0 ;
10336 PyObject *swig_obj[1] ;
10337
10338 if (!args) SWIG_fail;
10339 swig_obj[0] = args;
10340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10341 if (!SWIG_IsOK(res1)) {
10342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10343 }
10344 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10345 {
10346 PyThreadState* __tstate = wxPyBeginAllowThreads();
10347 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10348 wxPyEndAllowThreads(__tstate);
10349 if (PyErr_Occurred()) SWIG_fail;
10350 }
10351 {
10352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10353 }
10354 return resultobj;
10355 fail:
10356 return NULL;
10357 }
10358
10359
10360 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10361 PyObject *resultobj = 0;
10362 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10363 wxOperatingSystemId result;
10364 void *argp1 = 0 ;
10365 int res1 = 0 ;
10366 PyObject *swig_obj[1] ;
10367
10368 if (!args) SWIG_fail;
10369 swig_obj[0] = args;
10370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10371 if (!SWIG_IsOK(res1)) {
10372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10373 }
10374 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10375 {
10376 PyThreadState* __tstate = wxPyBeginAllowThreads();
10377 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10378 wxPyEndAllowThreads(__tstate);
10379 if (PyErr_Occurred()) SWIG_fail;
10380 }
10381 resultobj = SWIG_From_int(static_cast< int >(result));
10382 return resultobj;
10383 fail:
10384 return NULL;
10385 }
10386
10387
10388 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10389 PyObject *resultobj = 0;
10390 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10391 wxPortId result;
10392 void *argp1 = 0 ;
10393 int res1 = 0 ;
10394 PyObject *swig_obj[1] ;
10395
10396 if (!args) SWIG_fail;
10397 swig_obj[0] = args;
10398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10399 if (!SWIG_IsOK(res1)) {
10400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10401 }
10402 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10403 {
10404 PyThreadState* __tstate = wxPyBeginAllowThreads();
10405 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10406 wxPyEndAllowThreads(__tstate);
10407 if (PyErr_Occurred()) SWIG_fail;
10408 }
10409 resultobj = SWIG_From_int(static_cast< int >(result));
10410 return resultobj;
10411 fail:
10412 return NULL;
10413 }
10414
10415
10416 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10417 PyObject *resultobj = 0;
10418 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10419 wxArchitecture result;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 PyObject *swig_obj[1] ;
10423
10424 if (!args) SWIG_fail;
10425 swig_obj[0] = args;
10426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10427 if (!SWIG_IsOK(res1)) {
10428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10429 }
10430 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10434 wxPyEndAllowThreads(__tstate);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 resultobj = SWIG_From_int(static_cast< int >(result));
10438 return resultobj;
10439 fail:
10440 return NULL;
10441 }
10442
10443
10444 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10445 PyObject *resultobj = 0;
10446 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10447 wxEndianness result;
10448 void *argp1 = 0 ;
10449 int res1 = 0 ;
10450 PyObject *swig_obj[1] ;
10451
10452 if (!args) SWIG_fail;
10453 swig_obj[0] = args;
10454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10455 if (!SWIG_IsOK(res1)) {
10456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10457 }
10458 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10459 {
10460 PyThreadState* __tstate = wxPyBeginAllowThreads();
10461 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10462 wxPyEndAllowThreads(__tstate);
10463 if (PyErr_Occurred()) SWIG_fail;
10464 }
10465 resultobj = SWIG_From_int(static_cast< int >(result));
10466 return resultobj;
10467 fail:
10468 return NULL;
10469 }
10470
10471
10472 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10473 PyObject *resultobj = 0;
10474 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10475 wxString result;
10476 void *argp1 = 0 ;
10477 int res1 = 0 ;
10478 PyObject *swig_obj[1] ;
10479
10480 if (!args) SWIG_fail;
10481 swig_obj[0] = args;
10482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10483 if (!SWIG_IsOK(res1)) {
10484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10485 }
10486 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10487 {
10488 PyThreadState* __tstate = wxPyBeginAllowThreads();
10489 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10490 wxPyEndAllowThreads(__tstate);
10491 if (PyErr_Occurred()) SWIG_fail;
10492 }
10493 {
10494 #if wxUSE_UNICODE
10495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10496 #else
10497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10498 #endif
10499 }
10500 return resultobj;
10501 fail:
10502 return NULL;
10503 }
10504
10505
10506 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10507 PyObject *resultobj = 0;
10508 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10509 wxString result;
10510 void *argp1 = 0 ;
10511 int res1 = 0 ;
10512 PyObject *swig_obj[1] ;
10513
10514 if (!args) SWIG_fail;
10515 swig_obj[0] = args;
10516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10517 if (!SWIG_IsOK(res1)) {
10518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10519 }
10520 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10521 {
10522 PyThreadState* __tstate = wxPyBeginAllowThreads();
10523 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10524 wxPyEndAllowThreads(__tstate);
10525 if (PyErr_Occurred()) SWIG_fail;
10526 }
10527 {
10528 #if wxUSE_UNICODE
10529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10530 #else
10531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10532 #endif
10533 }
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10541 PyObject *resultobj = 0;
10542 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10543 wxString result;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 PyObject *swig_obj[1] ;
10547
10548 if (!args) SWIG_fail;
10549 swig_obj[0] = args;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10553 }
10554 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 {
10562 #if wxUSE_UNICODE
10563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10564 #else
10565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10566 #endif
10567 }
10568 return resultobj;
10569 fail:
10570 return NULL;
10571 }
10572
10573
10574 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10575 PyObject *resultobj = 0;
10576 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10577 wxString result;
10578 void *argp1 = 0 ;
10579 int res1 = 0 ;
10580 PyObject *swig_obj[1] ;
10581
10582 if (!args) SWIG_fail;
10583 swig_obj[0] = args;
10584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10585 if (!SWIG_IsOK(res1)) {
10586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10587 }
10588 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10589 {
10590 PyThreadState* __tstate = wxPyBeginAllowThreads();
10591 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10592 wxPyEndAllowThreads(__tstate);
10593 if (PyErr_Occurred()) SWIG_fail;
10594 }
10595 {
10596 #if wxUSE_UNICODE
10597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10598 #else
10599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10600 #endif
10601 }
10602 return resultobj;
10603 fail:
10604 return NULL;
10605 }
10606
10607
10608 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10609 PyObject *resultobj = 0;
10610 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10611 wxString result;
10612 void *argp1 = 0 ;
10613 int res1 = 0 ;
10614 PyObject *swig_obj[1] ;
10615
10616 if (!args) SWIG_fail;
10617 swig_obj[0] = args;
10618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10619 if (!SWIG_IsOK(res1)) {
10620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10621 }
10622 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10623 {
10624 PyThreadState* __tstate = wxPyBeginAllowThreads();
10625 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10626 wxPyEndAllowThreads(__tstate);
10627 if (PyErr_Occurred()) SWIG_fail;
10628 }
10629 {
10630 #if wxUSE_UNICODE
10631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10632 #else
10633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10634 #endif
10635 }
10636 return resultobj;
10637 fail:
10638 return NULL;
10639 }
10640
10641
10642 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10643 PyObject *resultobj = 0;
10644 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10645 wxString result;
10646 void *argp1 = 0 ;
10647 int res1 = 0 ;
10648 PyObject *swig_obj[1] ;
10649
10650 if (!args) SWIG_fail;
10651 swig_obj[0] = args;
10652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10653 if (!SWIG_IsOK(res1)) {
10654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10655 }
10656 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10657 {
10658 PyThreadState* __tstate = wxPyBeginAllowThreads();
10659 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10660 wxPyEndAllowThreads(__tstate);
10661 if (PyErr_Occurred()) SWIG_fail;
10662 }
10663 {
10664 #if wxUSE_UNICODE
10665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10666 #else
10667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10668 #endif
10669 }
10670 return resultobj;
10671 fail:
10672 return NULL;
10673 }
10674
10675
10676 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10677 PyObject *resultobj = 0;
10678 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10679 int arg2 ;
10680 int arg3 ;
10681 void *argp1 = 0 ;
10682 int res1 = 0 ;
10683 int val2 ;
10684 int ecode2 = 0 ;
10685 int val3 ;
10686 int ecode3 = 0 ;
10687 PyObject * obj0 = 0 ;
10688 PyObject * obj1 = 0 ;
10689 PyObject * obj2 = 0 ;
10690 char * kwnames[] = {
10691 (char *) "self",(char *) "major",(char *) "minor", NULL
10692 };
10693
10694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10696 if (!SWIG_IsOK(res1)) {
10697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10698 }
10699 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10700 ecode2 = SWIG_AsVal_int(obj1, &val2);
10701 if (!SWIG_IsOK(ecode2)) {
10702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10703 }
10704 arg2 = static_cast< int >(val2);
10705 ecode3 = SWIG_AsVal_int(obj2, &val3);
10706 if (!SWIG_IsOK(ecode3)) {
10707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10708 }
10709 arg3 = static_cast< int >(val3);
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 (arg1)->SetOSVersion(arg2,arg3);
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 resultobj = SWIG_Py_Void();
10717 return resultobj;
10718 fail:
10719 return NULL;
10720 }
10721
10722
10723 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10724 PyObject *resultobj = 0;
10725 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10726 int arg2 ;
10727 int arg3 ;
10728 void *argp1 = 0 ;
10729 int res1 = 0 ;
10730 int val2 ;
10731 int ecode2 = 0 ;
10732 int val3 ;
10733 int ecode3 = 0 ;
10734 PyObject * obj0 = 0 ;
10735 PyObject * obj1 = 0 ;
10736 PyObject * obj2 = 0 ;
10737 char * kwnames[] = {
10738 (char *) "self",(char *) "major",(char *) "minor", NULL
10739 };
10740
10741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10743 if (!SWIG_IsOK(res1)) {
10744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10745 }
10746 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10747 ecode2 = SWIG_AsVal_int(obj1, &val2);
10748 if (!SWIG_IsOK(ecode2)) {
10749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10750 }
10751 arg2 = static_cast< int >(val2);
10752 ecode3 = SWIG_AsVal_int(obj2, &val3);
10753 if (!SWIG_IsOK(ecode3)) {
10754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10755 }
10756 arg3 = static_cast< int >(val3);
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 (arg1)->SetToolkitVersion(arg2,arg3);
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 resultobj = SWIG_Py_Void();
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj = 0;
10772 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10773 wxOperatingSystemId arg2 ;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 int val2 ;
10777 int ecode2 = 0 ;
10778 PyObject * obj0 = 0 ;
10779 PyObject * obj1 = 0 ;
10780 char * kwnames[] = {
10781 (char *) "self",(char *) "n", NULL
10782 };
10783
10784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10786 if (!SWIG_IsOK(res1)) {
10787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10788 }
10789 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10790 ecode2 = SWIG_AsVal_int(obj1, &val2);
10791 if (!SWIG_IsOK(ecode2)) {
10792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10793 }
10794 arg2 = static_cast< wxOperatingSystemId >(val2);
10795 {
10796 PyThreadState* __tstate = wxPyBeginAllowThreads();
10797 (arg1)->SetOperatingSystemId(arg2);
10798 wxPyEndAllowThreads(__tstate);
10799 if (PyErr_Occurred()) SWIG_fail;
10800 }
10801 resultobj = SWIG_Py_Void();
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj = 0;
10810 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10811 wxPortId arg2 ;
10812 void *argp1 = 0 ;
10813 int res1 = 0 ;
10814 int val2 ;
10815 int ecode2 = 0 ;
10816 PyObject * obj0 = 0 ;
10817 PyObject * obj1 = 0 ;
10818 char * kwnames[] = {
10819 (char *) "self",(char *) "n", NULL
10820 };
10821
10822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10824 if (!SWIG_IsOK(res1)) {
10825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10826 }
10827 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10828 ecode2 = SWIG_AsVal_int(obj1, &val2);
10829 if (!SWIG_IsOK(ecode2)) {
10830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10831 }
10832 arg2 = static_cast< wxPortId >(val2);
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 (arg1)->SetPortId(arg2);
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 resultobj = SWIG_Py_Void();
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj = 0;
10848 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10849 wxArchitecture arg2 ;
10850 void *argp1 = 0 ;
10851 int res1 = 0 ;
10852 int val2 ;
10853 int ecode2 = 0 ;
10854 PyObject * obj0 = 0 ;
10855 PyObject * obj1 = 0 ;
10856 char * kwnames[] = {
10857 (char *) "self",(char *) "n", NULL
10858 };
10859
10860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10862 if (!SWIG_IsOK(res1)) {
10863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10864 }
10865 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10866 ecode2 = SWIG_AsVal_int(obj1, &val2);
10867 if (!SWIG_IsOK(ecode2)) {
10868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10869 }
10870 arg2 = static_cast< wxArchitecture >(val2);
10871 {
10872 PyThreadState* __tstate = wxPyBeginAllowThreads();
10873 (arg1)->SetArchitecture(arg2);
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 resultobj = SWIG_Py_Void();
10878 return resultobj;
10879 fail:
10880 return NULL;
10881 }
10882
10883
10884 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10885 PyObject *resultobj = 0;
10886 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10887 wxEndianness arg2 ;
10888 void *argp1 = 0 ;
10889 int res1 = 0 ;
10890 int val2 ;
10891 int ecode2 = 0 ;
10892 PyObject * obj0 = 0 ;
10893 PyObject * obj1 = 0 ;
10894 char * kwnames[] = {
10895 (char *) "self",(char *) "n", NULL
10896 };
10897
10898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10900 if (!SWIG_IsOK(res1)) {
10901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10902 }
10903 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10904 ecode2 = SWIG_AsVal_int(obj1, &val2);
10905 if (!SWIG_IsOK(ecode2)) {
10906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
10907 }
10908 arg2 = static_cast< wxEndianness >(val2);
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 (arg1)->SetEndianness(arg2);
10912 wxPyEndAllowThreads(__tstate);
10913 if (PyErr_Occurred()) SWIG_fail;
10914 }
10915 resultobj = SWIG_Py_Void();
10916 return resultobj;
10917 fail:
10918 return NULL;
10919 }
10920
10921
10922 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10923 PyObject *resultobj = 0;
10924 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10925 bool result;
10926 void *argp1 = 0 ;
10927 int res1 = 0 ;
10928 PyObject *swig_obj[1] ;
10929
10930 if (!args) SWIG_fail;
10931 swig_obj[0] = args;
10932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10933 if (!SWIG_IsOK(res1)) {
10934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10935 }
10936 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10937 {
10938 PyThreadState* __tstate = wxPyBeginAllowThreads();
10939 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
10940 wxPyEndAllowThreads(__tstate);
10941 if (PyErr_Occurred()) SWIG_fail;
10942 }
10943 {
10944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10945 }
10946 return resultobj;
10947 fail:
10948 return NULL;
10949 }
10950
10951
10952 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10953 PyObject *obj;
10954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10955 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
10956 return SWIG_Py_Void();
10957 }
10958
10959 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10960 return SWIG_Python_InitShadowInstance(args);
10961 }
10962
10963 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10964 PyObject *resultobj = 0;
10965 wxWindow *arg1 = (wxWindow *) 0 ;
10966 wxDC *arg2 = 0 ;
10967 bool result;
10968 void *argp1 = 0 ;
10969 int res1 = 0 ;
10970 void *argp2 = 0 ;
10971 int res2 = 0 ;
10972 PyObject * obj0 = 0 ;
10973 PyObject * obj1 = 0 ;
10974 char * kwnames[] = {
10975 (char *) "window",(char *) "dc", NULL
10976 };
10977
10978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10980 if (!SWIG_IsOK(res1)) {
10981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10982 }
10983 arg1 = reinterpret_cast< wxWindow * >(argp1);
10984 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10985 if (!SWIG_IsOK(res2)) {
10986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10987 }
10988 if (!argp2) {
10989 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10990 }
10991 arg2 = reinterpret_cast< wxDC * >(argp2);
10992 {
10993 PyThreadState* __tstate = wxPyBeginAllowThreads();
10994 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10995 wxPyEndAllowThreads(__tstate);
10996 if (PyErr_Occurred()) SWIG_fail;
10997 }
10998 {
10999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11000 }
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11008 PyObject *resultobj = 0;
11009 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11010 void *argp1 = 0 ;
11011 int res1 = 0 ;
11012 PyObject *swig_obj[1] ;
11013
11014 if (!args) SWIG_fail;
11015 swig_obj[0] = args;
11016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11017 if (!SWIG_IsOK(res1)) {
11018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11019 }
11020 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 delete arg1;
11024
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 resultobj = SWIG_Py_Void();
11029 return resultobj;
11030 fail:
11031 return NULL;
11032 }
11033
11034
11035 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11036 PyObject *resultobj = 0;
11037 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11038 wxString result;
11039 void *argp1 = 0 ;
11040 int res1 = 0 ;
11041 PyObject *swig_obj[1] ;
11042
11043 if (!args) SWIG_fail;
11044 swig_obj[0] = args;
11045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11046 if (!SWIG_IsOK(res1)) {
11047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11048 }
11049 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11050 {
11051 PyThreadState* __tstate = wxPyBeginAllowThreads();
11052 result = (arg1)->GetTip();
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 {
11057 #if wxUSE_UNICODE
11058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11059 #else
11060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11061 #endif
11062 }
11063 return resultobj;
11064 fail:
11065 return NULL;
11066 }
11067
11068
11069 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11070 PyObject *resultobj = 0;
11071 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11072 size_t result;
11073 void *argp1 = 0 ;
11074 int res1 = 0 ;
11075 PyObject *swig_obj[1] ;
11076
11077 if (!args) SWIG_fail;
11078 swig_obj[0] = args;
11079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11080 if (!SWIG_IsOK(res1)) {
11081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11082 }
11083 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11084 {
11085 PyThreadState* __tstate = wxPyBeginAllowThreads();
11086 result = (size_t)(arg1)->GetCurrentTip();
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj = 0;
11099 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11100 wxString *arg2 = 0 ;
11101 wxString result;
11102 void *argp1 = 0 ;
11103 int res1 = 0 ;
11104 bool temp2 = false ;
11105 PyObject * obj0 = 0 ;
11106 PyObject * obj1 = 0 ;
11107 char * kwnames[] = {
11108 (char *) "self",(char *) "tip", NULL
11109 };
11110
11111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11113 if (!SWIG_IsOK(res1)) {
11114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11115 }
11116 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11117 {
11118 arg2 = wxString_in_helper(obj1);
11119 if (arg2 == NULL) SWIG_fail;
11120 temp2 = true;
11121 }
11122 {
11123 PyThreadState* __tstate = wxPyBeginAllowThreads();
11124 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 {
11129 #if wxUSE_UNICODE
11130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11131 #else
11132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11133 #endif
11134 }
11135 {
11136 if (temp2)
11137 delete arg2;
11138 }
11139 return resultobj;
11140 fail:
11141 {
11142 if (temp2)
11143 delete arg2;
11144 }
11145 return NULL;
11146 }
11147
11148
11149 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11150 PyObject *obj;
11151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11152 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11153 return SWIG_Py_Void();
11154 }
11155
11156 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj = 0;
11158 size_t arg1 ;
11159 wxPyTipProvider *result = 0 ;
11160 size_t val1 ;
11161 int ecode1 = 0 ;
11162 PyObject * obj0 = 0 ;
11163 char * kwnames[] = {
11164 (char *) "currentTip", NULL
11165 };
11166
11167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11168 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11169 if (!SWIG_IsOK(ecode1)) {
11170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11171 }
11172 arg1 = static_cast< size_t >(val1);
11173 {
11174 PyThreadState* __tstate = wxPyBeginAllowThreads();
11175 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11180 return resultobj;
11181 fail:
11182 return NULL;
11183 }
11184
11185
11186 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11187 PyObject *resultobj = 0;
11188 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11189 PyObject *arg2 = (PyObject *) 0 ;
11190 PyObject *arg3 = (PyObject *) 0 ;
11191 void *argp1 = 0 ;
11192 int res1 = 0 ;
11193 PyObject * obj0 = 0 ;
11194 PyObject * obj1 = 0 ;
11195 PyObject * obj2 = 0 ;
11196 char * kwnames[] = {
11197 (char *) "self",(char *) "self",(char *) "_class", NULL
11198 };
11199
11200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11202 if (!SWIG_IsOK(res1)) {
11203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11204 }
11205 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11206 arg2 = obj1;
11207 arg3 = obj2;
11208 {
11209 PyThreadState* __tstate = wxPyBeginAllowThreads();
11210 (arg1)->_setCallbackInfo(arg2,arg3);
11211 wxPyEndAllowThreads(__tstate);
11212 if (PyErr_Occurred()) SWIG_fail;
11213 }
11214 resultobj = SWIG_Py_Void();
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11222 PyObject *obj;
11223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11224 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11225 return SWIG_Py_Void();
11226 }
11227
11228 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11229 return SWIG_Python_InitShadowInstance(args);
11230 }
11231
11232 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11233 PyObject *resultobj = 0;
11234 wxWindow *arg1 = (wxWindow *) 0 ;
11235 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11236 bool arg3 = (bool) true ;
11237 bool result;
11238 void *argp1 = 0 ;
11239 int res1 = 0 ;
11240 void *argp2 = 0 ;
11241 int res2 = 0 ;
11242 bool val3 ;
11243 int ecode3 = 0 ;
11244 PyObject * obj0 = 0 ;
11245 PyObject * obj1 = 0 ;
11246 PyObject * obj2 = 0 ;
11247 char * kwnames[] = {
11248 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11249 };
11250
11251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11253 if (!SWIG_IsOK(res1)) {
11254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11255 }
11256 arg1 = reinterpret_cast< wxWindow * >(argp1);
11257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11258 if (!SWIG_IsOK(res2)) {
11259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11260 }
11261 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11262 if (obj2) {
11263 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11264 if (!SWIG_IsOK(ecode3)) {
11265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11266 }
11267 arg3 = static_cast< bool >(val3);
11268 }
11269 {
11270 if (!wxPyCheckForApp()) SWIG_fail;
11271 PyThreadState* __tstate = wxPyBeginAllowThreads();
11272 result = (bool)wxShowTip(arg1,arg2,arg3);
11273 wxPyEndAllowThreads(__tstate);
11274 if (PyErr_Occurred()) SWIG_fail;
11275 }
11276 {
11277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11278 }
11279 return resultobj;
11280 fail:
11281 return NULL;
11282 }
11283
11284
11285 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11286 PyObject *resultobj = 0;
11287 wxString *arg1 = 0 ;
11288 size_t arg2 ;
11289 wxTipProvider *result = 0 ;
11290 bool temp1 = false ;
11291 size_t val2 ;
11292 int ecode2 = 0 ;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 char * kwnames[] = {
11296 (char *) "filename",(char *) "currentTip", NULL
11297 };
11298
11299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11300 {
11301 arg1 = wxString_in_helper(obj0);
11302 if (arg1 == NULL) SWIG_fail;
11303 temp1 = true;
11304 }
11305 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11306 if (!SWIG_IsOK(ecode2)) {
11307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11308 }
11309 arg2 = static_cast< size_t >(val2);
11310 {
11311 if (!wxPyCheckForApp()) SWIG_fail;
11312 PyThreadState* __tstate = wxPyBeginAllowThreads();
11313 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11314 wxPyEndAllowThreads(__tstate);
11315 if (PyErr_Occurred()) SWIG_fail;
11316 }
11317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11318 {
11319 if (temp1)
11320 delete arg1;
11321 }
11322 return resultobj;
11323 fail:
11324 {
11325 if (temp1)
11326 delete arg1;
11327 }
11328 return NULL;
11329 }
11330
11331
11332 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11333 PyObject *resultobj = 0;
11334 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11335 int arg2 = (int) wxID_ANY ;
11336 wxPyTimer *result = 0 ;
11337 void *argp1 = 0 ;
11338 int res1 = 0 ;
11339 int val2 ;
11340 int ecode2 = 0 ;
11341 PyObject * obj0 = 0 ;
11342 PyObject * obj1 = 0 ;
11343 char * kwnames[] = {
11344 (char *) "owner",(char *) "id", NULL
11345 };
11346
11347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11348 if (obj0) {
11349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11350 if (!SWIG_IsOK(res1)) {
11351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11352 }
11353 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11354 }
11355 if (obj1) {
11356 ecode2 = SWIG_AsVal_int(obj1, &val2);
11357 if (!SWIG_IsOK(ecode2)) {
11358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11359 }
11360 arg2 = static_cast< int >(val2);
11361 }
11362 {
11363 if (!wxPyCheckForApp()) SWIG_fail;
11364 PyThreadState* __tstate = wxPyBeginAllowThreads();
11365 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11366 wxPyEndAllowThreads(__tstate);
11367 if (PyErr_Occurred()) SWIG_fail;
11368 }
11369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11370 return resultobj;
11371 fail:
11372 return NULL;
11373 }
11374
11375
11376 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11377 PyObject *resultobj = 0;
11378 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11379 void *argp1 = 0 ;
11380 int res1 = 0 ;
11381 PyObject *swig_obj[1] ;
11382
11383 if (!args) SWIG_fail;
11384 swig_obj[0] = args;
11385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11386 if (!SWIG_IsOK(res1)) {
11387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11388 }
11389 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 delete arg1;
11393
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 resultobj = SWIG_Py_Void();
11398 return resultobj;
11399 fail:
11400 return NULL;
11401 }
11402
11403
11404 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj = 0;
11406 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11407 PyObject *arg2 = (PyObject *) 0 ;
11408 PyObject *arg3 = (PyObject *) 0 ;
11409 int arg4 = (int) 1 ;
11410 void *argp1 = 0 ;
11411 int res1 = 0 ;
11412 int val4 ;
11413 int ecode4 = 0 ;
11414 PyObject * obj0 = 0 ;
11415 PyObject * obj1 = 0 ;
11416 PyObject * obj2 = 0 ;
11417 PyObject * obj3 = 0 ;
11418 char * kwnames[] = {
11419 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11420 };
11421
11422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11424 if (!SWIG_IsOK(res1)) {
11425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11426 }
11427 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11428 arg2 = obj1;
11429 arg3 = obj2;
11430 if (obj3) {
11431 ecode4 = SWIG_AsVal_int(obj3, &val4);
11432 if (!SWIG_IsOK(ecode4)) {
11433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11434 }
11435 arg4 = static_cast< int >(val4);
11436 }
11437 {
11438 PyThreadState* __tstate = wxPyBeginAllowThreads();
11439 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 resultobj = SWIG_Py_Void();
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj = 0;
11452 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11453 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11454 int arg3 = (int) wxID_ANY ;
11455 void *argp1 = 0 ;
11456 int res1 = 0 ;
11457 void *argp2 = 0 ;
11458 int res2 = 0 ;
11459 int val3 ;
11460 int ecode3 = 0 ;
11461 PyObject * obj0 = 0 ;
11462 PyObject * obj1 = 0 ;
11463 PyObject * obj2 = 0 ;
11464 char * kwnames[] = {
11465 (char *) "self",(char *) "owner",(char *) "id", NULL
11466 };
11467
11468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11470 if (!SWIG_IsOK(res1)) {
11471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11472 }
11473 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11474 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11475 if (!SWIG_IsOK(res2)) {
11476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11477 }
11478 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11479 if (obj2) {
11480 ecode3 = SWIG_AsVal_int(obj2, &val3);
11481 if (!SWIG_IsOK(ecode3)) {
11482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11483 }
11484 arg3 = static_cast< int >(val3);
11485 }
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 (arg1)->SetOwner(arg2,arg3);
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 resultobj = SWIG_Py_Void();
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11500 PyObject *resultobj = 0;
11501 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11502 wxEvtHandler *result = 0 ;
11503 void *argp1 = 0 ;
11504 int res1 = 0 ;
11505 PyObject *swig_obj[1] ;
11506
11507 if (!args) SWIG_fail;
11508 swig_obj[0] = args;
11509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11510 if (!SWIG_IsOK(res1)) {
11511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11512 }
11513 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11514 {
11515 PyThreadState* __tstate = wxPyBeginAllowThreads();
11516 result = (wxEvtHandler *)(arg1)->GetOwner();
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 {
11521 resultobj = wxPyMake_wxObject(result, 0);
11522 }
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj = 0;
11531 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11532 int arg2 = (int) -1 ;
11533 bool arg3 = (bool) false ;
11534 bool result;
11535 void *argp1 = 0 ;
11536 int res1 = 0 ;
11537 int val2 ;
11538 int ecode2 = 0 ;
11539 bool val3 ;
11540 int ecode3 = 0 ;
11541 PyObject * obj0 = 0 ;
11542 PyObject * obj1 = 0 ;
11543 PyObject * obj2 = 0 ;
11544 char * kwnames[] = {
11545 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11546 };
11547
11548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11550 if (!SWIG_IsOK(res1)) {
11551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11552 }
11553 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11554 if (obj1) {
11555 ecode2 = SWIG_AsVal_int(obj1, &val2);
11556 if (!SWIG_IsOK(ecode2)) {
11557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11558 }
11559 arg2 = static_cast< int >(val2);
11560 }
11561 if (obj2) {
11562 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11563 if (!SWIG_IsOK(ecode3)) {
11564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11565 }
11566 arg3 = static_cast< bool >(val3);
11567 }
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 result = (bool)(arg1)->Start(arg2,arg3);
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 {
11575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11576 }
11577 return resultobj;
11578 fail:
11579 return NULL;
11580 }
11581
11582
11583 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11584 PyObject *resultobj = 0;
11585 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11586 void *argp1 = 0 ;
11587 int res1 = 0 ;
11588 PyObject *swig_obj[1] ;
11589
11590 if (!args) SWIG_fail;
11591 swig_obj[0] = args;
11592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11593 if (!SWIG_IsOK(res1)) {
11594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11595 }
11596 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11597 {
11598 PyThreadState* __tstate = wxPyBeginAllowThreads();
11599 (arg1)->Stop();
11600 wxPyEndAllowThreads(__tstate);
11601 if (PyErr_Occurred()) SWIG_fail;
11602 }
11603 resultobj = SWIG_Py_Void();
11604 return resultobj;
11605 fail:
11606 return NULL;
11607 }
11608
11609
11610 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11611 PyObject *resultobj = 0;
11612 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11613 void *argp1 = 0 ;
11614 int res1 = 0 ;
11615 PyObject *swig_obj[1] ;
11616
11617 if (!args) SWIG_fail;
11618 swig_obj[0] = args;
11619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11620 if (!SWIG_IsOK(res1)) {
11621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11622 }
11623 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11624 {
11625 PyThreadState* __tstate = wxPyBeginAllowThreads();
11626 (arg1)->Notify();
11627 wxPyEndAllowThreads(__tstate);
11628 if (PyErr_Occurred()) SWIG_fail;
11629 }
11630 resultobj = SWIG_Py_Void();
11631 return resultobj;
11632 fail:
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11638 PyObject *resultobj = 0;
11639 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11640 bool result;
11641 void *argp1 = 0 ;
11642 int res1 = 0 ;
11643 PyObject *swig_obj[1] ;
11644
11645 if (!args) SWIG_fail;
11646 swig_obj[0] = args;
11647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11648 if (!SWIG_IsOK(res1)) {
11649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11650 }
11651 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 {
11659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11660 }
11661 return resultobj;
11662 fail:
11663 return NULL;
11664 }
11665
11666
11667 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11668 PyObject *resultobj = 0;
11669 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11670 int result;
11671 void *argp1 = 0 ;
11672 int res1 = 0 ;
11673 PyObject *swig_obj[1] ;
11674
11675 if (!args) SWIG_fail;
11676 swig_obj[0] = args;
11677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11678 if (!SWIG_IsOK(res1)) {
11679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11680 }
11681 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 resultobj = SWIG_From_int(static_cast< int >(result));
11689 return resultobj;
11690 fail:
11691 return NULL;
11692 }
11693
11694
11695 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11696 PyObject *resultobj = 0;
11697 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11698 int result;
11699 void *argp1 = 0 ;
11700 int res1 = 0 ;
11701 PyObject *swig_obj[1] ;
11702
11703 if (!args) SWIG_fail;
11704 swig_obj[0] = args;
11705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11706 if (!SWIG_IsOK(res1)) {
11707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11708 }
11709 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (int)((wxPyTimer const *)arg1)->GetId();
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 resultobj = SWIG_From_int(static_cast< int >(result));
11717 return resultobj;
11718 fail:
11719 return NULL;
11720 }
11721
11722
11723 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 PyObject *resultobj = 0;
11725 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11726 bool result;
11727 void *argp1 = 0 ;
11728 int res1 = 0 ;
11729 PyObject *swig_obj[1] ;
11730
11731 if (!args) SWIG_fail;
11732 swig_obj[0] = args;
11733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11734 if (!SWIG_IsOK(res1)) {
11735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11736 }
11737 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11741 wxPyEndAllowThreads(__tstate);
11742 if (PyErr_Occurred()) SWIG_fail;
11743 }
11744 {
11745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11746 }
11747 return resultobj;
11748 fail:
11749 return NULL;
11750 }
11751
11752
11753 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11754 PyObject *obj;
11755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11756 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11757 return SWIG_Py_Void();
11758 }
11759
11760 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11761 return SWIG_Python_InitShadowInstance(args);
11762 }
11763
11764 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11765 PyObject *resultobj = 0;
11766 int arg1 = (int) 0 ;
11767 int arg2 = (int) 0 ;
11768 wxTimerEvent *result = 0 ;
11769 int val1 ;
11770 int ecode1 = 0 ;
11771 int val2 ;
11772 int ecode2 = 0 ;
11773 PyObject * obj0 = 0 ;
11774 PyObject * obj1 = 0 ;
11775 char * kwnames[] = {
11776 (char *) "timerid",(char *) "interval", NULL
11777 };
11778
11779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11780 if (obj0) {
11781 ecode1 = SWIG_AsVal_int(obj0, &val1);
11782 if (!SWIG_IsOK(ecode1)) {
11783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11784 }
11785 arg1 = static_cast< int >(val1);
11786 }
11787 if (obj1) {
11788 ecode2 = SWIG_AsVal_int(obj1, &val2);
11789 if (!SWIG_IsOK(ecode2)) {
11790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11791 }
11792 arg2 = static_cast< int >(val2);
11793 }
11794 {
11795 PyThreadState* __tstate = wxPyBeginAllowThreads();
11796 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11797 wxPyEndAllowThreads(__tstate);
11798 if (PyErr_Occurred()) SWIG_fail;
11799 }
11800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11801 return resultobj;
11802 fail:
11803 return NULL;
11804 }
11805
11806
11807 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11808 PyObject *resultobj = 0;
11809 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11810 int result;
11811 void *argp1 = 0 ;
11812 int res1 = 0 ;
11813 PyObject *swig_obj[1] ;
11814
11815 if (!args) SWIG_fail;
11816 swig_obj[0] = args;
11817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11820 }
11821 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 resultobj = SWIG_From_int(static_cast< int >(result));
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 PyObject *obj;
11837 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11838 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11839 return SWIG_Py_Void();
11840 }
11841
11842 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11843 return SWIG_Python_InitShadowInstance(args);
11844 }
11845
11846 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11847 PyObject *resultobj = 0;
11848 wxTimer *arg1 = 0 ;
11849 wxTimerRunner *result = 0 ;
11850 void *argp1 = 0 ;
11851 int res1 = 0 ;
11852
11853 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11855 if (!SWIG_IsOK(res1)) {
11856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11857 }
11858 if (!argp1) {
11859 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11860 }
11861 arg1 = reinterpret_cast< wxTimer * >(argp1);
11862 {
11863 if (!wxPyCheckForApp()) SWIG_fail;
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11866 wxPyEndAllowThreads(__tstate);
11867 if (PyErr_Occurred()) SWIG_fail;
11868 }
11869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11877 PyObject *resultobj = 0;
11878 wxTimer *arg1 = 0 ;
11879 int arg2 ;
11880 bool arg3 = (bool) false ;
11881 wxTimerRunner *result = 0 ;
11882 void *argp1 = 0 ;
11883 int res1 = 0 ;
11884 int val2 ;
11885 int ecode2 = 0 ;
11886 bool val3 ;
11887 int ecode3 = 0 ;
11888
11889 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11891 if (!SWIG_IsOK(res1)) {
11892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11893 }
11894 if (!argp1) {
11895 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11896 }
11897 arg1 = reinterpret_cast< wxTimer * >(argp1);
11898 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11899 if (!SWIG_IsOK(ecode2)) {
11900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
11901 }
11902 arg2 = static_cast< int >(val2);
11903 if (swig_obj[2]) {
11904 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
11905 if (!SWIG_IsOK(ecode3)) {
11906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
11907 }
11908 arg3 = static_cast< bool >(val3);
11909 }
11910 {
11911 if (!wxPyCheckForApp()) SWIG_fail;
11912 PyThreadState* __tstate = wxPyBeginAllowThreads();
11913 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
11914 wxPyEndAllowThreads(__tstate);
11915 if (PyErr_Occurred()) SWIG_fail;
11916 }
11917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11918 return resultobj;
11919 fail:
11920 return NULL;
11921 }
11922
11923
11924 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
11925 int argc;
11926 PyObject *argv[4];
11927
11928 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
11929 --argc;
11930 if (argc == 1) {
11931 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
11932 }
11933 if ((argc >= 2) && (argc <= 3)) {
11934 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
11935 }
11936
11937 fail:
11938 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11939 return NULL;
11940 }
11941
11942
11943 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11944 PyObject *resultobj = 0;
11945 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11946 void *argp1 = 0 ;
11947 int res1 = 0 ;
11948 PyObject *swig_obj[1] ;
11949
11950 if (!args) SWIG_fail;
11951 swig_obj[0] = args;
11952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11953 if (!SWIG_IsOK(res1)) {
11954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11955 }
11956 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 delete arg1;
11960
11961 wxPyEndAllowThreads(__tstate);
11962 if (PyErr_Occurred()) SWIG_fail;
11963 }
11964 resultobj = SWIG_Py_Void();
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11972 PyObject *resultobj = 0;
11973 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11974 int arg2 ;
11975 bool arg3 = (bool) false ;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978 int val2 ;
11979 int ecode2 = 0 ;
11980 bool val3 ;
11981 int ecode3 = 0 ;
11982 PyObject * obj0 = 0 ;
11983 PyObject * obj1 = 0 ;
11984 PyObject * obj2 = 0 ;
11985 char * kwnames[] = {
11986 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11987 };
11988
11989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11991 if (!SWIG_IsOK(res1)) {
11992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11993 }
11994 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11995 ecode2 = SWIG_AsVal_int(obj1, &val2);
11996 if (!SWIG_IsOK(ecode2)) {
11997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11998 }
11999 arg2 = static_cast< int >(val2);
12000 if (obj2) {
12001 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12002 if (!SWIG_IsOK(ecode3)) {
12003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12004 }
12005 arg3 = static_cast< bool >(val3);
12006 }
12007 {
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 (arg1)->Start(arg2,arg3);
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 resultobj = SWIG_Py_Void();
12014 return resultobj;
12015 fail:
12016 return NULL;
12017 }
12018
12019
12020 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12021 PyObject *obj;
12022 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12023 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12024 return SWIG_Py_Void();
12025 }
12026
12027 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12028 return SWIG_Python_InitShadowInstance(args);
12029 }
12030
12031 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12032 PyObject *resultobj = 0;
12033 wxLog *result = 0 ;
12034
12035 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12036 {
12037 PyThreadState* __tstate = wxPyBeginAllowThreads();
12038 result = (wxLog *)new wxLog();
12039 wxPyEndAllowThreads(__tstate);
12040 if (PyErr_Occurred()) SWIG_fail;
12041 }
12042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12050 PyObject *resultobj = 0;
12051 wxLog *arg1 = (wxLog *) 0 ;
12052 void *argp1 = 0 ;
12053 int res1 = 0 ;
12054 PyObject *swig_obj[1] ;
12055
12056 if (!args) SWIG_fail;
12057 swig_obj[0] = args;
12058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12059 if (!SWIG_IsOK(res1)) {
12060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12061 }
12062 arg1 = reinterpret_cast< wxLog * >(argp1);
12063 {
12064 PyThreadState* __tstate = wxPyBeginAllowThreads();
12065 delete arg1;
12066
12067 wxPyEndAllowThreads(__tstate);
12068 if (PyErr_Occurred()) SWIG_fail;
12069 }
12070 resultobj = SWIG_Py_Void();
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12078 PyObject *resultobj = 0;
12079 bool result;
12080
12081 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12082 {
12083 PyThreadState* __tstate = wxPyBeginAllowThreads();
12084 result = (bool)wxLog::IsEnabled();
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 {
12089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12090 }
12091 return resultobj;
12092 fail:
12093 return NULL;
12094 }
12095
12096
12097 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12098 PyObject *resultobj = 0;
12099 bool arg1 = (bool) true ;
12100 bool result;
12101 bool val1 ;
12102 int ecode1 = 0 ;
12103 PyObject * obj0 = 0 ;
12104 char * kwnames[] = {
12105 (char *) "doIt", NULL
12106 };
12107
12108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12109 if (obj0) {
12110 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12111 if (!SWIG_IsOK(ecode1)) {
12112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12113 }
12114 arg1 = static_cast< bool >(val1);
12115 }
12116 {
12117 PyThreadState* __tstate = wxPyBeginAllowThreads();
12118 result = (bool)wxLog::EnableLogging(arg1);
12119 wxPyEndAllowThreads(__tstate);
12120 if (PyErr_Occurred()) SWIG_fail;
12121 }
12122 {
12123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12124 }
12125 return resultobj;
12126 fail:
12127 return NULL;
12128 }
12129
12130
12131 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12132 PyObject *resultobj = 0;
12133 wxLogLevel arg1 ;
12134 wxChar *arg2 = (wxChar *) 0 ;
12135 time_t arg3 ;
12136 unsigned long val1 ;
12137 int ecode1 = 0 ;
12138 void *argp2 = 0 ;
12139 int res2 = 0 ;
12140 unsigned int val3 ;
12141 int ecode3 = 0 ;
12142 PyObject * obj0 = 0 ;
12143 PyObject * obj1 = 0 ;
12144 PyObject * obj2 = 0 ;
12145 char * kwnames[] = {
12146 (char *) "level",(char *) "szString",(char *) "t", NULL
12147 };
12148
12149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12150 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12151 if (!SWIG_IsOK(ecode1)) {
12152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12153 }
12154 arg1 = static_cast< wxLogLevel >(val1);
12155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12156 if (!SWIG_IsOK(res2)) {
12157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12158 }
12159 arg2 = reinterpret_cast< wxChar * >(argp2);
12160 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12161 if (!SWIG_IsOK(ecode3)) {
12162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12163 }
12164 arg3 = static_cast< time_t >(val3);
12165 {
12166 PyThreadState* __tstate = wxPyBeginAllowThreads();
12167 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12168 wxPyEndAllowThreads(__tstate);
12169 if (PyErr_Occurred()) SWIG_fail;
12170 }
12171 resultobj = SWIG_Py_Void();
12172 return resultobj;
12173 fail:
12174 return NULL;
12175 }
12176
12177
12178 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12179 PyObject *resultobj = 0;
12180 wxLog *arg1 = (wxLog *) 0 ;
12181 void *argp1 = 0 ;
12182 int res1 = 0 ;
12183 PyObject *swig_obj[1] ;
12184
12185 if (!args) SWIG_fail;
12186 swig_obj[0] = args;
12187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12188 if (!SWIG_IsOK(res1)) {
12189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12190 }
12191 arg1 = reinterpret_cast< wxLog * >(argp1);
12192 {
12193 PyThreadState* __tstate = wxPyBeginAllowThreads();
12194 (arg1)->Flush();
12195 wxPyEndAllowThreads(__tstate);
12196 if (PyErr_Occurred()) SWIG_fail;
12197 }
12198 resultobj = SWIG_Py_Void();
12199 return resultobj;
12200 fail:
12201 return NULL;
12202 }
12203
12204
12205 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12206 PyObject *resultobj = 0;
12207
12208 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12209 {
12210 PyThreadState* __tstate = wxPyBeginAllowThreads();
12211 wxLog::FlushActive();
12212 wxPyEndAllowThreads(__tstate);
12213 if (PyErr_Occurred()) SWIG_fail;
12214 }
12215 resultobj = SWIG_Py_Void();
12216 return resultobj;
12217 fail:
12218 return NULL;
12219 }
12220
12221
12222 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12223 PyObject *resultobj = 0;
12224 wxLog *result = 0 ;
12225
12226 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 result = (wxLog *)wxLog::GetActiveTarget();
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj = 0;
12242 wxLog *arg1 = (wxLog *) 0 ;
12243 wxLog *result = 0 ;
12244 int res1 = 0 ;
12245 PyObject * obj0 = 0 ;
12246 char * kwnames[] = {
12247 (char *) "pLogger", NULL
12248 };
12249
12250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12251 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12252 if (!SWIG_IsOK(res1)) {
12253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12254 }
12255 {
12256 PyThreadState* __tstate = wxPyBeginAllowThreads();
12257 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12258 wxPyEndAllowThreads(__tstate);
12259 if (PyErr_Occurred()) SWIG_fail;
12260 }
12261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12262 return resultobj;
12263 fail:
12264 return NULL;
12265 }
12266
12267
12268 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269 PyObject *resultobj = 0;
12270
12271 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12272 {
12273 PyThreadState* __tstate = wxPyBeginAllowThreads();
12274 wxLog::Suspend();
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 resultobj = SWIG_Py_Void();
12279 return resultobj;
12280 fail:
12281 return NULL;
12282 }
12283
12284
12285 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12286 PyObject *resultobj = 0;
12287
12288 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 wxLog::Resume();
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = SWIG_Py_Void();
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12303 PyObject *resultobj = 0;
12304 bool arg1 = (bool) true ;
12305 bool val1 ;
12306 int ecode1 = 0 ;
12307 PyObject * obj0 = 0 ;
12308 char * kwnames[] = {
12309 (char *) "bVerbose", NULL
12310 };
12311
12312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12313 if (obj0) {
12314 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12315 if (!SWIG_IsOK(ecode1)) {
12316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12317 }
12318 arg1 = static_cast< bool >(val1);
12319 }
12320 {
12321 PyThreadState* __tstate = wxPyBeginAllowThreads();
12322 wxLog::SetVerbose(arg1);
12323 wxPyEndAllowThreads(__tstate);
12324 if (PyErr_Occurred()) SWIG_fail;
12325 }
12326 resultobj = SWIG_Py_Void();
12327 return resultobj;
12328 fail:
12329 return NULL;
12330 }
12331
12332
12333 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12334 PyObject *resultobj = 0;
12335 wxLogLevel arg1 ;
12336 unsigned long val1 ;
12337 int ecode1 = 0 ;
12338 PyObject * obj0 = 0 ;
12339 char * kwnames[] = {
12340 (char *) "logLevel", NULL
12341 };
12342
12343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12344 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12345 if (!SWIG_IsOK(ecode1)) {
12346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12347 }
12348 arg1 = static_cast< wxLogLevel >(val1);
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 wxLog::SetLogLevel(arg1);
12352 wxPyEndAllowThreads(__tstate);
12353 if (PyErr_Occurred()) SWIG_fail;
12354 }
12355 resultobj = SWIG_Py_Void();
12356 return resultobj;
12357 fail:
12358 return NULL;
12359 }
12360
12361
12362 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12363 PyObject *resultobj = 0;
12364
12365 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12366 {
12367 PyThreadState* __tstate = wxPyBeginAllowThreads();
12368 wxLog::DontCreateOnDemand();
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 resultobj = SWIG_Py_Void();
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj = 0;
12381 bool arg1 = (bool) true ;
12382 bool val1 ;
12383 int ecode1 = 0 ;
12384 PyObject * obj0 = 0 ;
12385 char * kwnames[] = {
12386 (char *) "bRepetCounting", NULL
12387 };
12388
12389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12390 if (obj0) {
12391 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12392 if (!SWIG_IsOK(ecode1)) {
12393 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12394 }
12395 arg1 = static_cast< bool >(val1);
12396 }
12397 {
12398 PyThreadState* __tstate = wxPyBeginAllowThreads();
12399 wxLog::SetRepetitionCounting(arg1);
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 resultobj = SWIG_Py_Void();
12404 return resultobj;
12405 fail:
12406 return NULL;
12407 }
12408
12409
12410 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12411 PyObject *resultobj = 0;
12412 bool result;
12413
12414 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12415 {
12416 PyThreadState* __tstate = wxPyBeginAllowThreads();
12417 result = (bool)wxLog::GetRepetitionCounting();
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 {
12422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12423 }
12424 return resultobj;
12425 fail:
12426 return NULL;
12427 }
12428
12429
12430 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12431 PyObject *resultobj = 0;
12432 wxTraceMask arg1 ;
12433 unsigned long val1 ;
12434 int ecode1 = 0 ;
12435 PyObject * obj0 = 0 ;
12436 char * kwnames[] = {
12437 (char *) "ulMask", NULL
12438 };
12439
12440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12441 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12442 if (!SWIG_IsOK(ecode1)) {
12443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12444 }
12445 arg1 = static_cast< wxTraceMask >(val1);
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 wxLog::SetTraceMask(arg1);
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 resultobj = SWIG_Py_Void();
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12460 PyObject *resultobj = 0;
12461 wxString *arg1 = 0 ;
12462 bool temp1 = false ;
12463 PyObject * obj0 = 0 ;
12464 char * kwnames[] = {
12465 (char *) "str", NULL
12466 };
12467
12468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12469 {
12470 arg1 = wxString_in_helper(obj0);
12471 if (arg1 == NULL) SWIG_fail;
12472 temp1 = true;
12473 }
12474 {
12475 PyThreadState* __tstate = wxPyBeginAllowThreads();
12476 wxLog::AddTraceMask((wxString const &)*arg1);
12477 wxPyEndAllowThreads(__tstate);
12478 if (PyErr_Occurred()) SWIG_fail;
12479 }
12480 resultobj = SWIG_Py_Void();
12481 {
12482 if (temp1)
12483 delete arg1;
12484 }
12485 return resultobj;
12486 fail:
12487 {
12488 if (temp1)
12489 delete arg1;
12490 }
12491 return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12496 PyObject *resultobj = 0;
12497 wxString *arg1 = 0 ;
12498 bool temp1 = false ;
12499 PyObject * obj0 = 0 ;
12500 char * kwnames[] = {
12501 (char *) "str", NULL
12502 };
12503
12504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12505 {
12506 arg1 = wxString_in_helper(obj0);
12507 if (arg1 == NULL) SWIG_fail;
12508 temp1 = true;
12509 }
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 wxLog::RemoveTraceMask((wxString const &)*arg1);
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 resultobj = SWIG_Py_Void();
12517 {
12518 if (temp1)
12519 delete arg1;
12520 }
12521 return resultobj;
12522 fail:
12523 {
12524 if (temp1)
12525 delete arg1;
12526 }
12527 return NULL;
12528 }
12529
12530
12531 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12532 PyObject *resultobj = 0;
12533
12534 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12535 {
12536 PyThreadState* __tstate = wxPyBeginAllowThreads();
12537 wxLog::ClearTraceMasks();
12538 wxPyEndAllowThreads(__tstate);
12539 if (PyErr_Occurred()) SWIG_fail;
12540 }
12541 resultobj = SWIG_Py_Void();
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12549 PyObject *resultobj = 0;
12550 wxArrayString *result = 0 ;
12551
12552 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12553 {
12554 PyThreadState* __tstate = wxPyBeginAllowThreads();
12555 {
12556 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12557 result = (wxArrayString *) &_result_ref;
12558 }
12559 wxPyEndAllowThreads(__tstate);
12560 if (PyErr_Occurred()) SWIG_fail;
12561 }
12562 {
12563 resultobj = wxArrayString2PyList_helper(*result);
12564 }
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12572 PyObject *resultobj = 0;
12573 wxChar *arg1 = (wxChar *) 0 ;
12574 void *argp1 = 0 ;
12575 int res1 = 0 ;
12576 PyObject * obj0 = 0 ;
12577 char * kwnames[] = {
12578 (char *) "ts", NULL
12579 };
12580
12581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12583 if (!SWIG_IsOK(res1)) {
12584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12585 }
12586 arg1 = reinterpret_cast< wxChar * >(argp1);
12587 {
12588 PyThreadState* __tstate = wxPyBeginAllowThreads();
12589 wxLog::SetTimestamp((wxChar const *)arg1);
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 resultobj = SWIG_Py_Void();
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12601 PyObject *resultobj = 0;
12602 bool result;
12603
12604 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 result = (bool)wxLog::GetVerbose();
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 {
12612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12613 }
12614 return resultobj;
12615 fail:
12616 return NULL;
12617 }
12618
12619
12620 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12621 PyObject *resultobj = 0;
12622 wxTraceMask result;
12623
12624 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 result = (wxTraceMask)wxLog::GetTraceMask();
12628 wxPyEndAllowThreads(__tstate);
12629 if (PyErr_Occurred()) SWIG_fail;
12630 }
12631 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12632 return resultobj;
12633 fail:
12634 return NULL;
12635 }
12636
12637
12638 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj = 0;
12640 wxChar *arg1 = (wxChar *) 0 ;
12641 bool result;
12642 void *argp1 = 0 ;
12643 int res1 = 0 ;
12644 PyObject * obj0 = 0 ;
12645 char * kwnames[] = {
12646 (char *) "mask", NULL
12647 };
12648
12649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12651 if (!SWIG_IsOK(res1)) {
12652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12653 }
12654 arg1 = reinterpret_cast< wxChar * >(argp1);
12655 {
12656 PyThreadState* __tstate = wxPyBeginAllowThreads();
12657 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12658 wxPyEndAllowThreads(__tstate);
12659 if (PyErr_Occurred()) SWIG_fail;
12660 }
12661 {
12662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12663 }
12664 return resultobj;
12665 fail:
12666 return NULL;
12667 }
12668
12669
12670 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12671 PyObject *resultobj = 0;
12672 wxLogLevel result;
12673
12674 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 result = (wxLogLevel)wxLog::GetLogLevel();
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12689 PyObject *resultobj = 0;
12690 wxChar *result = 0 ;
12691
12692 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12693 {
12694 PyThreadState* __tstate = wxPyBeginAllowThreads();
12695 result = (wxChar *)wxLog::GetTimestamp();
12696 wxPyEndAllowThreads(__tstate);
12697 if (PyErr_Occurred()) SWIG_fail;
12698 }
12699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12700 return resultobj;
12701 fail:
12702 return NULL;
12703 }
12704
12705
12706 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12707 PyObject *resultobj = 0;
12708 wxString result;
12709
12710 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 result = wxLog_TimeStamp();
12714 wxPyEndAllowThreads(__tstate);
12715 if (PyErr_Occurred()) SWIG_fail;
12716 }
12717 {
12718 #if wxUSE_UNICODE
12719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12720 #else
12721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12722 #endif
12723 }
12724 return resultobj;
12725 fail:
12726 return NULL;
12727 }
12728
12729
12730 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12731 PyObject *resultobj = 0;
12732 wxLog *arg1 = (wxLog *) 0 ;
12733 void *argp1 = 0 ;
12734 int res1 = 0 ;
12735 PyObject *swig_obj[1] ;
12736
12737 if (!args) SWIG_fail;
12738 swig_obj[0] = args;
12739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12740 if (!SWIG_IsOK(res1)) {
12741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12742 }
12743 arg1 = reinterpret_cast< wxLog * >(argp1);
12744 {
12745 PyThreadState* __tstate = wxPyBeginAllowThreads();
12746 wxLog_Destroy(arg1);
12747 wxPyEndAllowThreads(__tstate);
12748 if (PyErr_Occurred()) SWIG_fail;
12749 }
12750 resultobj = SWIG_Py_Void();
12751 return resultobj;
12752 fail:
12753 return NULL;
12754 }
12755
12756
12757 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12758 PyObject *obj;
12759 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12760 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12761 return SWIG_Py_Void();
12762 }
12763
12764 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12765 return SWIG_Python_InitShadowInstance(args);
12766 }
12767
12768 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12769 PyObject *resultobj = 0;
12770 wxLogStderr *result = 0 ;
12771
12772 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12773 {
12774 PyThreadState* __tstate = wxPyBeginAllowThreads();
12775 result = (wxLogStderr *)new wxLogStderr();
12776 wxPyEndAllowThreads(__tstate);
12777 if (PyErr_Occurred()) SWIG_fail;
12778 }
12779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12787 PyObject *obj;
12788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12789 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12790 return SWIG_Py_Void();
12791 }
12792
12793 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12794 return SWIG_Python_InitShadowInstance(args);
12795 }
12796
12797 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12798 PyObject *resultobj = 0;
12799 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12800 wxLogTextCtrl *result = 0 ;
12801 void *argp1 = 0 ;
12802 int res1 = 0 ;
12803 PyObject * obj0 = 0 ;
12804 char * kwnames[] = {
12805 (char *) "pTextCtrl", NULL
12806 };
12807
12808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12810 if (!SWIG_IsOK(res1)) {
12811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12812 }
12813 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12817 wxPyEndAllowThreads(__tstate);
12818 if (PyErr_Occurred()) SWIG_fail;
12819 }
12820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12828 PyObject *obj;
12829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12830 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12831 return SWIG_Py_Void();
12832 }
12833
12834 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12835 return SWIG_Python_InitShadowInstance(args);
12836 }
12837
12838 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12839 PyObject *resultobj = 0;
12840 wxLogGui *result = 0 ;
12841
12842 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = (wxLogGui *)new wxLogGui();
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12850 return resultobj;
12851 fail:
12852 return NULL;
12853 }
12854
12855
12856 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12857 PyObject *obj;
12858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12859 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12860 return SWIG_Py_Void();
12861 }
12862
12863 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12864 return SWIG_Python_InitShadowInstance(args);
12865 }
12866
12867 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12868 PyObject *resultobj = 0;
12869 wxFrame *arg1 = (wxFrame *) 0 ;
12870 wxString *arg2 = 0 ;
12871 bool arg3 = (bool) true ;
12872 bool arg4 = (bool) true ;
12873 wxLogWindow *result = 0 ;
12874 void *argp1 = 0 ;
12875 int res1 = 0 ;
12876 bool temp2 = false ;
12877 bool val3 ;
12878 int ecode3 = 0 ;
12879 bool val4 ;
12880 int ecode4 = 0 ;
12881 PyObject * obj0 = 0 ;
12882 PyObject * obj1 = 0 ;
12883 PyObject * obj2 = 0 ;
12884 PyObject * obj3 = 0 ;
12885 char * kwnames[] = {
12886 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12887 };
12888
12889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12891 if (!SWIG_IsOK(res1)) {
12892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12893 }
12894 arg1 = reinterpret_cast< wxFrame * >(argp1);
12895 {
12896 arg2 = wxString_in_helper(obj1);
12897 if (arg2 == NULL) SWIG_fail;
12898 temp2 = true;
12899 }
12900 if (obj2) {
12901 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12902 if (!SWIG_IsOK(ecode3)) {
12903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
12904 }
12905 arg3 = static_cast< bool >(val3);
12906 }
12907 if (obj3) {
12908 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12909 if (!SWIG_IsOK(ecode4)) {
12910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
12911 }
12912 arg4 = static_cast< bool >(val4);
12913 }
12914 {
12915 PyThreadState* __tstate = wxPyBeginAllowThreads();
12916 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
12917 wxPyEndAllowThreads(__tstate);
12918 if (PyErr_Occurred()) SWIG_fail;
12919 }
12920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
12921 {
12922 if (temp2)
12923 delete arg2;
12924 }
12925 return resultobj;
12926 fail:
12927 {
12928 if (temp2)
12929 delete arg2;
12930 }
12931 return NULL;
12932 }
12933
12934
12935 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12936 PyObject *resultobj = 0;
12937 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12938 bool arg2 = (bool) true ;
12939 void *argp1 = 0 ;
12940 int res1 = 0 ;
12941 bool val2 ;
12942 int ecode2 = 0 ;
12943 PyObject * obj0 = 0 ;
12944 PyObject * obj1 = 0 ;
12945 char * kwnames[] = {
12946 (char *) "self",(char *) "bShow", NULL
12947 };
12948
12949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12951 if (!SWIG_IsOK(res1)) {
12952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12953 }
12954 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12955 if (obj1) {
12956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12957 if (!SWIG_IsOK(ecode2)) {
12958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12959 }
12960 arg2 = static_cast< bool >(val2);
12961 }
12962 {
12963 PyThreadState* __tstate = wxPyBeginAllowThreads();
12964 (arg1)->Show(arg2);
12965 wxPyEndAllowThreads(__tstate);
12966 if (PyErr_Occurred()) SWIG_fail;
12967 }
12968 resultobj = SWIG_Py_Void();
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 PyObject *resultobj = 0;
12977 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12978 wxFrame *result = 0 ;
12979 void *argp1 = 0 ;
12980 int res1 = 0 ;
12981 PyObject *swig_obj[1] ;
12982
12983 if (!args) SWIG_fail;
12984 swig_obj[0] = args;
12985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12986 if (!SWIG_IsOK(res1)) {
12987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12988 }
12989 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12990 {
12991 PyThreadState* __tstate = wxPyBeginAllowThreads();
12992 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12993 wxPyEndAllowThreads(__tstate);
12994 if (PyErr_Occurred()) SWIG_fail;
12995 }
12996 {
12997 resultobj = wxPyMake_wxObject(result, (bool)0);
12998 }
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13006 PyObject *resultobj = 0;
13007 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13008 wxLog *result = 0 ;
13009 void *argp1 = 0 ;
13010 int res1 = 0 ;
13011 PyObject *swig_obj[1] ;
13012
13013 if (!args) SWIG_fail;
13014 swig_obj[0] = args;
13015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13016 if (!SWIG_IsOK(res1)) {
13017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13018 }
13019 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13020 {
13021 PyThreadState* __tstate = wxPyBeginAllowThreads();
13022 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13023 wxPyEndAllowThreads(__tstate);
13024 if (PyErr_Occurred()) SWIG_fail;
13025 }
13026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13027 return resultobj;
13028 fail:
13029 return NULL;
13030 }
13031
13032
13033 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13034 PyObject *resultobj = 0;
13035 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13036 bool result;
13037 void *argp1 = 0 ;
13038 int res1 = 0 ;
13039 PyObject *swig_obj[1] ;
13040
13041 if (!args) SWIG_fail;
13042 swig_obj[0] = args;
13043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13044 if (!SWIG_IsOK(res1)) {
13045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13046 }
13047 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13051 wxPyEndAllowThreads(__tstate);
13052 if (PyErr_Occurred()) SWIG_fail;
13053 }
13054 {
13055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13056 }
13057 return resultobj;
13058 fail:
13059 return NULL;
13060 }
13061
13062
13063 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13064 PyObject *resultobj = 0;
13065 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13066 bool arg2 ;
13067 void *argp1 = 0 ;
13068 int res1 = 0 ;
13069 bool val2 ;
13070 int ecode2 = 0 ;
13071 PyObject * obj0 = 0 ;
13072 PyObject * obj1 = 0 ;
13073 char * kwnames[] = {
13074 (char *) "self",(char *) "bDoPass", NULL
13075 };
13076
13077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13079 if (!SWIG_IsOK(res1)) {
13080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13081 }
13082 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13083 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13084 if (!SWIG_IsOK(ecode2)) {
13085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13086 }
13087 arg2 = static_cast< bool >(val2);
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 (arg1)->PassMessages(arg2);
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_Py_Void();
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13102 PyObject *obj;
13103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13104 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13105 return SWIG_Py_Void();
13106 }
13107
13108 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13109 return SWIG_Python_InitShadowInstance(args);
13110 }
13111
13112 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13113 PyObject *resultobj = 0;
13114 wxLog *arg1 = (wxLog *) 0 ;
13115 wxLogChain *result = 0 ;
13116 void *argp1 = 0 ;
13117 int res1 = 0 ;
13118 PyObject * obj0 = 0 ;
13119 char * kwnames[] = {
13120 (char *) "logger", NULL
13121 };
13122
13123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13127 }
13128 arg1 = reinterpret_cast< wxLog * >(argp1);
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (wxLogChain *)new wxLogChain(arg1);
13132 wxPyEndAllowThreads(__tstate);
13133 if (PyErr_Occurred()) SWIG_fail;
13134 }
13135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13136 return resultobj;
13137 fail:
13138 return NULL;
13139 }
13140
13141
13142 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13143 PyObject *resultobj = 0;
13144 wxLogChain *arg1 = (wxLogChain *) 0 ;
13145 wxLog *arg2 = (wxLog *) 0 ;
13146 void *argp1 = 0 ;
13147 int res1 = 0 ;
13148 void *argp2 = 0 ;
13149 int res2 = 0 ;
13150 PyObject * obj0 = 0 ;
13151 PyObject * obj1 = 0 ;
13152 char * kwnames[] = {
13153 (char *) "self",(char *) "logger", NULL
13154 };
13155
13156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13158 if (!SWIG_IsOK(res1)) {
13159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13160 }
13161 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13162 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13163 if (!SWIG_IsOK(res2)) {
13164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13165 }
13166 arg2 = reinterpret_cast< wxLog * >(argp2);
13167 {
13168 PyThreadState* __tstate = wxPyBeginAllowThreads();
13169 (arg1)->SetLog(arg2);
13170 wxPyEndAllowThreads(__tstate);
13171 if (PyErr_Occurred()) SWIG_fail;
13172 }
13173 resultobj = SWIG_Py_Void();
13174 return resultobj;
13175 fail:
13176 return NULL;
13177 }
13178
13179
13180 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj = 0;
13182 wxLogChain *arg1 = (wxLogChain *) 0 ;
13183 bool arg2 ;
13184 void *argp1 = 0 ;
13185 int res1 = 0 ;
13186 bool val2 ;
13187 int ecode2 = 0 ;
13188 PyObject * obj0 = 0 ;
13189 PyObject * obj1 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "self",(char *) "bDoPass", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13198 }
13199 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13200 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13201 if (!SWIG_IsOK(ecode2)) {
13202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13203 }
13204 arg2 = static_cast< bool >(val2);
13205 {
13206 PyThreadState* __tstate = wxPyBeginAllowThreads();
13207 (arg1)->PassMessages(arg2);
13208 wxPyEndAllowThreads(__tstate);
13209 if (PyErr_Occurred()) SWIG_fail;
13210 }
13211 resultobj = SWIG_Py_Void();
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13219 PyObject *resultobj = 0;
13220 wxLogChain *arg1 = (wxLogChain *) 0 ;
13221 bool result;
13222 void *argp1 = 0 ;
13223 int res1 = 0 ;
13224 PyObject *swig_obj[1] ;
13225
13226 if (!args) SWIG_fail;
13227 swig_obj[0] = args;
13228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13229 if (!SWIG_IsOK(res1)) {
13230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13231 }
13232 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13233 {
13234 PyThreadState* __tstate = wxPyBeginAllowThreads();
13235 result = (bool)(arg1)->IsPassingMessages();
13236 wxPyEndAllowThreads(__tstate);
13237 if (PyErr_Occurred()) SWIG_fail;
13238 }
13239 {
13240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13241 }
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13249 PyObject *resultobj = 0;
13250 wxLogChain *arg1 = (wxLogChain *) 0 ;
13251 wxLog *result = 0 ;
13252 void *argp1 = 0 ;
13253 int res1 = 0 ;
13254 PyObject *swig_obj[1] ;
13255
13256 if (!args) SWIG_fail;
13257 swig_obj[0] = args;
13258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13259 if (!SWIG_IsOK(res1)) {
13260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13261 }
13262 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 result = (wxLog *)(arg1)->GetOldLog();
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13277 PyObject *obj;
13278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13279 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13280 return SWIG_Py_Void();
13281 }
13282
13283 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13284 return SWIG_Python_InitShadowInstance(args);
13285 }
13286
13287 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13288 PyObject *resultobj = 0;
13289 wxLogBuffer *result = 0 ;
13290
13291 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (wxLogBuffer *)new wxLogBuffer();
13295 wxPyEndAllowThreads(__tstate);
13296 if (PyErr_Occurred()) SWIG_fail;
13297 }
13298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13299 return resultobj;
13300 fail:
13301 return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13306 PyObject *resultobj = 0;
13307 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13308 wxString *result = 0 ;
13309 void *argp1 = 0 ;
13310 int res1 = 0 ;
13311 PyObject *swig_obj[1] ;
13312
13313 if (!args) SWIG_fail;
13314 swig_obj[0] = args;
13315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13316 if (!SWIG_IsOK(res1)) {
13317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13318 }
13319 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13320 {
13321 PyThreadState* __tstate = wxPyBeginAllowThreads();
13322 {
13323 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13324 result = (wxString *) &_result_ref;
13325 }
13326 wxPyEndAllowThreads(__tstate);
13327 if (PyErr_Occurred()) SWIG_fail;
13328 }
13329 {
13330 #if wxUSE_UNICODE
13331 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13332 #else
13333 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13334 #endif
13335 }
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13343 PyObject *obj;
13344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13345 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13346 return SWIG_Py_Void();
13347 }
13348
13349 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13350 return SWIG_Python_InitShadowInstance(args);
13351 }
13352
13353 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13354 PyObject *resultobj = 0;
13355 unsigned long result;
13356
13357 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (unsigned long)wxSysErrorCode();
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13365 return resultobj;
13366 fail:
13367 return NULL;
13368 }
13369
13370
13371 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj = 0;
13373 unsigned long arg1 = (unsigned long) 0 ;
13374 wxString result;
13375 unsigned long val1 ;
13376 int ecode1 = 0 ;
13377 PyObject * obj0 = 0 ;
13378 char * kwnames[] = {
13379 (char *) "nErrCode", NULL
13380 };
13381
13382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13383 if (obj0) {
13384 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13385 if (!SWIG_IsOK(ecode1)) {
13386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13387 }
13388 arg1 = static_cast< unsigned long >(val1);
13389 }
13390 {
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = wxSysErrorMsg(arg1);
13393 wxPyEndAllowThreads(__tstate);
13394 if (PyErr_Occurred()) SWIG_fail;
13395 }
13396 {
13397 #if wxUSE_UNICODE
13398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13399 #else
13400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13401 #endif
13402 }
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj = 0;
13411 wxString *arg1 = 0 ;
13412 bool temp1 = false ;
13413 PyObject * obj0 = 0 ;
13414 char * kwnames[] = {
13415 (char *) "msg", NULL
13416 };
13417
13418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13419 {
13420 arg1 = wxString_in_helper(obj0);
13421 if (arg1 == NULL) SWIG_fail;
13422 temp1 = true;
13423 }
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 wxPyLogFatalError((wxString const &)*arg1);
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 resultobj = SWIG_Py_Void();
13431 {
13432 if (temp1)
13433 delete arg1;
13434 }
13435 return resultobj;
13436 fail:
13437 {
13438 if (temp1)
13439 delete arg1;
13440 }
13441 return NULL;
13442 }
13443
13444
13445 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13446 PyObject *resultobj = 0;
13447 wxString *arg1 = 0 ;
13448 bool temp1 = false ;
13449 PyObject * obj0 = 0 ;
13450 char * kwnames[] = {
13451 (char *) "msg", NULL
13452 };
13453
13454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13455 {
13456 arg1 = wxString_in_helper(obj0);
13457 if (arg1 == NULL) SWIG_fail;
13458 temp1 = true;
13459 }
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 wxPyLogError((wxString const &)*arg1);
13463 wxPyEndAllowThreads(__tstate);
13464 if (PyErr_Occurred()) SWIG_fail;
13465 }
13466 resultobj = SWIG_Py_Void();
13467 {
13468 if (temp1)
13469 delete arg1;
13470 }
13471 return resultobj;
13472 fail:
13473 {
13474 if (temp1)
13475 delete arg1;
13476 }
13477 return NULL;
13478 }
13479
13480
13481 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj = 0;
13483 wxString *arg1 = 0 ;
13484 bool temp1 = false ;
13485 PyObject * obj0 = 0 ;
13486 char * kwnames[] = {
13487 (char *) "msg", NULL
13488 };
13489
13490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13491 {
13492 arg1 = wxString_in_helper(obj0);
13493 if (arg1 == NULL) SWIG_fail;
13494 temp1 = true;
13495 }
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 wxPyLogWarning((wxString const &)*arg1);
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 resultobj = SWIG_Py_Void();
13503 {
13504 if (temp1)
13505 delete arg1;
13506 }
13507 return resultobj;
13508 fail:
13509 {
13510 if (temp1)
13511 delete arg1;
13512 }
13513 return NULL;
13514 }
13515
13516
13517 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13518 PyObject *resultobj = 0;
13519 wxString *arg1 = 0 ;
13520 bool temp1 = false ;
13521 PyObject * obj0 = 0 ;
13522 char * kwnames[] = {
13523 (char *) "msg", NULL
13524 };
13525
13526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13527 {
13528 arg1 = wxString_in_helper(obj0);
13529 if (arg1 == NULL) SWIG_fail;
13530 temp1 = true;
13531 }
13532 {
13533 PyThreadState* __tstate = wxPyBeginAllowThreads();
13534 wxPyLogMessage((wxString const &)*arg1);
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 resultobj = SWIG_Py_Void();
13539 {
13540 if (temp1)
13541 delete arg1;
13542 }
13543 return resultobj;
13544 fail:
13545 {
13546 if (temp1)
13547 delete arg1;
13548 }
13549 return NULL;
13550 }
13551
13552
13553 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj = 0;
13555 wxString *arg1 = 0 ;
13556 bool temp1 = false ;
13557 PyObject * obj0 = 0 ;
13558 char * kwnames[] = {
13559 (char *) "msg", NULL
13560 };
13561
13562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13563 {
13564 arg1 = wxString_in_helper(obj0);
13565 if (arg1 == NULL) SWIG_fail;
13566 temp1 = true;
13567 }
13568 {
13569 PyThreadState* __tstate = wxPyBeginAllowThreads();
13570 wxPyLogInfo((wxString const &)*arg1);
13571 wxPyEndAllowThreads(__tstate);
13572 if (PyErr_Occurred()) SWIG_fail;
13573 }
13574 resultobj = SWIG_Py_Void();
13575 {
13576 if (temp1)
13577 delete arg1;
13578 }
13579 return resultobj;
13580 fail:
13581 {
13582 if (temp1)
13583 delete arg1;
13584 }
13585 return NULL;
13586 }
13587
13588
13589 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13590 PyObject *resultobj = 0;
13591 wxString *arg1 = 0 ;
13592 bool temp1 = false ;
13593 PyObject * obj0 = 0 ;
13594 char * kwnames[] = {
13595 (char *) "msg", NULL
13596 };
13597
13598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13599 {
13600 arg1 = wxString_in_helper(obj0);
13601 if (arg1 == NULL) SWIG_fail;
13602 temp1 = true;
13603 }
13604 {
13605 PyThreadState* __tstate = wxPyBeginAllowThreads();
13606 wxPyLogDebug((wxString const &)*arg1);
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 resultobj = SWIG_Py_Void();
13611 {
13612 if (temp1)
13613 delete arg1;
13614 }
13615 return resultobj;
13616 fail:
13617 {
13618 if (temp1)
13619 delete arg1;
13620 }
13621 return NULL;
13622 }
13623
13624
13625 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj = 0;
13627 wxString *arg1 = 0 ;
13628 bool temp1 = false ;
13629 PyObject * obj0 = 0 ;
13630 char * kwnames[] = {
13631 (char *) "msg", NULL
13632 };
13633
13634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13635 {
13636 arg1 = wxString_in_helper(obj0);
13637 if (arg1 == NULL) SWIG_fail;
13638 temp1 = true;
13639 }
13640 {
13641 PyThreadState* __tstate = wxPyBeginAllowThreads();
13642 wxPyLogVerbose((wxString const &)*arg1);
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 resultobj = SWIG_Py_Void();
13647 {
13648 if (temp1)
13649 delete arg1;
13650 }
13651 return resultobj;
13652 fail:
13653 {
13654 if (temp1)
13655 delete arg1;
13656 }
13657 return NULL;
13658 }
13659
13660
13661 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13662 PyObject *resultobj = 0;
13663 wxString *arg1 = 0 ;
13664 bool temp1 = false ;
13665 PyObject * obj0 = 0 ;
13666 char * kwnames[] = {
13667 (char *) "msg", NULL
13668 };
13669
13670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13671 {
13672 arg1 = wxString_in_helper(obj0);
13673 if (arg1 == NULL) SWIG_fail;
13674 temp1 = true;
13675 }
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 wxPyLogStatus((wxString const &)*arg1);
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_Py_Void();
13683 {
13684 if (temp1)
13685 delete arg1;
13686 }
13687 return resultobj;
13688 fail:
13689 {
13690 if (temp1)
13691 delete arg1;
13692 }
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxFrame *arg1 = (wxFrame *) 0 ;
13700 wxString *arg2 = 0 ;
13701 void *argp1 = 0 ;
13702 int res1 = 0 ;
13703 bool temp2 = false ;
13704 PyObject * obj0 = 0 ;
13705 PyObject * obj1 = 0 ;
13706 char * kwnames[] = {
13707 (char *) "pFrame",(char *) "msg", NULL
13708 };
13709
13710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13712 if (!SWIG_IsOK(res1)) {
13713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13714 }
13715 arg1 = reinterpret_cast< wxFrame * >(argp1);
13716 {
13717 arg2 = wxString_in_helper(obj1);
13718 if (arg2 == NULL) SWIG_fail;
13719 temp2 = true;
13720 }
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13724 wxPyEndAllowThreads(__tstate);
13725 if (PyErr_Occurred()) SWIG_fail;
13726 }
13727 resultobj = SWIG_Py_Void();
13728 {
13729 if (temp2)
13730 delete arg2;
13731 }
13732 return resultobj;
13733 fail:
13734 {
13735 if (temp2)
13736 delete arg2;
13737 }
13738 return NULL;
13739 }
13740
13741
13742 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13743 PyObject *resultobj = 0;
13744 wxString *arg1 = 0 ;
13745 bool temp1 = false ;
13746 PyObject * obj0 = 0 ;
13747 char * kwnames[] = {
13748 (char *) "msg", NULL
13749 };
13750
13751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13752 {
13753 arg1 = wxString_in_helper(obj0);
13754 if (arg1 == NULL) SWIG_fail;
13755 temp1 = true;
13756 }
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 wxPyLogSysError((wxString const &)*arg1);
13760 wxPyEndAllowThreads(__tstate);
13761 if (PyErr_Occurred()) SWIG_fail;
13762 }
13763 resultobj = SWIG_Py_Void();
13764 {
13765 if (temp1)
13766 delete arg1;
13767 }
13768 return resultobj;
13769 fail:
13770 {
13771 if (temp1)
13772 delete arg1;
13773 }
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj = 0;
13780 unsigned long arg1 ;
13781 wxString *arg2 = 0 ;
13782 unsigned long val1 ;
13783 int ecode1 = 0 ;
13784 bool temp2 = false ;
13785 PyObject * obj0 = 0 ;
13786 PyObject * obj1 = 0 ;
13787 char * kwnames[] = {
13788 (char *) "level",(char *) "msg", NULL
13789 };
13790
13791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13792 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13793 if (!SWIG_IsOK(ecode1)) {
13794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13795 }
13796 arg1 = static_cast< unsigned long >(val1);
13797 {
13798 arg2 = wxString_in_helper(obj1);
13799 if (arg2 == NULL) SWIG_fail;
13800 temp2 = true;
13801 }
13802 {
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13805 wxPyEndAllowThreads(__tstate);
13806 if (PyErr_Occurred()) SWIG_fail;
13807 }
13808 resultobj = SWIG_Py_Void();
13809 {
13810 if (temp2)
13811 delete arg2;
13812 }
13813 return resultobj;
13814 fail:
13815 {
13816 if (temp2)
13817 delete arg2;
13818 }
13819 return NULL;
13820 }
13821
13822
13823 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13824 PyObject *resultobj = 0;
13825 unsigned long arg1 ;
13826 wxString *arg2 = 0 ;
13827 unsigned long val1 ;
13828 int ecode1 = 0 ;
13829 bool temp2 = false ;
13830
13831 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13832 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13833 if (!SWIG_IsOK(ecode1)) {
13834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13835 }
13836 arg1 = static_cast< unsigned long >(val1);
13837 {
13838 arg2 = wxString_in_helper(swig_obj[1]);
13839 if (arg2 == NULL) SWIG_fail;
13840 temp2 = true;
13841 }
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 wxPyLogTrace(arg1,(wxString const &)*arg2);
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_Py_Void();
13849 {
13850 if (temp2)
13851 delete arg2;
13852 }
13853 return resultobj;
13854 fail:
13855 {
13856 if (temp2)
13857 delete arg2;
13858 }
13859 return NULL;
13860 }
13861
13862
13863 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13864 PyObject *resultobj = 0;
13865 wxString *arg1 = 0 ;
13866 wxString *arg2 = 0 ;
13867 bool temp1 = false ;
13868 bool temp2 = false ;
13869
13870 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13871 {
13872 arg1 = wxString_in_helper(swig_obj[0]);
13873 if (arg1 == NULL) SWIG_fail;
13874 temp1 = true;
13875 }
13876 {
13877 arg2 = wxString_in_helper(swig_obj[1]);
13878 if (arg2 == NULL) SWIG_fail;
13879 temp2 = true;
13880 }
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 resultobj = SWIG_Py_Void();
13888 {
13889 if (temp1)
13890 delete arg1;
13891 }
13892 {
13893 if (temp2)
13894 delete arg2;
13895 }
13896 return resultobj;
13897 fail:
13898 {
13899 if (temp1)
13900 delete arg1;
13901 }
13902 {
13903 if (temp2)
13904 delete arg2;
13905 }
13906 return NULL;
13907 }
13908
13909
13910 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
13911 int argc;
13912 PyObject *argv[3];
13913
13914 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
13915 --argc;
13916 if (argc == 2) {
13917 int _v = 0;
13918 {
13919 {
13920 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
13921 }
13922 }
13923 if (!_v) goto check_1;
13924 return _wrap_LogTrace__SWIG_1(self, argc, argv);
13925 }
13926 check_1:
13927
13928 if (argc == 2) {
13929 return _wrap_LogTrace__SWIG_0(self, argc, argv);
13930 }
13931
13932 fail:
13933 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
13934 return NULL;
13935 }
13936
13937
13938 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj = 0;
13940 wxString *arg1 = 0 ;
13941 wxString *arg2 = 0 ;
13942 bool temp1 = false ;
13943 bool temp2 = false ;
13944 PyObject * obj0 = 0 ;
13945 PyObject * obj1 = 0 ;
13946 char * kwnames[] = {
13947 (char *) "title",(char *) "text", NULL
13948 };
13949
13950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13951 {
13952 arg1 = wxString_in_helper(obj0);
13953 if (arg1 == NULL) SWIG_fail;
13954 temp1 = true;
13955 }
13956 {
13957 arg2 = wxString_in_helper(obj1);
13958 if (arg2 == NULL) SWIG_fail;
13959 temp2 = true;
13960 }
13961 {
13962 PyThreadState* __tstate = wxPyBeginAllowThreads();
13963 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 resultobj = SWIG_Py_Void();
13968 {
13969 if (temp1)
13970 delete arg1;
13971 }
13972 {
13973 if (temp2)
13974 delete arg2;
13975 }
13976 return resultobj;
13977 fail:
13978 {
13979 if (temp1)
13980 delete arg1;
13981 }
13982 {
13983 if (temp2)
13984 delete arg2;
13985 }
13986 return NULL;
13987 }
13988
13989
13990 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13991 PyObject *resultobj = 0;
13992 wxLogNull *result = 0 ;
13993
13994 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 result = (wxLogNull *)new wxLogNull();
13998 wxPyEndAllowThreads(__tstate);
13999 if (PyErr_Occurred()) SWIG_fail;
14000 }
14001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14009 PyObject *resultobj = 0;
14010 wxLogNull *arg1 = (wxLogNull *) 0 ;
14011 void *argp1 = 0 ;
14012 int res1 = 0 ;
14013 PyObject *swig_obj[1] ;
14014
14015 if (!args) SWIG_fail;
14016 swig_obj[0] = args;
14017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14018 if (!SWIG_IsOK(res1)) {
14019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14020 }
14021 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 delete arg1;
14025
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 resultobj = SWIG_Py_Void();
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14037 PyObject *obj;
14038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14039 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14040 return SWIG_Py_Void();
14041 }
14042
14043 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14044 return SWIG_Python_InitShadowInstance(args);
14045 }
14046
14047 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14048 PyObject *resultobj = 0;
14049 wxPyLog *result = 0 ;
14050
14051 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14052 {
14053 PyThreadState* __tstate = wxPyBeginAllowThreads();
14054 result = (wxPyLog *)new wxPyLog();
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14059 return resultobj;
14060 fail:
14061 return NULL;
14062 }
14063
14064
14065 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14066 PyObject *resultobj = 0;
14067 wxPyLog *arg1 = (wxPyLog *) 0 ;
14068 PyObject *arg2 = (PyObject *) 0 ;
14069 PyObject *arg3 = (PyObject *) 0 ;
14070 void *argp1 = 0 ;
14071 int res1 = 0 ;
14072 PyObject * obj0 = 0 ;
14073 PyObject * obj1 = 0 ;
14074 PyObject * obj2 = 0 ;
14075 char * kwnames[] = {
14076 (char *) "self",(char *) "self",(char *) "_class", NULL
14077 };
14078
14079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14081 if (!SWIG_IsOK(res1)) {
14082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14083 }
14084 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14085 arg2 = obj1;
14086 arg3 = obj2;
14087 {
14088 PyThreadState* __tstate = wxPyBeginAllowThreads();
14089 (arg1)->_setCallbackInfo(arg2,arg3);
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 resultobj = SWIG_Py_Void();
14094 return resultobj;
14095 fail:
14096 return NULL;
14097 }
14098
14099
14100 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14101 PyObject *obj;
14102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14103 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14104 return SWIG_Py_Void();
14105 }
14106
14107 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14108 return SWIG_Python_InitShadowInstance(args);
14109 }
14110
14111 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14112 PyObject *resultobj = 0;
14113 int arg1 ;
14114 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14115 int arg3 = (int) wxKILL_NOCHILDREN ;
14116 wxKillError result;
14117 int val1 ;
14118 int ecode1 = 0 ;
14119 int val2 ;
14120 int ecode2 = 0 ;
14121 int val3 ;
14122 int ecode3 = 0 ;
14123 PyObject * obj0 = 0 ;
14124 PyObject * obj1 = 0 ;
14125 PyObject * obj2 = 0 ;
14126 char * kwnames[] = {
14127 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14128 };
14129
14130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14131 ecode1 = SWIG_AsVal_int(obj0, &val1);
14132 if (!SWIG_IsOK(ecode1)) {
14133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14134 }
14135 arg1 = static_cast< int >(val1);
14136 if (obj1) {
14137 ecode2 = SWIG_AsVal_int(obj1, &val2);
14138 if (!SWIG_IsOK(ecode2)) {
14139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14140 }
14141 arg2 = static_cast< wxSignal >(val2);
14142 }
14143 if (obj2) {
14144 ecode3 = SWIG_AsVal_int(obj2, &val3);
14145 if (!SWIG_IsOK(ecode3)) {
14146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14147 }
14148 arg3 = static_cast< int >(val3);
14149 }
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14153 wxPyEndAllowThreads(__tstate);
14154 if (PyErr_Occurred()) SWIG_fail;
14155 }
14156 resultobj = SWIG_From_int(static_cast< int >(result));
14157 return resultobj;
14158 fail:
14159 return NULL;
14160 }
14161
14162
14163 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14164 PyObject *resultobj = 0;
14165 int arg1 ;
14166 bool result;
14167 int val1 ;
14168 int ecode1 = 0 ;
14169 PyObject * obj0 = 0 ;
14170 char * kwnames[] = {
14171 (char *) "pid", NULL
14172 };
14173
14174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14175 ecode1 = SWIG_AsVal_int(obj0, &val1);
14176 if (!SWIG_IsOK(ecode1)) {
14177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14178 }
14179 arg1 = static_cast< int >(val1);
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 result = (bool)wxPyProcess::Exists(arg1);
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 {
14187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14188 }
14189 return resultobj;
14190 fail:
14191 return NULL;
14192 }
14193
14194
14195 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14196 PyObject *resultobj = 0;
14197 wxString *arg1 = 0 ;
14198 int arg2 = (int) wxEXEC_ASYNC ;
14199 wxPyProcess *result = 0 ;
14200 bool temp1 = false ;
14201 int val2 ;
14202 int ecode2 = 0 ;
14203 PyObject * obj0 = 0 ;
14204 PyObject * obj1 = 0 ;
14205 char * kwnames[] = {
14206 (char *) "cmd",(char *) "flags", NULL
14207 };
14208
14209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14210 {
14211 arg1 = wxString_in_helper(obj0);
14212 if (arg1 == NULL) SWIG_fail;
14213 temp1 = true;
14214 }
14215 if (obj1) {
14216 ecode2 = SWIG_AsVal_int(obj1, &val2);
14217 if (!SWIG_IsOK(ecode2)) {
14218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14219 }
14220 arg2 = static_cast< int >(val2);
14221 }
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14225 wxPyEndAllowThreads(__tstate);
14226 if (PyErr_Occurred()) SWIG_fail;
14227 }
14228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14229 {
14230 if (temp1)
14231 delete arg1;
14232 }
14233 return resultobj;
14234 fail:
14235 {
14236 if (temp1)
14237 delete arg1;
14238 }
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj = 0;
14245 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14246 int arg2 = (int) -1 ;
14247 wxPyProcess *result = 0 ;
14248 void *argp1 = 0 ;
14249 int res1 = 0 ;
14250 int val2 ;
14251 int ecode2 = 0 ;
14252 PyObject * obj0 = 0 ;
14253 PyObject * obj1 = 0 ;
14254 char * kwnames[] = {
14255 (char *) "parent",(char *) "id", NULL
14256 };
14257
14258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14259 if (obj0) {
14260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14261 if (!SWIG_IsOK(res1)) {
14262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14263 }
14264 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14265 }
14266 if (obj1) {
14267 ecode2 = SWIG_AsVal_int(obj1, &val2);
14268 if (!SWIG_IsOK(ecode2)) {
14269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14270 }
14271 arg2 = static_cast< int >(val2);
14272 }
14273 {
14274 PyThreadState* __tstate = wxPyBeginAllowThreads();
14275 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14287 PyObject *resultobj = 0;
14288 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14289 PyObject *arg2 = (PyObject *) 0 ;
14290 PyObject *arg3 = (PyObject *) 0 ;
14291 void *argp1 = 0 ;
14292 int res1 = 0 ;
14293 PyObject * obj0 = 0 ;
14294 PyObject * obj1 = 0 ;
14295 PyObject * obj2 = 0 ;
14296 char * kwnames[] = {
14297 (char *) "self",(char *) "self",(char *) "_class", NULL
14298 };
14299
14300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14302 if (!SWIG_IsOK(res1)) {
14303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14304 }
14305 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14306 arg2 = obj1;
14307 arg3 = obj2;
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 (arg1)->_setCallbackInfo(arg2,arg3);
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 resultobj = SWIG_Py_Void();
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj = 0;
14323 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14324 int arg2 ;
14325 int arg3 ;
14326 void *argp1 = 0 ;
14327 int res1 = 0 ;
14328 int val2 ;
14329 int ecode2 = 0 ;
14330 int val3 ;
14331 int ecode3 = 0 ;
14332 PyObject * obj0 = 0 ;
14333 PyObject * obj1 = 0 ;
14334 PyObject * obj2 = 0 ;
14335 char * kwnames[] = {
14336 (char *) "self",(char *) "pid",(char *) "status", NULL
14337 };
14338
14339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14341 if (!SWIG_IsOK(res1)) {
14342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14343 }
14344 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14345 ecode2 = SWIG_AsVal_int(obj1, &val2);
14346 if (!SWIG_IsOK(ecode2)) {
14347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14348 }
14349 arg2 = static_cast< int >(val2);
14350 ecode3 = SWIG_AsVal_int(obj2, &val3);
14351 if (!SWIG_IsOK(ecode3)) {
14352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14353 }
14354 arg3 = static_cast< int >(val3);
14355 {
14356 PyThreadState* __tstate = wxPyBeginAllowThreads();
14357 (arg1)->OnTerminate(arg2,arg3);
14358 wxPyEndAllowThreads(__tstate);
14359 if (PyErr_Occurred()) SWIG_fail;
14360 }
14361 resultobj = SWIG_Py_Void();
14362 return resultobj;
14363 fail:
14364 return NULL;
14365 }
14366
14367
14368 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14369 PyObject *resultobj = 0;
14370 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14371 void *argp1 = 0 ;
14372 int res1 = 0 ;
14373 PyObject *swig_obj[1] ;
14374
14375 if (!args) SWIG_fail;
14376 swig_obj[0] = args;
14377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14378 if (!SWIG_IsOK(res1)) {
14379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14380 }
14381 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 (arg1)->Redirect();
14385 wxPyEndAllowThreads(__tstate);
14386 if (PyErr_Occurred()) SWIG_fail;
14387 }
14388 resultobj = SWIG_Py_Void();
14389 return resultobj;
14390 fail:
14391 return NULL;
14392 }
14393
14394
14395 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14396 PyObject *resultobj = 0;
14397 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14398 bool result;
14399 void *argp1 = 0 ;
14400 int res1 = 0 ;
14401 PyObject *swig_obj[1] ;
14402
14403 if (!args) SWIG_fail;
14404 swig_obj[0] = args;
14405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14406 if (!SWIG_IsOK(res1)) {
14407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14408 }
14409 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = (bool)(arg1)->IsRedirected();
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 {
14417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14418 }
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14426 PyObject *resultobj = 0;
14427 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 PyObject *swig_obj[1] ;
14431
14432 if (!args) SWIG_fail;
14433 swig_obj[0] = args;
14434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14435 if (!SWIG_IsOK(res1)) {
14436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14437 }
14438 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 (arg1)->Detach();
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 resultobj = SWIG_Py_Void();
14446 return resultobj;
14447 fail:
14448 return NULL;
14449 }
14450
14451
14452 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14453 PyObject *resultobj = 0;
14454 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14455 wxInputStream *result = 0 ;
14456 void *argp1 = 0 ;
14457 int res1 = 0 ;
14458 PyObject *swig_obj[1] ;
14459
14460 if (!args) SWIG_fail;
14461 swig_obj[0] = args;
14462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14463 if (!SWIG_IsOK(res1)) {
14464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14465 }
14466 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (wxInputStream *)(arg1)->GetInputStream();
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 {
14474 wxPyInputStream * _ptr = NULL;
14475
14476 if (result) {
14477 _ptr = new wxPyInputStream(result);
14478 }
14479 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14480 }
14481 return resultobj;
14482 fail:
14483 return NULL;
14484 }
14485
14486
14487 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14488 PyObject *resultobj = 0;
14489 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14490 wxInputStream *result = 0 ;
14491 void *argp1 = 0 ;
14492 int res1 = 0 ;
14493 PyObject *swig_obj[1] ;
14494
14495 if (!args) SWIG_fail;
14496 swig_obj[0] = args;
14497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14498 if (!SWIG_IsOK(res1)) {
14499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14500 }
14501 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14502 {
14503 PyThreadState* __tstate = wxPyBeginAllowThreads();
14504 result = (wxInputStream *)(arg1)->GetErrorStream();
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 wxPyInputStream * _ptr = NULL;
14510
14511 if (result) {
14512 _ptr = new wxPyInputStream(result);
14513 }
14514 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14515 }
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14523 PyObject *resultobj = 0;
14524 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14525 wxOutputStream *result = 0 ;
14526 void *argp1 = 0 ;
14527 int res1 = 0 ;
14528 PyObject *swig_obj[1] ;
14529
14530 if (!args) SWIG_fail;
14531 swig_obj[0] = args;
14532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14533 if (!SWIG_IsOK(res1)) {
14534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14535 }
14536 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (wxOutputStream *)(arg1)->GetOutputStream();
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14544 return resultobj;
14545 fail:
14546 return NULL;
14547 }
14548
14549
14550 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14551 PyObject *resultobj = 0;
14552 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14553 void *argp1 = 0 ;
14554 int res1 = 0 ;
14555 PyObject *swig_obj[1] ;
14556
14557 if (!args) SWIG_fail;
14558 swig_obj[0] = args;
14559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14560 if (!SWIG_IsOK(res1)) {
14561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14562 }
14563 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14564 {
14565 PyThreadState* __tstate = wxPyBeginAllowThreads();
14566 (arg1)->CloseOutput();
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 resultobj = SWIG_Py_Void();
14571 return resultobj;
14572 fail:
14573 return NULL;
14574 }
14575
14576
14577 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14578 PyObject *resultobj = 0;
14579 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14580 bool result;
14581 void *argp1 = 0 ;
14582 int res1 = 0 ;
14583 PyObject *swig_obj[1] ;
14584
14585 if (!args) SWIG_fail;
14586 swig_obj[0] = args;
14587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14588 if (!SWIG_IsOK(res1)) {
14589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14590 }
14591 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14592 {
14593 PyThreadState* __tstate = wxPyBeginAllowThreads();
14594 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14595 wxPyEndAllowThreads(__tstate);
14596 if (PyErr_Occurred()) SWIG_fail;
14597 }
14598 {
14599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14600 }
14601 return resultobj;
14602 fail:
14603 return NULL;
14604 }
14605
14606
14607 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14608 PyObject *resultobj = 0;
14609 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14610 bool result;
14611 void *argp1 = 0 ;
14612 int res1 = 0 ;
14613 PyObject *swig_obj[1] ;
14614
14615 if (!args) SWIG_fail;
14616 swig_obj[0] = args;
14617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14618 if (!SWIG_IsOK(res1)) {
14619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14620 }
14621 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14622 {
14623 PyThreadState* __tstate = wxPyBeginAllowThreads();
14624 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14625 wxPyEndAllowThreads(__tstate);
14626 if (PyErr_Occurred()) SWIG_fail;
14627 }
14628 {
14629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14630 }
14631 return resultobj;
14632 fail:
14633 return NULL;
14634 }
14635
14636
14637 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14638 PyObject *resultobj = 0;
14639 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14640 bool result;
14641 void *argp1 = 0 ;
14642 int res1 = 0 ;
14643 PyObject *swig_obj[1] ;
14644
14645 if (!args) SWIG_fail;
14646 swig_obj[0] = args;
14647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14648 if (!SWIG_IsOK(res1)) {
14649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14650 }
14651 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14652 {
14653 PyThreadState* __tstate = wxPyBeginAllowThreads();
14654 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14655 wxPyEndAllowThreads(__tstate);
14656 if (PyErr_Occurred()) SWIG_fail;
14657 }
14658 {
14659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14660 }
14661 return resultobj;
14662 fail:
14663 return NULL;
14664 }
14665
14666
14667 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14668 PyObject *obj;
14669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14670 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14671 return SWIG_Py_Void();
14672 }
14673
14674 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14675 return SWIG_Python_InitShadowInstance(args);
14676 }
14677
14678 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14679 PyObject *resultobj = 0;
14680 int arg1 = (int) 0 ;
14681 int arg2 = (int) 0 ;
14682 int arg3 = (int) 0 ;
14683 wxProcessEvent *result = 0 ;
14684 int val1 ;
14685 int ecode1 = 0 ;
14686 int val2 ;
14687 int ecode2 = 0 ;
14688 int val3 ;
14689 int ecode3 = 0 ;
14690 PyObject * obj0 = 0 ;
14691 PyObject * obj1 = 0 ;
14692 PyObject * obj2 = 0 ;
14693 char * kwnames[] = {
14694 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14695 };
14696
14697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14698 if (obj0) {
14699 ecode1 = SWIG_AsVal_int(obj0, &val1);
14700 if (!SWIG_IsOK(ecode1)) {
14701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14702 }
14703 arg1 = static_cast< int >(val1);
14704 }
14705 if (obj1) {
14706 ecode2 = SWIG_AsVal_int(obj1, &val2);
14707 if (!SWIG_IsOK(ecode2)) {
14708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14709 }
14710 arg2 = static_cast< int >(val2);
14711 }
14712 if (obj2) {
14713 ecode3 = SWIG_AsVal_int(obj2, &val3);
14714 if (!SWIG_IsOK(ecode3)) {
14715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14716 }
14717 arg3 = static_cast< int >(val3);
14718 }
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14735 int result;
14736 void *argp1 = 0 ;
14737 int res1 = 0 ;
14738 PyObject *swig_obj[1] ;
14739
14740 if (!args) SWIG_fail;
14741 swig_obj[0] = args;
14742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14745 }
14746 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 result = (int)(arg1)->GetPid();
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 resultobj = SWIG_From_int(static_cast< int >(result));
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14761 PyObject *resultobj = 0;
14762 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14763 int result;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 PyObject *swig_obj[1] ;
14767
14768 if (!args) SWIG_fail;
14769 swig_obj[0] = args;
14770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14771 if (!SWIG_IsOK(res1)) {
14772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14773 }
14774 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (int)(arg1)->GetExitCode();
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 resultobj = SWIG_From_int(static_cast< int >(result));
14782 return resultobj;
14783 fail:
14784 return NULL;
14785 }
14786
14787
14788 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14789 PyObject *resultobj = 0;
14790 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14791 int arg2 ;
14792 void *argp1 = 0 ;
14793 int res1 = 0 ;
14794 int val2 ;
14795 int ecode2 = 0 ;
14796 PyObject *swig_obj[2] ;
14797
14798 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14800 if (!SWIG_IsOK(res1)) {
14801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14802 }
14803 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14804 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14805 if (!SWIG_IsOK(ecode2)) {
14806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14807 }
14808 arg2 = static_cast< int >(val2);
14809 if (arg1) (arg1)->m_pid = arg2;
14810
14811 resultobj = SWIG_Py_Void();
14812 return resultobj;
14813 fail:
14814 return NULL;
14815 }
14816
14817
14818 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14819 PyObject *resultobj = 0;
14820 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14821 int result;
14822 void *argp1 = 0 ;
14823 int res1 = 0 ;
14824 PyObject *swig_obj[1] ;
14825
14826 if (!args) SWIG_fail;
14827 swig_obj[0] = args;
14828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14829 if (!SWIG_IsOK(res1)) {
14830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14831 }
14832 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14833 result = (int) ((arg1)->m_pid);
14834 resultobj = SWIG_From_int(static_cast< int >(result));
14835 return resultobj;
14836 fail:
14837 return NULL;
14838 }
14839
14840
14841 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14842 PyObject *resultobj = 0;
14843 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14844 int arg2 ;
14845 void *argp1 = 0 ;
14846 int res1 = 0 ;
14847 int val2 ;
14848 int ecode2 = 0 ;
14849 PyObject *swig_obj[2] ;
14850
14851 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14853 if (!SWIG_IsOK(res1)) {
14854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14855 }
14856 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14857 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14858 if (!SWIG_IsOK(ecode2)) {
14859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14860 }
14861 arg2 = static_cast< int >(val2);
14862 if (arg1) (arg1)->m_exitcode = arg2;
14863
14864 resultobj = SWIG_Py_Void();
14865 return resultobj;
14866 fail:
14867 return NULL;
14868 }
14869
14870
14871 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14872 PyObject *resultobj = 0;
14873 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14874 int result;
14875 void *argp1 = 0 ;
14876 int res1 = 0 ;
14877 PyObject *swig_obj[1] ;
14878
14879 if (!args) SWIG_fail;
14880 swig_obj[0] = args;
14881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14882 if (!SWIG_IsOK(res1)) {
14883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14884 }
14885 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14886 result = (int) ((arg1)->m_exitcode);
14887 resultobj = SWIG_From_int(static_cast< int >(result));
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14895 PyObject *obj;
14896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14897 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
14898 return SWIG_Py_Void();
14899 }
14900
14901 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14902 return SWIG_Python_InitShadowInstance(args);
14903 }
14904
14905 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14906 PyObject *resultobj = 0;
14907 wxString *arg1 = 0 ;
14908 int arg2 = (int) wxEXEC_ASYNC ;
14909 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
14910 long result;
14911 bool temp1 = false ;
14912 int val2 ;
14913 int ecode2 = 0 ;
14914 void *argp3 = 0 ;
14915 int res3 = 0 ;
14916 PyObject * obj0 = 0 ;
14917 PyObject * obj1 = 0 ;
14918 PyObject * obj2 = 0 ;
14919 char * kwnames[] = {
14920 (char *) "command",(char *) "flags",(char *) "process", NULL
14921 };
14922
14923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14924 {
14925 arg1 = wxString_in_helper(obj0);
14926 if (arg1 == NULL) SWIG_fail;
14927 temp1 = true;
14928 }
14929 if (obj1) {
14930 ecode2 = SWIG_AsVal_int(obj1, &val2);
14931 if (!SWIG_IsOK(ecode2)) {
14932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
14933 }
14934 arg2 = static_cast< int >(val2);
14935 }
14936 if (obj2) {
14937 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14938 if (!SWIG_IsOK(res3)) {
14939 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14940 }
14941 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14942 }
14943 {
14944 if (!wxPyCheckForApp()) SWIG_fail;
14945 PyThreadState* __tstate = wxPyBeginAllowThreads();
14946 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 resultobj = SWIG_From_long(static_cast< long >(result));
14951 {
14952 if (temp1)
14953 delete arg1;
14954 }
14955 return resultobj;
14956 fail:
14957 {
14958 if (temp1)
14959 delete arg1;
14960 }
14961 return NULL;
14962 }
14963
14964
14965 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14966 PyObject *resultobj = 0;
14967 long arg1 ;
14968 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14969 wxKillError *arg3 = (wxKillError *) 0 ;
14970 int arg4 = (int) wxKILL_NOCHILDREN ;
14971 int result;
14972 long val1 ;
14973 int ecode1 = 0 ;
14974 int val2 ;
14975 int ecode2 = 0 ;
14976 wxKillError temp3 ;
14977 int val4 ;
14978 int ecode4 = 0 ;
14979 PyObject * obj0 = 0 ;
14980 PyObject * obj1 = 0 ;
14981 PyObject * obj2 = 0 ;
14982 char * kwnames[] = {
14983 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14984 };
14985
14986 {
14987 arg3 = &temp3;
14988 }
14989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14990 ecode1 = SWIG_AsVal_long(obj0, &val1);
14991 if (!SWIG_IsOK(ecode1)) {
14992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14993 }
14994 arg1 = static_cast< long >(val1);
14995 if (obj1) {
14996 ecode2 = SWIG_AsVal_int(obj1, &val2);
14997 if (!SWIG_IsOK(ecode2)) {
14998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14999 }
15000 arg2 = static_cast< wxSignal >(val2);
15001 }
15002 if (obj2) {
15003 ecode4 = SWIG_AsVal_int(obj2, &val4);
15004 if (!SWIG_IsOK(ecode4)) {
15005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15006 }
15007 arg4 = static_cast< int >(val4);
15008 }
15009 {
15010 PyThreadState* __tstate = wxPyBeginAllowThreads();
15011 result = (int)wxKill(arg1,arg2,arg3,arg4);
15012 wxPyEndAllowThreads(__tstate);
15013 if (PyErr_Occurred()) SWIG_fail;
15014 }
15015 resultobj = SWIG_From_int(static_cast< int >(result));
15016 {
15017 PyObject* o;
15018 o = PyInt_FromLong((long) (*arg3));
15019
15020
15021
15022 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15023
15024 }
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15032 PyObject *resultobj = 0;
15033 int arg1 = (int) wxJOYSTICK1 ;
15034 wxJoystick *result = 0 ;
15035 int val1 ;
15036 int ecode1 = 0 ;
15037 PyObject * obj0 = 0 ;
15038 char * kwnames[] = {
15039 (char *) "joystick", NULL
15040 };
15041
15042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15043 if (obj0) {
15044 ecode1 = SWIG_AsVal_int(obj0, &val1);
15045 if (!SWIG_IsOK(ecode1)) {
15046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15047 }
15048 arg1 = static_cast< int >(val1);
15049 }
15050 {
15051 if (!wxPyCheckForApp()) SWIG_fail;
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (wxJoystick *)new wxJoystick(arg1);
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15065 PyObject *resultobj = 0;
15066 wxJoystick *arg1 = (wxJoystick *) 0 ;
15067 void *argp1 = 0 ;
15068 int res1 = 0 ;
15069 PyObject *swig_obj[1] ;
15070
15071 if (!args) SWIG_fail;
15072 swig_obj[0] = args;
15073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15074 if (!SWIG_IsOK(res1)) {
15075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15076 }
15077 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 delete arg1;
15081
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 resultobj = SWIG_Py_Void();
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15093 PyObject *resultobj = 0;
15094 wxJoystick *arg1 = (wxJoystick *) 0 ;
15095 wxPoint result;
15096 void *argp1 = 0 ;
15097 int res1 = 0 ;
15098 PyObject *swig_obj[1] ;
15099
15100 if (!args) SWIG_fail;
15101 swig_obj[0] = args;
15102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15103 if (!SWIG_IsOK(res1)) {
15104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15105 }
15106 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 result = (arg1)->GetPosition();
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15121 PyObject *resultobj = 0;
15122 wxJoystick *arg1 = (wxJoystick *) 0 ;
15123 int result;
15124 void *argp1 = 0 ;
15125 int res1 = 0 ;
15126 PyObject *swig_obj[1] ;
15127
15128 if (!args) SWIG_fail;
15129 swig_obj[0] = args;
15130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15131 if (!SWIG_IsOK(res1)) {
15132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15133 }
15134 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15135 {
15136 PyThreadState* __tstate = wxPyBeginAllowThreads();
15137 result = (int)(arg1)->GetZPosition();
15138 wxPyEndAllowThreads(__tstate);
15139 if (PyErr_Occurred()) SWIG_fail;
15140 }
15141 resultobj = SWIG_From_int(static_cast< int >(result));
15142 return resultobj;
15143 fail:
15144 return NULL;
15145 }
15146
15147
15148 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15149 PyObject *resultobj = 0;
15150 wxJoystick *arg1 = (wxJoystick *) 0 ;
15151 int result;
15152 void *argp1 = 0 ;
15153 int res1 = 0 ;
15154 PyObject *swig_obj[1] ;
15155
15156 if (!args) SWIG_fail;
15157 swig_obj[0] = args;
15158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15159 if (!SWIG_IsOK(res1)) {
15160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15161 }
15162 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15163 {
15164 PyThreadState* __tstate = wxPyBeginAllowThreads();
15165 result = (int)(arg1)->GetButtonState();
15166 wxPyEndAllowThreads(__tstate);
15167 if (PyErr_Occurred()) SWIG_fail;
15168 }
15169 resultobj = SWIG_From_int(static_cast< int >(result));
15170 return resultobj;
15171 fail:
15172 return NULL;
15173 }
15174
15175
15176 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15177 PyObject *resultobj = 0;
15178 wxJoystick *arg1 = (wxJoystick *) 0 ;
15179 int result;
15180 void *argp1 = 0 ;
15181 int res1 = 0 ;
15182 PyObject *swig_obj[1] ;
15183
15184 if (!args) SWIG_fail;
15185 swig_obj[0] = args;
15186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15187 if (!SWIG_IsOK(res1)) {
15188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15189 }
15190 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15191 {
15192 PyThreadState* __tstate = wxPyBeginAllowThreads();
15193 result = (int)(arg1)->GetPOVPosition();
15194 wxPyEndAllowThreads(__tstate);
15195 if (PyErr_Occurred()) SWIG_fail;
15196 }
15197 resultobj = SWIG_From_int(static_cast< int >(result));
15198 return resultobj;
15199 fail:
15200 return NULL;
15201 }
15202
15203
15204 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15205 PyObject *resultobj = 0;
15206 wxJoystick *arg1 = (wxJoystick *) 0 ;
15207 int result;
15208 void *argp1 = 0 ;
15209 int res1 = 0 ;
15210 PyObject *swig_obj[1] ;
15211
15212 if (!args) SWIG_fail;
15213 swig_obj[0] = args;
15214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15215 if (!SWIG_IsOK(res1)) {
15216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15217 }
15218 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15219 {
15220 PyThreadState* __tstate = wxPyBeginAllowThreads();
15221 result = (int)(arg1)->GetPOVCTSPosition();
15222 wxPyEndAllowThreads(__tstate);
15223 if (PyErr_Occurred()) SWIG_fail;
15224 }
15225 resultobj = SWIG_From_int(static_cast< int >(result));
15226 return resultobj;
15227 fail:
15228 return NULL;
15229 }
15230
15231
15232 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15233 PyObject *resultobj = 0;
15234 wxJoystick *arg1 = (wxJoystick *) 0 ;
15235 int result;
15236 void *argp1 = 0 ;
15237 int res1 = 0 ;
15238 PyObject *swig_obj[1] ;
15239
15240 if (!args) SWIG_fail;
15241 swig_obj[0] = args;
15242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15243 if (!SWIG_IsOK(res1)) {
15244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15245 }
15246 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = (int)(arg1)->GetRudderPosition();
15250 wxPyEndAllowThreads(__tstate);
15251 if (PyErr_Occurred()) SWIG_fail;
15252 }
15253 resultobj = SWIG_From_int(static_cast< int >(result));
15254 return resultobj;
15255 fail:
15256 return NULL;
15257 }
15258
15259
15260 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15261 PyObject *resultobj = 0;
15262 wxJoystick *arg1 = (wxJoystick *) 0 ;
15263 int result;
15264 void *argp1 = 0 ;
15265 int res1 = 0 ;
15266 PyObject *swig_obj[1] ;
15267
15268 if (!args) SWIG_fail;
15269 swig_obj[0] = args;
15270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15271 if (!SWIG_IsOK(res1)) {
15272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15273 }
15274 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15275 {
15276 PyThreadState* __tstate = wxPyBeginAllowThreads();
15277 result = (int)(arg1)->GetUPosition();
15278 wxPyEndAllowThreads(__tstate);
15279 if (PyErr_Occurred()) SWIG_fail;
15280 }
15281 resultobj = SWIG_From_int(static_cast< int >(result));
15282 return resultobj;
15283 fail:
15284 return NULL;
15285 }
15286
15287
15288 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15289 PyObject *resultobj = 0;
15290 wxJoystick *arg1 = (wxJoystick *) 0 ;
15291 int result;
15292 void *argp1 = 0 ;
15293 int res1 = 0 ;
15294 PyObject *swig_obj[1] ;
15295
15296 if (!args) SWIG_fail;
15297 swig_obj[0] = args;
15298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15299 if (!SWIG_IsOK(res1)) {
15300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15301 }
15302 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (int)(arg1)->GetVPosition();
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = SWIG_From_int(static_cast< int >(result));
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15317 PyObject *resultobj = 0;
15318 wxJoystick *arg1 = (wxJoystick *) 0 ;
15319 int result;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 PyObject *swig_obj[1] ;
15323
15324 if (!args) SWIG_fail;
15325 swig_obj[0] = args;
15326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15329 }
15330 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (int)(arg1)->GetMovementThreshold();
15334 wxPyEndAllowThreads(__tstate);
15335 if (PyErr_Occurred()) SWIG_fail;
15336 }
15337 resultobj = SWIG_From_int(static_cast< int >(result));
15338 return resultobj;
15339 fail:
15340 return NULL;
15341 }
15342
15343
15344 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15345 PyObject *resultobj = 0;
15346 wxJoystick *arg1 = (wxJoystick *) 0 ;
15347 int arg2 ;
15348 void *argp1 = 0 ;
15349 int res1 = 0 ;
15350 int val2 ;
15351 int ecode2 = 0 ;
15352 PyObject * obj0 = 0 ;
15353 PyObject * obj1 = 0 ;
15354 char * kwnames[] = {
15355 (char *) "self",(char *) "threshold", NULL
15356 };
15357
15358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15360 if (!SWIG_IsOK(res1)) {
15361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15362 }
15363 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15364 ecode2 = SWIG_AsVal_int(obj1, &val2);
15365 if (!SWIG_IsOK(ecode2)) {
15366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15367 }
15368 arg2 = static_cast< int >(val2);
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 (arg1)->SetMovementThreshold(arg2);
15372 wxPyEndAllowThreads(__tstate);
15373 if (PyErr_Occurred()) SWIG_fail;
15374 }
15375 resultobj = SWIG_Py_Void();
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15383 PyObject *resultobj = 0;
15384 wxJoystick *arg1 = (wxJoystick *) 0 ;
15385 bool result;
15386 void *argp1 = 0 ;
15387 int res1 = 0 ;
15388 PyObject *swig_obj[1] ;
15389
15390 if (!args) SWIG_fail;
15391 swig_obj[0] = args;
15392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15393 if (!SWIG_IsOK(res1)) {
15394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15395 }
15396 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 result = (bool)(arg1)->IsOk();
15400 wxPyEndAllowThreads(__tstate);
15401 if (PyErr_Occurred()) SWIG_fail;
15402 }
15403 {
15404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15405 }
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15413 PyObject *resultobj = 0;
15414 wxJoystick *arg1 = (wxJoystick *) 0 ;
15415 int result;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject *swig_obj[1] ;
15419
15420 if (!args) SWIG_fail;
15421 swig_obj[0] = args;
15422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15423 if (!SWIG_IsOK(res1)) {
15424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15425 }
15426 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (int)(arg1)->GetNumberJoysticks();
15430 wxPyEndAllowThreads(__tstate);
15431 if (PyErr_Occurred()) SWIG_fail;
15432 }
15433 resultobj = SWIG_From_int(static_cast< int >(result));
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15441 PyObject *resultobj = 0;
15442 wxJoystick *arg1 = (wxJoystick *) 0 ;
15443 int result;
15444 void *argp1 = 0 ;
15445 int res1 = 0 ;
15446 PyObject *swig_obj[1] ;
15447
15448 if (!args) SWIG_fail;
15449 swig_obj[0] = args;
15450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15451 if (!SWIG_IsOK(res1)) {
15452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15453 }
15454 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 result = (int)(arg1)->GetManufacturerId();
15458 wxPyEndAllowThreads(__tstate);
15459 if (PyErr_Occurred()) SWIG_fail;
15460 }
15461 resultobj = SWIG_From_int(static_cast< int >(result));
15462 return resultobj;
15463 fail:
15464 return NULL;
15465 }
15466
15467
15468 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15469 PyObject *resultobj = 0;
15470 wxJoystick *arg1 = (wxJoystick *) 0 ;
15471 int result;
15472 void *argp1 = 0 ;
15473 int res1 = 0 ;
15474 PyObject *swig_obj[1] ;
15475
15476 if (!args) SWIG_fail;
15477 swig_obj[0] = args;
15478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15479 if (!SWIG_IsOK(res1)) {
15480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15481 }
15482 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (int)(arg1)->GetProductId();
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 resultobj = SWIG_From_int(static_cast< int >(result));
15490 return resultobj;
15491 fail:
15492 return NULL;
15493 }
15494
15495
15496 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15497 PyObject *resultobj = 0;
15498 wxJoystick *arg1 = (wxJoystick *) 0 ;
15499 wxString result;
15500 void *argp1 = 0 ;
15501 int res1 = 0 ;
15502 PyObject *swig_obj[1] ;
15503
15504 if (!args) SWIG_fail;
15505 swig_obj[0] = args;
15506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15507 if (!SWIG_IsOK(res1)) {
15508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15509 }
15510 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 result = (arg1)->GetProductName();
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 {
15518 #if wxUSE_UNICODE
15519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15520 #else
15521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15522 #endif
15523 }
15524 return resultobj;
15525 fail:
15526 return NULL;
15527 }
15528
15529
15530 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15531 PyObject *resultobj = 0;
15532 wxJoystick *arg1 = (wxJoystick *) 0 ;
15533 int result;
15534 void *argp1 = 0 ;
15535 int res1 = 0 ;
15536 PyObject *swig_obj[1] ;
15537
15538 if (!args) SWIG_fail;
15539 swig_obj[0] = args;
15540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15541 if (!SWIG_IsOK(res1)) {
15542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15543 }
15544 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 result = (int)(arg1)->GetXMin();
15548 wxPyEndAllowThreads(__tstate);
15549 if (PyErr_Occurred()) SWIG_fail;
15550 }
15551 resultobj = SWIG_From_int(static_cast< int >(result));
15552 return resultobj;
15553 fail:
15554 return NULL;
15555 }
15556
15557
15558 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15559 PyObject *resultobj = 0;
15560 wxJoystick *arg1 = (wxJoystick *) 0 ;
15561 int result;
15562 void *argp1 = 0 ;
15563 int res1 = 0 ;
15564 PyObject *swig_obj[1] ;
15565
15566 if (!args) SWIG_fail;
15567 swig_obj[0] = args;
15568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15569 if (!SWIG_IsOK(res1)) {
15570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15571 }
15572 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15573 {
15574 PyThreadState* __tstate = wxPyBeginAllowThreads();
15575 result = (int)(arg1)->GetYMin();
15576 wxPyEndAllowThreads(__tstate);
15577 if (PyErr_Occurred()) SWIG_fail;
15578 }
15579 resultobj = SWIG_From_int(static_cast< int >(result));
15580 return resultobj;
15581 fail:
15582 return NULL;
15583 }
15584
15585
15586 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15587 PyObject *resultobj = 0;
15588 wxJoystick *arg1 = (wxJoystick *) 0 ;
15589 int result;
15590 void *argp1 = 0 ;
15591 int res1 = 0 ;
15592 PyObject *swig_obj[1] ;
15593
15594 if (!args) SWIG_fail;
15595 swig_obj[0] = args;
15596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15597 if (!SWIG_IsOK(res1)) {
15598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15599 }
15600 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15601 {
15602 PyThreadState* __tstate = wxPyBeginAllowThreads();
15603 result = (int)(arg1)->GetZMin();
15604 wxPyEndAllowThreads(__tstate);
15605 if (PyErr_Occurred()) SWIG_fail;
15606 }
15607 resultobj = SWIG_From_int(static_cast< int >(result));
15608 return resultobj;
15609 fail:
15610 return NULL;
15611 }
15612
15613
15614 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15615 PyObject *resultobj = 0;
15616 wxJoystick *arg1 = (wxJoystick *) 0 ;
15617 int result;
15618 void *argp1 = 0 ;
15619 int res1 = 0 ;
15620 PyObject *swig_obj[1] ;
15621
15622 if (!args) SWIG_fail;
15623 swig_obj[0] = args;
15624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15625 if (!SWIG_IsOK(res1)) {
15626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15627 }
15628 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 result = (int)(arg1)->GetXMax();
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 resultobj = SWIG_From_int(static_cast< int >(result));
15636 return resultobj;
15637 fail:
15638 return NULL;
15639 }
15640
15641
15642 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15643 PyObject *resultobj = 0;
15644 wxJoystick *arg1 = (wxJoystick *) 0 ;
15645 int result;
15646 void *argp1 = 0 ;
15647 int res1 = 0 ;
15648 PyObject *swig_obj[1] ;
15649
15650 if (!args) SWIG_fail;
15651 swig_obj[0] = args;
15652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15653 if (!SWIG_IsOK(res1)) {
15654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15655 }
15656 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15657 {
15658 PyThreadState* __tstate = wxPyBeginAllowThreads();
15659 result = (int)(arg1)->GetYMax();
15660 wxPyEndAllowThreads(__tstate);
15661 if (PyErr_Occurred()) SWIG_fail;
15662 }
15663 resultobj = SWIG_From_int(static_cast< int >(result));
15664 return resultobj;
15665 fail:
15666 return NULL;
15667 }
15668
15669
15670 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15671 PyObject *resultobj = 0;
15672 wxJoystick *arg1 = (wxJoystick *) 0 ;
15673 int result;
15674 void *argp1 = 0 ;
15675 int res1 = 0 ;
15676 PyObject *swig_obj[1] ;
15677
15678 if (!args) SWIG_fail;
15679 swig_obj[0] = args;
15680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15681 if (!SWIG_IsOK(res1)) {
15682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15683 }
15684 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = (int)(arg1)->GetZMax();
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 resultobj = SWIG_From_int(static_cast< int >(result));
15692 return resultobj;
15693 fail:
15694 return NULL;
15695 }
15696
15697
15698 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15699 PyObject *resultobj = 0;
15700 wxJoystick *arg1 = (wxJoystick *) 0 ;
15701 int result;
15702 void *argp1 = 0 ;
15703 int res1 = 0 ;
15704 PyObject *swig_obj[1] ;
15705
15706 if (!args) SWIG_fail;
15707 swig_obj[0] = args;
15708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15709 if (!SWIG_IsOK(res1)) {
15710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15711 }
15712 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15713 {
15714 PyThreadState* __tstate = wxPyBeginAllowThreads();
15715 result = (int)(arg1)->GetNumberButtons();
15716 wxPyEndAllowThreads(__tstate);
15717 if (PyErr_Occurred()) SWIG_fail;
15718 }
15719 resultobj = SWIG_From_int(static_cast< int >(result));
15720 return resultobj;
15721 fail:
15722 return NULL;
15723 }
15724
15725
15726 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15727 PyObject *resultobj = 0;
15728 wxJoystick *arg1 = (wxJoystick *) 0 ;
15729 int result;
15730 void *argp1 = 0 ;
15731 int res1 = 0 ;
15732 PyObject *swig_obj[1] ;
15733
15734 if (!args) SWIG_fail;
15735 swig_obj[0] = args;
15736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15737 if (!SWIG_IsOK(res1)) {
15738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15739 }
15740 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15741 {
15742 PyThreadState* __tstate = wxPyBeginAllowThreads();
15743 result = (int)(arg1)->GetNumberAxes();
15744 wxPyEndAllowThreads(__tstate);
15745 if (PyErr_Occurred()) SWIG_fail;
15746 }
15747 resultobj = SWIG_From_int(static_cast< int >(result));
15748 return resultobj;
15749 fail:
15750 return NULL;
15751 }
15752
15753
15754 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15755 PyObject *resultobj = 0;
15756 wxJoystick *arg1 = (wxJoystick *) 0 ;
15757 int result;
15758 void *argp1 = 0 ;
15759 int res1 = 0 ;
15760 PyObject *swig_obj[1] ;
15761
15762 if (!args) SWIG_fail;
15763 swig_obj[0] = args;
15764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15765 if (!SWIG_IsOK(res1)) {
15766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15767 }
15768 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15769 {
15770 PyThreadState* __tstate = wxPyBeginAllowThreads();
15771 result = (int)(arg1)->GetMaxButtons();
15772 wxPyEndAllowThreads(__tstate);
15773 if (PyErr_Occurred()) SWIG_fail;
15774 }
15775 resultobj = SWIG_From_int(static_cast< int >(result));
15776 return resultobj;
15777 fail:
15778 return NULL;
15779 }
15780
15781
15782 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15783 PyObject *resultobj = 0;
15784 wxJoystick *arg1 = (wxJoystick *) 0 ;
15785 int result;
15786 void *argp1 = 0 ;
15787 int res1 = 0 ;
15788 PyObject *swig_obj[1] ;
15789
15790 if (!args) SWIG_fail;
15791 swig_obj[0] = args;
15792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15793 if (!SWIG_IsOK(res1)) {
15794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15795 }
15796 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15797 {
15798 PyThreadState* __tstate = wxPyBeginAllowThreads();
15799 result = (int)(arg1)->GetMaxAxes();
15800 wxPyEndAllowThreads(__tstate);
15801 if (PyErr_Occurred()) SWIG_fail;
15802 }
15803 resultobj = SWIG_From_int(static_cast< int >(result));
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15811 PyObject *resultobj = 0;
15812 wxJoystick *arg1 = (wxJoystick *) 0 ;
15813 int result;
15814 void *argp1 = 0 ;
15815 int res1 = 0 ;
15816 PyObject *swig_obj[1] ;
15817
15818 if (!args) SWIG_fail;
15819 swig_obj[0] = args;
15820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15821 if (!SWIG_IsOK(res1)) {
15822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15823 }
15824 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15825 {
15826 PyThreadState* __tstate = wxPyBeginAllowThreads();
15827 result = (int)(arg1)->GetPollingMin();
15828 wxPyEndAllowThreads(__tstate);
15829 if (PyErr_Occurred()) SWIG_fail;
15830 }
15831 resultobj = SWIG_From_int(static_cast< int >(result));
15832 return resultobj;
15833 fail:
15834 return NULL;
15835 }
15836
15837
15838 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15839 PyObject *resultobj = 0;
15840 wxJoystick *arg1 = (wxJoystick *) 0 ;
15841 int result;
15842 void *argp1 = 0 ;
15843 int res1 = 0 ;
15844 PyObject *swig_obj[1] ;
15845
15846 if (!args) SWIG_fail;
15847 swig_obj[0] = args;
15848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15849 if (!SWIG_IsOK(res1)) {
15850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15851 }
15852 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 result = (int)(arg1)->GetPollingMax();
15856 wxPyEndAllowThreads(__tstate);
15857 if (PyErr_Occurred()) SWIG_fail;
15858 }
15859 resultobj = SWIG_From_int(static_cast< int >(result));
15860 return resultobj;
15861 fail:
15862 return NULL;
15863 }
15864
15865
15866 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15867 PyObject *resultobj = 0;
15868 wxJoystick *arg1 = (wxJoystick *) 0 ;
15869 int result;
15870 void *argp1 = 0 ;
15871 int res1 = 0 ;
15872 PyObject *swig_obj[1] ;
15873
15874 if (!args) SWIG_fail;
15875 swig_obj[0] = args;
15876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15877 if (!SWIG_IsOK(res1)) {
15878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15879 }
15880 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15881 {
15882 PyThreadState* __tstate = wxPyBeginAllowThreads();
15883 result = (int)(arg1)->GetRudderMin();
15884 wxPyEndAllowThreads(__tstate);
15885 if (PyErr_Occurred()) SWIG_fail;
15886 }
15887 resultobj = SWIG_From_int(static_cast< int >(result));
15888 return resultobj;
15889 fail:
15890 return NULL;
15891 }
15892
15893
15894 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15895 PyObject *resultobj = 0;
15896 wxJoystick *arg1 = (wxJoystick *) 0 ;
15897 int result;
15898 void *argp1 = 0 ;
15899 int res1 = 0 ;
15900 PyObject *swig_obj[1] ;
15901
15902 if (!args) SWIG_fail;
15903 swig_obj[0] = args;
15904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15905 if (!SWIG_IsOK(res1)) {
15906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15907 }
15908 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15909 {
15910 PyThreadState* __tstate = wxPyBeginAllowThreads();
15911 result = (int)(arg1)->GetRudderMax();
15912 wxPyEndAllowThreads(__tstate);
15913 if (PyErr_Occurred()) SWIG_fail;
15914 }
15915 resultobj = SWIG_From_int(static_cast< int >(result));
15916 return resultobj;
15917 fail:
15918 return NULL;
15919 }
15920
15921
15922 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15923 PyObject *resultobj = 0;
15924 wxJoystick *arg1 = (wxJoystick *) 0 ;
15925 int result;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 PyObject *swig_obj[1] ;
15929
15930 if (!args) SWIG_fail;
15931 swig_obj[0] = args;
15932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15933 if (!SWIG_IsOK(res1)) {
15934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15935 }
15936 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = (int)(arg1)->GetUMin();
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 resultobj = SWIG_From_int(static_cast< int >(result));
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15951 PyObject *resultobj = 0;
15952 wxJoystick *arg1 = (wxJoystick *) 0 ;
15953 int result;
15954 void *argp1 = 0 ;
15955 int res1 = 0 ;
15956 PyObject *swig_obj[1] ;
15957
15958 if (!args) SWIG_fail;
15959 swig_obj[0] = args;
15960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15961 if (!SWIG_IsOK(res1)) {
15962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15963 }
15964 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15965 {
15966 PyThreadState* __tstate = wxPyBeginAllowThreads();
15967 result = (int)(arg1)->GetUMax();
15968 wxPyEndAllowThreads(__tstate);
15969 if (PyErr_Occurred()) SWIG_fail;
15970 }
15971 resultobj = SWIG_From_int(static_cast< int >(result));
15972 return resultobj;
15973 fail:
15974 return NULL;
15975 }
15976
15977
15978 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15979 PyObject *resultobj = 0;
15980 wxJoystick *arg1 = (wxJoystick *) 0 ;
15981 int result;
15982 void *argp1 = 0 ;
15983 int res1 = 0 ;
15984 PyObject *swig_obj[1] ;
15985
15986 if (!args) SWIG_fail;
15987 swig_obj[0] = args;
15988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15989 if (!SWIG_IsOK(res1)) {
15990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15991 }
15992 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15993 {
15994 PyThreadState* __tstate = wxPyBeginAllowThreads();
15995 result = (int)(arg1)->GetVMin();
15996 wxPyEndAllowThreads(__tstate);
15997 if (PyErr_Occurred()) SWIG_fail;
15998 }
15999 resultobj = SWIG_From_int(static_cast< int >(result));
16000 return resultobj;
16001 fail:
16002 return NULL;
16003 }
16004
16005
16006 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16007 PyObject *resultobj = 0;
16008 wxJoystick *arg1 = (wxJoystick *) 0 ;
16009 int result;
16010 void *argp1 = 0 ;
16011 int res1 = 0 ;
16012 PyObject *swig_obj[1] ;
16013
16014 if (!args) SWIG_fail;
16015 swig_obj[0] = args;
16016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16017 if (!SWIG_IsOK(res1)) {
16018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16019 }
16020 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16021 {
16022 PyThreadState* __tstate = wxPyBeginAllowThreads();
16023 result = (int)(arg1)->GetVMax();
16024 wxPyEndAllowThreads(__tstate);
16025 if (PyErr_Occurred()) SWIG_fail;
16026 }
16027 resultobj = SWIG_From_int(static_cast< int >(result));
16028 return resultobj;
16029 fail:
16030 return NULL;
16031 }
16032
16033
16034 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16035 PyObject *resultobj = 0;
16036 wxJoystick *arg1 = (wxJoystick *) 0 ;
16037 bool result;
16038 void *argp1 = 0 ;
16039 int res1 = 0 ;
16040 PyObject *swig_obj[1] ;
16041
16042 if (!args) SWIG_fail;
16043 swig_obj[0] = args;
16044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16045 if (!SWIG_IsOK(res1)) {
16046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16047 }
16048 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16049 {
16050 PyThreadState* __tstate = wxPyBeginAllowThreads();
16051 result = (bool)(arg1)->HasRudder();
16052 wxPyEndAllowThreads(__tstate);
16053 if (PyErr_Occurred()) SWIG_fail;
16054 }
16055 {
16056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16057 }
16058 return resultobj;
16059 fail:
16060 return NULL;
16061 }
16062
16063
16064 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16065 PyObject *resultobj = 0;
16066 wxJoystick *arg1 = (wxJoystick *) 0 ;
16067 bool result;
16068 void *argp1 = 0 ;
16069 int res1 = 0 ;
16070 PyObject *swig_obj[1] ;
16071
16072 if (!args) SWIG_fail;
16073 swig_obj[0] = args;
16074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16075 if (!SWIG_IsOK(res1)) {
16076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16077 }
16078 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16079 {
16080 PyThreadState* __tstate = wxPyBeginAllowThreads();
16081 result = (bool)(arg1)->HasZ();
16082 wxPyEndAllowThreads(__tstate);
16083 if (PyErr_Occurred()) SWIG_fail;
16084 }
16085 {
16086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16087 }
16088 return resultobj;
16089 fail:
16090 return NULL;
16091 }
16092
16093
16094 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16095 PyObject *resultobj = 0;
16096 wxJoystick *arg1 = (wxJoystick *) 0 ;
16097 bool result;
16098 void *argp1 = 0 ;
16099 int res1 = 0 ;
16100 PyObject *swig_obj[1] ;
16101
16102 if (!args) SWIG_fail;
16103 swig_obj[0] = args;
16104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16105 if (!SWIG_IsOK(res1)) {
16106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16107 }
16108 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 result = (bool)(arg1)->HasU();
16112 wxPyEndAllowThreads(__tstate);
16113 if (PyErr_Occurred()) SWIG_fail;
16114 }
16115 {
16116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16117 }
16118 return resultobj;
16119 fail:
16120 return NULL;
16121 }
16122
16123
16124 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16125 PyObject *resultobj = 0;
16126 wxJoystick *arg1 = (wxJoystick *) 0 ;
16127 bool result;
16128 void *argp1 = 0 ;
16129 int res1 = 0 ;
16130 PyObject *swig_obj[1] ;
16131
16132 if (!args) SWIG_fail;
16133 swig_obj[0] = args;
16134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16135 if (!SWIG_IsOK(res1)) {
16136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16137 }
16138 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16139 {
16140 PyThreadState* __tstate = wxPyBeginAllowThreads();
16141 result = (bool)(arg1)->HasV();
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 {
16146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16147 }
16148 return resultobj;
16149 fail:
16150 return NULL;
16151 }
16152
16153
16154 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16155 PyObject *resultobj = 0;
16156 wxJoystick *arg1 = (wxJoystick *) 0 ;
16157 bool result;
16158 void *argp1 = 0 ;
16159 int res1 = 0 ;
16160 PyObject *swig_obj[1] ;
16161
16162 if (!args) SWIG_fail;
16163 swig_obj[0] = args;
16164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16165 if (!SWIG_IsOK(res1)) {
16166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16167 }
16168 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16169 {
16170 PyThreadState* __tstate = wxPyBeginAllowThreads();
16171 result = (bool)(arg1)->HasPOV();
16172 wxPyEndAllowThreads(__tstate);
16173 if (PyErr_Occurred()) SWIG_fail;
16174 }
16175 {
16176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16177 }
16178 return resultobj;
16179 fail:
16180 return NULL;
16181 }
16182
16183
16184 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16185 PyObject *resultobj = 0;
16186 wxJoystick *arg1 = (wxJoystick *) 0 ;
16187 bool result;
16188 void *argp1 = 0 ;
16189 int res1 = 0 ;
16190 PyObject *swig_obj[1] ;
16191
16192 if (!args) SWIG_fail;
16193 swig_obj[0] = args;
16194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16195 if (!SWIG_IsOK(res1)) {
16196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16197 }
16198 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16199 {
16200 PyThreadState* __tstate = wxPyBeginAllowThreads();
16201 result = (bool)(arg1)->HasPOV4Dir();
16202 wxPyEndAllowThreads(__tstate);
16203 if (PyErr_Occurred()) SWIG_fail;
16204 }
16205 {
16206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16207 }
16208 return resultobj;
16209 fail:
16210 return NULL;
16211 }
16212
16213
16214 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16215 PyObject *resultobj = 0;
16216 wxJoystick *arg1 = (wxJoystick *) 0 ;
16217 bool result;
16218 void *argp1 = 0 ;
16219 int res1 = 0 ;
16220 PyObject *swig_obj[1] ;
16221
16222 if (!args) SWIG_fail;
16223 swig_obj[0] = args;
16224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16227 }
16228 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16229 {
16230 PyThreadState* __tstate = wxPyBeginAllowThreads();
16231 result = (bool)(arg1)->HasPOVCTS();
16232 wxPyEndAllowThreads(__tstate);
16233 if (PyErr_Occurred()) SWIG_fail;
16234 }
16235 {
16236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16237 }
16238 return resultobj;
16239 fail:
16240 return NULL;
16241 }
16242
16243
16244 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16245 PyObject *resultobj = 0;
16246 wxJoystick *arg1 = (wxJoystick *) 0 ;
16247 wxWindow *arg2 = (wxWindow *) 0 ;
16248 int arg3 = (int) 0 ;
16249 bool result;
16250 void *argp1 = 0 ;
16251 int res1 = 0 ;
16252 void *argp2 = 0 ;
16253 int res2 = 0 ;
16254 int val3 ;
16255 int ecode3 = 0 ;
16256 PyObject * obj0 = 0 ;
16257 PyObject * obj1 = 0 ;
16258 PyObject * obj2 = 0 ;
16259 char * kwnames[] = {
16260 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16261 };
16262
16263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16265 if (!SWIG_IsOK(res1)) {
16266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16267 }
16268 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16270 if (!SWIG_IsOK(res2)) {
16271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16272 }
16273 arg2 = reinterpret_cast< wxWindow * >(argp2);
16274 if (obj2) {
16275 ecode3 = SWIG_AsVal_int(obj2, &val3);
16276 if (!SWIG_IsOK(ecode3)) {
16277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16278 }
16279 arg3 = static_cast< int >(val3);
16280 }
16281 {
16282 PyThreadState* __tstate = wxPyBeginAllowThreads();
16283 result = (bool)(arg1)->SetCapture(arg2,arg3);
16284 wxPyEndAllowThreads(__tstate);
16285 if (PyErr_Occurred()) SWIG_fail;
16286 }
16287 {
16288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16289 }
16290 return resultobj;
16291 fail:
16292 return NULL;
16293 }
16294
16295
16296 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16297 PyObject *resultobj = 0;
16298 wxJoystick *arg1 = (wxJoystick *) 0 ;
16299 bool result;
16300 void *argp1 = 0 ;
16301 int res1 = 0 ;
16302 PyObject *swig_obj[1] ;
16303
16304 if (!args) SWIG_fail;
16305 swig_obj[0] = args;
16306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16307 if (!SWIG_IsOK(res1)) {
16308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16309 }
16310 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16311 {
16312 PyThreadState* __tstate = wxPyBeginAllowThreads();
16313 result = (bool)(arg1)->ReleaseCapture();
16314 wxPyEndAllowThreads(__tstate);
16315 if (PyErr_Occurred()) SWIG_fail;
16316 }
16317 {
16318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16319 }
16320 return resultobj;
16321 fail:
16322 return NULL;
16323 }
16324
16325
16326 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16327 PyObject *obj;
16328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16329 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16330 return SWIG_Py_Void();
16331 }
16332
16333 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16334 return SWIG_Python_InitShadowInstance(args);
16335 }
16336
16337 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16338 PyObject *resultobj = 0;
16339 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16340 int arg2 = (int) 0 ;
16341 int arg3 = (int) wxJOYSTICK1 ;
16342 int arg4 = (int) 0 ;
16343 wxJoystickEvent *result = 0 ;
16344 int val1 ;
16345 int ecode1 = 0 ;
16346 int val2 ;
16347 int ecode2 = 0 ;
16348 int val3 ;
16349 int ecode3 = 0 ;
16350 int val4 ;
16351 int ecode4 = 0 ;
16352 PyObject * obj0 = 0 ;
16353 PyObject * obj1 = 0 ;
16354 PyObject * obj2 = 0 ;
16355 PyObject * obj3 = 0 ;
16356 char * kwnames[] = {
16357 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16358 };
16359
16360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16361 if (obj0) {
16362 ecode1 = SWIG_AsVal_int(obj0, &val1);
16363 if (!SWIG_IsOK(ecode1)) {
16364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16365 }
16366 arg1 = static_cast< wxEventType >(val1);
16367 }
16368 if (obj1) {
16369 ecode2 = SWIG_AsVal_int(obj1, &val2);
16370 if (!SWIG_IsOK(ecode2)) {
16371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16372 }
16373 arg2 = static_cast< int >(val2);
16374 }
16375 if (obj2) {
16376 ecode3 = SWIG_AsVal_int(obj2, &val3);
16377 if (!SWIG_IsOK(ecode3)) {
16378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16379 }
16380 arg3 = static_cast< int >(val3);
16381 }
16382 if (obj3) {
16383 ecode4 = SWIG_AsVal_int(obj3, &val4);
16384 if (!SWIG_IsOK(ecode4)) {
16385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16386 }
16387 arg4 = static_cast< int >(val4);
16388 }
16389 {
16390 PyThreadState* __tstate = wxPyBeginAllowThreads();
16391 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16392 wxPyEndAllowThreads(__tstate);
16393 if (PyErr_Occurred()) SWIG_fail;
16394 }
16395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16396 return resultobj;
16397 fail:
16398 return NULL;
16399 }
16400
16401
16402 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16403 PyObject *resultobj = 0;
16404 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16405 wxPoint result;
16406 void *argp1 = 0 ;
16407 int res1 = 0 ;
16408 PyObject *swig_obj[1] ;
16409
16410 if (!args) SWIG_fail;
16411 swig_obj[0] = args;
16412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16413 if (!SWIG_IsOK(res1)) {
16414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16415 }
16416 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16424 return resultobj;
16425 fail:
16426 return NULL;
16427 }
16428
16429
16430 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16431 PyObject *resultobj = 0;
16432 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16433 int result;
16434 void *argp1 = 0 ;
16435 int res1 = 0 ;
16436 PyObject *swig_obj[1] ;
16437
16438 if (!args) SWIG_fail;
16439 swig_obj[0] = args;
16440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16441 if (!SWIG_IsOK(res1)) {
16442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16443 }
16444 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16445 {
16446 PyThreadState* __tstate = wxPyBeginAllowThreads();
16447 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 resultobj = SWIG_From_int(static_cast< int >(result));
16452 return resultobj;
16453 fail:
16454 return NULL;
16455 }
16456
16457
16458 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16459 PyObject *resultobj = 0;
16460 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16461 int result;
16462 void *argp1 = 0 ;
16463 int res1 = 0 ;
16464 PyObject *swig_obj[1] ;
16465
16466 if (!args) SWIG_fail;
16467 swig_obj[0] = args;
16468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16469 if (!SWIG_IsOK(res1)) {
16470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16471 }
16472 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16473 {
16474 PyThreadState* __tstate = wxPyBeginAllowThreads();
16475 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16476 wxPyEndAllowThreads(__tstate);
16477 if (PyErr_Occurred()) SWIG_fail;
16478 }
16479 resultobj = SWIG_From_int(static_cast< int >(result));
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16487 PyObject *resultobj = 0;
16488 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16489 int result;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 PyObject *swig_obj[1] ;
16493
16494 if (!args) SWIG_fail;
16495 swig_obj[0] = args;
16496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16497 if (!SWIG_IsOK(res1)) {
16498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16499 }
16500 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_From_int(static_cast< int >(result));
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16515 PyObject *resultobj = 0;
16516 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16517 int result;
16518 void *argp1 = 0 ;
16519 int res1 = 0 ;
16520 PyObject *swig_obj[1] ;
16521
16522 if (!args) SWIG_fail;
16523 swig_obj[0] = args;
16524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16525 if (!SWIG_IsOK(res1)) {
16526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16527 }
16528 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16529 {
16530 PyThreadState* __tstate = wxPyBeginAllowThreads();
16531 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16532 wxPyEndAllowThreads(__tstate);
16533 if (PyErr_Occurred()) SWIG_fail;
16534 }
16535 resultobj = SWIG_From_int(static_cast< int >(result));
16536 return resultobj;
16537 fail:
16538 return NULL;
16539 }
16540
16541
16542 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16543 PyObject *resultobj = 0;
16544 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16545 int arg2 ;
16546 void *argp1 = 0 ;
16547 int res1 = 0 ;
16548 int val2 ;
16549 int ecode2 = 0 ;
16550 PyObject * obj0 = 0 ;
16551 PyObject * obj1 = 0 ;
16552 char * kwnames[] = {
16553 (char *) "self",(char *) "stick", NULL
16554 };
16555
16556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16558 if (!SWIG_IsOK(res1)) {
16559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16560 }
16561 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16562 ecode2 = SWIG_AsVal_int(obj1, &val2);
16563 if (!SWIG_IsOK(ecode2)) {
16564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16565 }
16566 arg2 = static_cast< int >(val2);
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 (arg1)->SetJoystick(arg2);
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 resultobj = SWIG_Py_Void();
16574 return resultobj;
16575 fail:
16576 return NULL;
16577 }
16578
16579
16580 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16581 PyObject *resultobj = 0;
16582 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16583 int arg2 ;
16584 void *argp1 = 0 ;
16585 int res1 = 0 ;
16586 int val2 ;
16587 int ecode2 = 0 ;
16588 PyObject * obj0 = 0 ;
16589 PyObject * obj1 = 0 ;
16590 char * kwnames[] = {
16591 (char *) "self",(char *) "state", NULL
16592 };
16593
16594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16596 if (!SWIG_IsOK(res1)) {
16597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16598 }
16599 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16600 ecode2 = SWIG_AsVal_int(obj1, &val2);
16601 if (!SWIG_IsOK(ecode2)) {
16602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16603 }
16604 arg2 = static_cast< int >(val2);
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 (arg1)->SetButtonState(arg2);
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 resultobj = SWIG_Py_Void();
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16619 PyObject *resultobj = 0;
16620 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16621 int arg2 ;
16622 void *argp1 = 0 ;
16623 int res1 = 0 ;
16624 int val2 ;
16625 int ecode2 = 0 ;
16626 PyObject * obj0 = 0 ;
16627 PyObject * obj1 = 0 ;
16628 char * kwnames[] = {
16629 (char *) "self",(char *) "change", NULL
16630 };
16631
16632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16634 if (!SWIG_IsOK(res1)) {
16635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16636 }
16637 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16638 ecode2 = SWIG_AsVal_int(obj1, &val2);
16639 if (!SWIG_IsOK(ecode2)) {
16640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16641 }
16642 arg2 = static_cast< int >(val2);
16643 {
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 (arg1)->SetButtonChange(arg2);
16646 wxPyEndAllowThreads(__tstate);
16647 if (PyErr_Occurred()) SWIG_fail;
16648 }
16649 resultobj = SWIG_Py_Void();
16650 return resultobj;
16651 fail:
16652 return NULL;
16653 }
16654
16655
16656 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16657 PyObject *resultobj = 0;
16658 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16659 wxPoint *arg2 = 0 ;
16660 void *argp1 = 0 ;
16661 int res1 = 0 ;
16662 wxPoint temp2 ;
16663 PyObject * obj0 = 0 ;
16664 PyObject * obj1 = 0 ;
16665 char * kwnames[] = {
16666 (char *) "self",(char *) "pos", NULL
16667 };
16668
16669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16671 if (!SWIG_IsOK(res1)) {
16672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16673 }
16674 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16675 {
16676 arg2 = &temp2;
16677 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16678 }
16679 {
16680 PyThreadState* __tstate = wxPyBeginAllowThreads();
16681 (arg1)->SetPosition((wxPoint const &)*arg2);
16682 wxPyEndAllowThreads(__tstate);
16683 if (PyErr_Occurred()) SWIG_fail;
16684 }
16685 resultobj = SWIG_Py_Void();
16686 return resultobj;
16687 fail:
16688 return NULL;
16689 }
16690
16691
16692 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16693 PyObject *resultobj = 0;
16694 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16695 int arg2 ;
16696 void *argp1 = 0 ;
16697 int res1 = 0 ;
16698 int val2 ;
16699 int ecode2 = 0 ;
16700 PyObject * obj0 = 0 ;
16701 PyObject * obj1 = 0 ;
16702 char * kwnames[] = {
16703 (char *) "self",(char *) "zPos", NULL
16704 };
16705
16706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16708 if (!SWIG_IsOK(res1)) {
16709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16710 }
16711 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16712 ecode2 = SWIG_AsVal_int(obj1, &val2);
16713 if (!SWIG_IsOK(ecode2)) {
16714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16715 }
16716 arg2 = static_cast< int >(val2);
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 (arg1)->SetZPosition(arg2);
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = SWIG_Py_Void();
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16731 PyObject *resultobj = 0;
16732 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16733 bool result;
16734 void *argp1 = 0 ;
16735 int res1 = 0 ;
16736 PyObject *swig_obj[1] ;
16737
16738 if (!args) SWIG_fail;
16739 swig_obj[0] = args;
16740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16741 if (!SWIG_IsOK(res1)) {
16742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16743 }
16744 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16745 {
16746 PyThreadState* __tstate = wxPyBeginAllowThreads();
16747 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16748 wxPyEndAllowThreads(__tstate);
16749 if (PyErr_Occurred()) SWIG_fail;
16750 }
16751 {
16752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16753 }
16754 return resultobj;
16755 fail:
16756 return NULL;
16757 }
16758
16759
16760 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16761 PyObject *resultobj = 0;
16762 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16763 bool result;
16764 void *argp1 = 0 ;
16765 int res1 = 0 ;
16766 PyObject *swig_obj[1] ;
16767
16768 if (!args) SWIG_fail;
16769 swig_obj[0] = args;
16770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16771 if (!SWIG_IsOK(res1)) {
16772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16773 }
16774 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16775 {
16776 PyThreadState* __tstate = wxPyBeginAllowThreads();
16777 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 {
16782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16783 }
16784 return resultobj;
16785 fail:
16786 return NULL;
16787 }
16788
16789
16790 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16791 PyObject *resultobj = 0;
16792 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16793 bool result;
16794 void *argp1 = 0 ;
16795 int res1 = 0 ;
16796 PyObject *swig_obj[1] ;
16797
16798 if (!args) SWIG_fail;
16799 swig_obj[0] = args;
16800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16801 if (!SWIG_IsOK(res1)) {
16802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16803 }
16804 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 {
16812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16813 }
16814 return resultobj;
16815 fail:
16816 return NULL;
16817 }
16818
16819
16820 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16821 PyObject *resultobj = 0;
16822 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16823 int arg2 = (int) wxJOY_BUTTON_ANY ;
16824 bool result;
16825 void *argp1 = 0 ;
16826 int res1 = 0 ;
16827 int val2 ;
16828 int ecode2 = 0 ;
16829 PyObject * obj0 = 0 ;
16830 PyObject * obj1 = 0 ;
16831 char * kwnames[] = {
16832 (char *) "self",(char *) "but", NULL
16833 };
16834
16835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16837 if (!SWIG_IsOK(res1)) {
16838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16839 }
16840 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16841 if (obj1) {
16842 ecode2 = SWIG_AsVal_int(obj1, &val2);
16843 if (!SWIG_IsOK(ecode2)) {
16844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16845 }
16846 arg2 = static_cast< int >(val2);
16847 }
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16851 wxPyEndAllowThreads(__tstate);
16852 if (PyErr_Occurred()) SWIG_fail;
16853 }
16854 {
16855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16856 }
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16864 PyObject *resultobj = 0;
16865 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16866 int arg2 = (int) wxJOY_BUTTON_ANY ;
16867 bool result;
16868 void *argp1 = 0 ;
16869 int res1 = 0 ;
16870 int val2 ;
16871 int ecode2 = 0 ;
16872 PyObject * obj0 = 0 ;
16873 PyObject * obj1 = 0 ;
16874 char * kwnames[] = {
16875 (char *) "self",(char *) "but", NULL
16876 };
16877
16878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16880 if (!SWIG_IsOK(res1)) {
16881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16882 }
16883 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16884 if (obj1) {
16885 ecode2 = SWIG_AsVal_int(obj1, &val2);
16886 if (!SWIG_IsOK(ecode2)) {
16887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16888 }
16889 arg2 = static_cast< int >(val2);
16890 }
16891 {
16892 PyThreadState* __tstate = wxPyBeginAllowThreads();
16893 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16894 wxPyEndAllowThreads(__tstate);
16895 if (PyErr_Occurred()) SWIG_fail;
16896 }
16897 {
16898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16899 }
16900 return resultobj;
16901 fail:
16902 return NULL;
16903 }
16904
16905
16906 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16907 PyObject *resultobj = 0;
16908 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16909 int arg2 = (int) wxJOY_BUTTON_ANY ;
16910 bool result;
16911 void *argp1 = 0 ;
16912 int res1 = 0 ;
16913 int val2 ;
16914 int ecode2 = 0 ;
16915 PyObject * obj0 = 0 ;
16916 PyObject * obj1 = 0 ;
16917 char * kwnames[] = {
16918 (char *) "self",(char *) "but", NULL
16919 };
16920
16921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
16922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16923 if (!SWIG_IsOK(res1)) {
16924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16925 }
16926 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16927 if (obj1) {
16928 ecode2 = SWIG_AsVal_int(obj1, &val2);
16929 if (!SWIG_IsOK(ecode2)) {
16930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
16931 }
16932 arg2 = static_cast< int >(val2);
16933 }
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
16937 wxPyEndAllowThreads(__tstate);
16938 if (PyErr_Occurred()) SWIG_fail;
16939 }
16940 {
16941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16942 }
16943 return resultobj;
16944 fail:
16945 return NULL;
16946 }
16947
16948
16949 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16950 PyObject *obj;
16951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16952 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16953 return SWIG_Py_Void();
16954 }
16955
16956 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16957 return SWIG_Python_InitShadowInstance(args);
16958 }
16959
16960 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16961 PyObject *resultobj = 0;
16962 wxString const &arg1_defvalue = wxPyEmptyString ;
16963 wxString *arg1 = (wxString *) &arg1_defvalue ;
16964 wxSound *result = 0 ;
16965 bool temp1 = false ;
16966 PyObject * obj0 = 0 ;
16967 char * kwnames[] = {
16968 (char *) "fileName", NULL
16969 };
16970
16971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16972 if (obj0) {
16973 {
16974 arg1 = wxString_in_helper(obj0);
16975 if (arg1 == NULL) SWIG_fail;
16976 temp1 = true;
16977 }
16978 }
16979 {
16980 if (!wxPyCheckForApp()) SWIG_fail;
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16983 wxPyEndAllowThreads(__tstate);
16984 if (PyErr_Occurred()) SWIG_fail;
16985 }
16986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16987 {
16988 if (temp1)
16989 delete arg1;
16990 }
16991 return resultobj;
16992 fail:
16993 {
16994 if (temp1)
16995 delete arg1;
16996 }
16997 return NULL;
16998 }
16999
17000
17001 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17002 PyObject *resultobj = 0;
17003 PyObject *arg1 = (PyObject *) 0 ;
17004 wxSound *result = 0 ;
17005 PyObject * obj0 = 0 ;
17006 char * kwnames[] = {
17007 (char *) "data", NULL
17008 };
17009
17010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17011 arg1 = obj0;
17012 {
17013 if (!wxPyCheckForApp()) SWIG_fail;
17014 PyThreadState* __tstate = wxPyBeginAllowThreads();
17015 result = (wxSound *)new_wxSound(arg1);
17016 wxPyEndAllowThreads(__tstate);
17017 if (PyErr_Occurred()) SWIG_fail;
17018 }
17019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17020 return resultobj;
17021 fail:
17022 return NULL;
17023 }
17024
17025
17026 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17027 PyObject *resultobj = 0;
17028 wxSound *arg1 = (wxSound *) 0 ;
17029 void *argp1 = 0 ;
17030 int res1 = 0 ;
17031 PyObject *swig_obj[1] ;
17032
17033 if (!args) SWIG_fail;
17034 swig_obj[0] = args;
17035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17036 if (!SWIG_IsOK(res1)) {
17037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17038 }
17039 arg1 = reinterpret_cast< wxSound * >(argp1);
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 delete arg1;
17043
17044 wxPyEndAllowThreads(__tstate);
17045 if (PyErr_Occurred()) SWIG_fail;
17046 }
17047 resultobj = SWIG_Py_Void();
17048 return resultobj;
17049 fail:
17050 return NULL;
17051 }
17052
17053
17054 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17055 PyObject *resultobj = 0;
17056 wxSound *arg1 = (wxSound *) 0 ;
17057 wxString *arg2 = 0 ;
17058 bool result;
17059 void *argp1 = 0 ;
17060 int res1 = 0 ;
17061 bool temp2 = false ;
17062 PyObject * obj0 = 0 ;
17063 PyObject * obj1 = 0 ;
17064 char * kwnames[] = {
17065 (char *) "self",(char *) "fileName", NULL
17066 };
17067
17068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17070 if (!SWIG_IsOK(res1)) {
17071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17072 }
17073 arg1 = reinterpret_cast< wxSound * >(argp1);
17074 {
17075 arg2 = wxString_in_helper(obj1);
17076 if (arg2 == NULL) SWIG_fail;
17077 temp2 = true;
17078 }
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 result = (bool)(arg1)->Create((wxString const &)*arg2);
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 {
17086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17087 }
17088 {
17089 if (temp2)
17090 delete arg2;
17091 }
17092 return resultobj;
17093 fail:
17094 {
17095 if (temp2)
17096 delete arg2;
17097 }
17098 return NULL;
17099 }
17100
17101
17102 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj = 0;
17104 wxSound *arg1 = (wxSound *) 0 ;
17105 PyObject *arg2 = (PyObject *) 0 ;
17106 bool result;
17107 void *argp1 = 0 ;
17108 int res1 = 0 ;
17109 PyObject * obj0 = 0 ;
17110 PyObject * obj1 = 0 ;
17111 char * kwnames[] = {
17112 (char *) "self",(char *) "data", NULL
17113 };
17114
17115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17117 if (!SWIG_IsOK(res1)) {
17118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17119 }
17120 arg1 = reinterpret_cast< wxSound * >(argp1);
17121 arg2 = obj1;
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (bool)wxSound_CreateFromData(arg1,arg2);
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 {
17129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17130 }
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17138 PyObject *resultobj = 0;
17139 wxSound *arg1 = (wxSound *) 0 ;
17140 bool result;
17141 void *argp1 = 0 ;
17142 int res1 = 0 ;
17143 PyObject *swig_obj[1] ;
17144
17145 if (!args) SWIG_fail;
17146 swig_obj[0] = args;
17147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17148 if (!SWIG_IsOK(res1)) {
17149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17150 }
17151 arg1 = reinterpret_cast< wxSound * >(argp1);
17152 {
17153 PyThreadState* __tstate = wxPyBeginAllowThreads();
17154 result = (bool)(arg1)->IsOk();
17155 wxPyEndAllowThreads(__tstate);
17156 if (PyErr_Occurred()) SWIG_fail;
17157 }
17158 {
17159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17160 }
17161 return resultobj;
17162 fail:
17163 return NULL;
17164 }
17165
17166
17167 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17168 PyObject *resultobj = 0;
17169 wxSound *arg1 = (wxSound *) 0 ;
17170 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17171 bool result;
17172 void *argp1 = 0 ;
17173 int res1 = 0 ;
17174 unsigned int val2 ;
17175 int ecode2 = 0 ;
17176 PyObject * obj0 = 0 ;
17177 PyObject * obj1 = 0 ;
17178 char * kwnames[] = {
17179 (char *) "self",(char *) "flags", NULL
17180 };
17181
17182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17184 if (!SWIG_IsOK(res1)) {
17185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17186 }
17187 arg1 = reinterpret_cast< wxSound * >(argp1);
17188 if (obj1) {
17189 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17190 if (!SWIG_IsOK(ecode2)) {
17191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17192 }
17193 arg2 = static_cast< unsigned int >(val2);
17194 }
17195 {
17196 if (!wxPyCheckForApp()) SWIG_fail;
17197 PyThreadState* __tstate = wxPyBeginAllowThreads();
17198 result = (bool)((wxSound const *)arg1)->Play(arg2);
17199 wxPyEndAllowThreads(__tstate);
17200 if (PyErr_Occurred()) SWIG_fail;
17201 }
17202 {
17203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17204 }
17205 return resultobj;
17206 fail:
17207 return NULL;
17208 }
17209
17210
17211 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17212 PyObject *resultobj = 0;
17213 wxString *arg1 = 0 ;
17214 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17215 bool result;
17216 bool temp1 = false ;
17217 unsigned int val2 ;
17218 int ecode2 = 0 ;
17219 PyObject * obj0 = 0 ;
17220 PyObject * obj1 = 0 ;
17221 char * kwnames[] = {
17222 (char *) "filename",(char *) "flags", NULL
17223 };
17224
17225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17226 {
17227 arg1 = wxString_in_helper(obj0);
17228 if (arg1 == NULL) SWIG_fail;
17229 temp1 = true;
17230 }
17231 if (obj1) {
17232 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17233 if (!SWIG_IsOK(ecode2)) {
17234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17235 }
17236 arg2 = static_cast< unsigned int >(val2);
17237 }
17238 {
17239 if (!wxPyCheckForApp()) SWIG_fail;
17240 PyThreadState* __tstate = wxPyBeginAllowThreads();
17241 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17242 wxPyEndAllowThreads(__tstate);
17243 if (PyErr_Occurred()) SWIG_fail;
17244 }
17245 {
17246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17247 }
17248 {
17249 if (temp1)
17250 delete arg1;
17251 }
17252 return resultobj;
17253 fail:
17254 {
17255 if (temp1)
17256 delete arg1;
17257 }
17258 return NULL;
17259 }
17260
17261
17262 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17263 PyObject *resultobj = 0;
17264
17265 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17266 {
17267 if (!wxPyCheckForApp()) SWIG_fail;
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 wxSound::Stop();
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 resultobj = SWIG_Py_Void();
17274 return resultobj;
17275 fail:
17276 return NULL;
17277 }
17278
17279
17280 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17281 PyObject *obj;
17282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17283 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17284 return SWIG_Py_Void();
17285 }
17286
17287 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17288 return SWIG_Python_InitShadowInstance(args);
17289 }
17290
17291 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17292 PyObject *resultobj = 0;
17293 wxString *arg1 = 0 ;
17294 wxString *arg2 = 0 ;
17295 wxString *arg3 = 0 ;
17296 wxString *arg4 = 0 ;
17297 wxFileTypeInfo *result = 0 ;
17298 bool temp1 = false ;
17299 bool temp2 = false ;
17300 bool temp3 = false ;
17301 bool temp4 = false ;
17302 PyObject * obj0 = 0 ;
17303 PyObject * obj1 = 0 ;
17304 PyObject * obj2 = 0 ;
17305 PyObject * obj3 = 0 ;
17306 char * kwnames[] = {
17307 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17308 };
17309
17310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17311 {
17312 arg1 = wxString_in_helper(obj0);
17313 if (arg1 == NULL) SWIG_fail;
17314 temp1 = true;
17315 }
17316 {
17317 arg2 = wxString_in_helper(obj1);
17318 if (arg2 == NULL) SWIG_fail;
17319 temp2 = true;
17320 }
17321 {
17322 arg3 = wxString_in_helper(obj2);
17323 if (arg3 == NULL) SWIG_fail;
17324 temp3 = true;
17325 }
17326 {
17327 arg4 = wxString_in_helper(obj3);
17328 if (arg4 == NULL) SWIG_fail;
17329 temp4 = true;
17330 }
17331 {
17332 PyThreadState* __tstate = wxPyBeginAllowThreads();
17333 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17338 {
17339 if (temp1)
17340 delete arg1;
17341 }
17342 {
17343 if (temp2)
17344 delete arg2;
17345 }
17346 {
17347 if (temp3)
17348 delete arg3;
17349 }
17350 {
17351 if (temp4)
17352 delete arg4;
17353 }
17354 return resultobj;
17355 fail:
17356 {
17357 if (temp1)
17358 delete arg1;
17359 }
17360 {
17361 if (temp2)
17362 delete arg2;
17363 }
17364 {
17365 if (temp3)
17366 delete arg3;
17367 }
17368 {
17369 if (temp4)
17370 delete arg4;
17371 }
17372 return NULL;
17373 }
17374
17375
17376 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17377 PyObject *resultobj = 0;
17378 wxArrayString *arg1 = 0 ;
17379 wxFileTypeInfo *result = 0 ;
17380 bool temp1 = false ;
17381 PyObject * obj0 = 0 ;
17382 char * kwnames[] = {
17383 (char *) "sArray", NULL
17384 };
17385
17386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17387 {
17388 if (! PySequence_Check(obj0)) {
17389 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17390 SWIG_fail;
17391 }
17392 arg1 = new wxArrayString;
17393 temp1 = true;
17394 int i, len=PySequence_Length(obj0);
17395 for (i=0; i<len; i++) {
17396 PyObject* item = PySequence_GetItem(obj0, i);
17397 wxString* s = wxString_in_helper(item);
17398 if (PyErr_Occurred()) SWIG_fail;
17399 arg1->Add(*s);
17400 delete s;
17401 Py_DECREF(item);
17402 }
17403 }
17404 {
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17411 {
17412 if (temp1) delete arg1;
17413 }
17414 return resultobj;
17415 fail:
17416 {
17417 if (temp1) delete arg1;
17418 }
17419 return NULL;
17420 }
17421
17422
17423 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17424 PyObject *resultobj = 0;
17425 wxFileTypeInfo *result = 0 ;
17426
17427 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17428 {
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17431 wxPyEndAllowThreads(__tstate);
17432 if (PyErr_Occurred()) SWIG_fail;
17433 }
17434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17435 return resultobj;
17436 fail:
17437 return NULL;
17438 }
17439
17440
17441 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17442 PyObject *resultobj = 0;
17443 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17444 bool result;
17445 void *argp1 = 0 ;
17446 int res1 = 0 ;
17447 PyObject *swig_obj[1] ;
17448
17449 if (!args) SWIG_fail;
17450 swig_obj[0] = args;
17451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17452 if (!SWIG_IsOK(res1)) {
17453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17454 }
17455 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 {
17463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17464 }
17465 return resultobj;
17466 fail:
17467 return NULL;
17468 }
17469
17470
17471 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17472 PyObject *resultobj = 0;
17473 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17474 wxString *arg2 = 0 ;
17475 int arg3 = (int) 0 ;
17476 void *argp1 = 0 ;
17477 int res1 = 0 ;
17478 bool temp2 = false ;
17479 int val3 ;
17480 int ecode3 = 0 ;
17481 PyObject * obj0 = 0 ;
17482 PyObject * obj1 = 0 ;
17483 PyObject * obj2 = 0 ;
17484 char * kwnames[] = {
17485 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17486 };
17487
17488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17490 if (!SWIG_IsOK(res1)) {
17491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17492 }
17493 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17494 {
17495 arg2 = wxString_in_helper(obj1);
17496 if (arg2 == NULL) SWIG_fail;
17497 temp2 = true;
17498 }
17499 if (obj2) {
17500 ecode3 = SWIG_AsVal_int(obj2, &val3);
17501 if (!SWIG_IsOK(ecode3)) {
17502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17503 }
17504 arg3 = static_cast< int >(val3);
17505 }
17506 {
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17509 wxPyEndAllowThreads(__tstate);
17510 if (PyErr_Occurred()) SWIG_fail;
17511 }
17512 resultobj = SWIG_Py_Void();
17513 {
17514 if (temp2)
17515 delete arg2;
17516 }
17517 return resultobj;
17518 fail:
17519 {
17520 if (temp2)
17521 delete arg2;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj = 0;
17529 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17530 wxString *arg2 = 0 ;
17531 void *argp1 = 0 ;
17532 int res1 = 0 ;
17533 bool temp2 = false ;
17534 PyObject * obj0 = 0 ;
17535 PyObject * obj1 = 0 ;
17536 char * kwnames[] = {
17537 (char *) "self",(char *) "shortDesc", NULL
17538 };
17539
17540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17542 if (!SWIG_IsOK(res1)) {
17543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17544 }
17545 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17546 {
17547 arg2 = wxString_in_helper(obj1);
17548 if (arg2 == NULL) SWIG_fail;
17549 temp2 = true;
17550 }
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 (arg1)->SetShortDesc((wxString const &)*arg2);
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 resultobj = SWIG_Py_Void();
17558 {
17559 if (temp2)
17560 delete arg2;
17561 }
17562 return resultobj;
17563 fail:
17564 {
17565 if (temp2)
17566 delete arg2;
17567 }
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17573 PyObject *resultobj = 0;
17574 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17575 wxString *result = 0 ;
17576 void *argp1 = 0 ;
17577 int res1 = 0 ;
17578 PyObject *swig_obj[1] ;
17579
17580 if (!args) SWIG_fail;
17581 swig_obj[0] = args;
17582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17583 if (!SWIG_IsOK(res1)) {
17584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17585 }
17586 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17587 {
17588 PyThreadState* __tstate = wxPyBeginAllowThreads();
17589 {
17590 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17591 result = (wxString *) &_result_ref;
17592 }
17593 wxPyEndAllowThreads(__tstate);
17594 if (PyErr_Occurred()) SWIG_fail;
17595 }
17596 {
17597 #if wxUSE_UNICODE
17598 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17599 #else
17600 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17601 #endif
17602 }
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17610 PyObject *resultobj = 0;
17611 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17612 wxString *result = 0 ;
17613 void *argp1 = 0 ;
17614 int res1 = 0 ;
17615 PyObject *swig_obj[1] ;
17616
17617 if (!args) SWIG_fail;
17618 swig_obj[0] = args;
17619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17620 if (!SWIG_IsOK(res1)) {
17621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17622 }
17623 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17624 {
17625 PyThreadState* __tstate = wxPyBeginAllowThreads();
17626 {
17627 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17628 result = (wxString *) &_result_ref;
17629 }
17630 wxPyEndAllowThreads(__tstate);
17631 if (PyErr_Occurred()) SWIG_fail;
17632 }
17633 {
17634 #if wxUSE_UNICODE
17635 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17636 #else
17637 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17638 #endif
17639 }
17640 return resultobj;
17641 fail:
17642 return NULL;
17643 }
17644
17645
17646 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17647 PyObject *resultobj = 0;
17648 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17649 wxString *result = 0 ;
17650 void *argp1 = 0 ;
17651 int res1 = 0 ;
17652 PyObject *swig_obj[1] ;
17653
17654 if (!args) SWIG_fail;
17655 swig_obj[0] = args;
17656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17657 if (!SWIG_IsOK(res1)) {
17658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17659 }
17660 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 {
17664 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17665 result = (wxString *) &_result_ref;
17666 }
17667 wxPyEndAllowThreads(__tstate);
17668 if (PyErr_Occurred()) SWIG_fail;
17669 }
17670 {
17671 #if wxUSE_UNICODE
17672 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17673 #else
17674 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17675 #endif
17676 }
17677 return resultobj;
17678 fail:
17679 return NULL;
17680 }
17681
17682
17683 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17684 PyObject *resultobj = 0;
17685 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17686 wxString *result = 0 ;
17687 void *argp1 = 0 ;
17688 int res1 = 0 ;
17689 PyObject *swig_obj[1] ;
17690
17691 if (!args) SWIG_fail;
17692 swig_obj[0] = args;
17693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17694 if (!SWIG_IsOK(res1)) {
17695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17696 }
17697 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 {
17701 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17702 result = (wxString *) &_result_ref;
17703 }
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 {
17708 #if wxUSE_UNICODE
17709 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17710 #else
17711 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17712 #endif
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17721 PyObject *resultobj = 0;
17722 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17723 wxString *result = 0 ;
17724 void *argp1 = 0 ;
17725 int res1 = 0 ;
17726 PyObject *swig_obj[1] ;
17727
17728 if (!args) SWIG_fail;
17729 swig_obj[0] = args;
17730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17731 if (!SWIG_IsOK(res1)) {
17732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17733 }
17734 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 {
17738 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17739 result = (wxString *) &_result_ref;
17740 }
17741 wxPyEndAllowThreads(__tstate);
17742 if (PyErr_Occurred()) SWIG_fail;
17743 }
17744 {
17745 #if wxUSE_UNICODE
17746 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17747 #else
17748 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17749 #endif
17750 }
17751 return resultobj;
17752 fail:
17753 return NULL;
17754 }
17755
17756
17757 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17758 PyObject *resultobj = 0;
17759 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17760 wxArrayString *result = 0 ;
17761 void *argp1 = 0 ;
17762 int res1 = 0 ;
17763 PyObject *swig_obj[1] ;
17764
17765 if (!args) SWIG_fail;
17766 swig_obj[0] = args;
17767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17768 if (!SWIG_IsOK(res1)) {
17769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17770 }
17771 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17772 {
17773 PyThreadState* __tstate = wxPyBeginAllowThreads();
17774 {
17775 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17776 result = (wxArrayString *) &_result_ref;
17777 }
17778 wxPyEndAllowThreads(__tstate);
17779 if (PyErr_Occurred()) SWIG_fail;
17780 }
17781 {
17782 resultobj = wxArrayString2PyList_helper(*result);
17783 }
17784 return resultobj;
17785 fail:
17786 return NULL;
17787 }
17788
17789
17790 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791 PyObject *resultobj = 0;
17792 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17793 size_t result;
17794 void *argp1 = 0 ;
17795 int res1 = 0 ;
17796 PyObject *swig_obj[1] ;
17797
17798 if (!args) SWIG_fail;
17799 swig_obj[0] = args;
17800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17801 if (!SWIG_IsOK(res1)) {
17802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17803 }
17804 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17805 {
17806 PyThreadState* __tstate = wxPyBeginAllowThreads();
17807 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17808 wxPyEndAllowThreads(__tstate);
17809 if (PyErr_Occurred()) SWIG_fail;
17810 }
17811 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17812 return resultobj;
17813 fail:
17814 return NULL;
17815 }
17816
17817
17818 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17819 PyObject *resultobj = 0;
17820 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17821 wxString *result = 0 ;
17822 void *argp1 = 0 ;
17823 int res1 = 0 ;
17824 PyObject *swig_obj[1] ;
17825
17826 if (!args) SWIG_fail;
17827 swig_obj[0] = args;
17828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17829 if (!SWIG_IsOK(res1)) {
17830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17831 }
17832 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17833 {
17834 PyThreadState* __tstate = wxPyBeginAllowThreads();
17835 {
17836 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17837 result = (wxString *) &_result_ref;
17838 }
17839 wxPyEndAllowThreads(__tstate);
17840 if (PyErr_Occurred()) SWIG_fail;
17841 }
17842 {
17843 #if wxUSE_UNICODE
17844 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17845 #else
17846 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17847 #endif
17848 }
17849 return resultobj;
17850 fail:
17851 return NULL;
17852 }
17853
17854
17855 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17856 PyObject *resultobj = 0;
17857 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17858 int result;
17859 void *argp1 = 0 ;
17860 int res1 = 0 ;
17861 PyObject *swig_obj[1] ;
17862
17863 if (!args) SWIG_fail;
17864 swig_obj[0] = args;
17865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17866 if (!SWIG_IsOK(res1)) {
17867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17868 }
17869 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17870 {
17871 PyThreadState* __tstate = wxPyBeginAllowThreads();
17872 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17873 wxPyEndAllowThreads(__tstate);
17874 if (PyErr_Occurred()) SWIG_fail;
17875 }
17876 resultobj = SWIG_From_int(static_cast< int >(result));
17877 return resultobj;
17878 fail:
17879 return NULL;
17880 }
17881
17882
17883 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17884 PyObject *obj;
17885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17886 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17887 return SWIG_Py_Void();
17888 }
17889
17890 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17891 return SWIG_Python_InitShadowInstance(args);
17892 }
17893
17894 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17895 PyObject *resultobj = 0;
17896 wxFileTypeInfo *arg1 = 0 ;
17897 wxFileType *result = 0 ;
17898 void *argp1 = 0 ;
17899 int res1 = 0 ;
17900 PyObject * obj0 = 0 ;
17901 char * kwnames[] = {
17902 (char *) "ftInfo", NULL
17903 };
17904
17905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
17906 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17907 if (!SWIG_IsOK(res1)) {
17908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17909 }
17910 if (!argp1) {
17911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17912 }
17913 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17914 {
17915 PyThreadState* __tstate = wxPyBeginAllowThreads();
17916 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
17917 wxPyEndAllowThreads(__tstate);
17918 if (PyErr_Occurred()) SWIG_fail;
17919 }
17920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
17921 return resultobj;
17922 fail:
17923 return NULL;
17924 }
17925
17926
17927 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17928 PyObject *resultobj = 0;
17929 wxFileType *arg1 = (wxFileType *) 0 ;
17930 void *argp1 = 0 ;
17931 int res1 = 0 ;
17932 PyObject *swig_obj[1] ;
17933
17934 if (!args) SWIG_fail;
17935 swig_obj[0] = args;
17936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
17937 if (!SWIG_IsOK(res1)) {
17938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17939 }
17940 arg1 = reinterpret_cast< wxFileType * >(argp1);
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 delete arg1;
17944
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 resultobj = SWIG_Py_Void();
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17956 PyObject *resultobj = 0;
17957 wxFileType *arg1 = (wxFileType *) 0 ;
17958 PyObject *result = 0 ;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 PyObject *swig_obj[1] ;
17962
17963 if (!args) SWIG_fail;
17964 swig_obj[0] = args;
17965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17966 if (!SWIG_IsOK(res1)) {
17967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17968 }
17969 arg1 = reinterpret_cast< wxFileType * >(argp1);
17970 {
17971 PyThreadState* __tstate = wxPyBeginAllowThreads();
17972 result = (PyObject *)wxFileType_GetMimeType(arg1);
17973 wxPyEndAllowThreads(__tstate);
17974 if (PyErr_Occurred()) SWIG_fail;
17975 }
17976 resultobj = result;
17977 return resultobj;
17978 fail:
17979 return NULL;
17980 }
17981
17982
17983 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17984 PyObject *resultobj = 0;
17985 wxFileType *arg1 = (wxFileType *) 0 ;
17986 PyObject *result = 0 ;
17987 void *argp1 = 0 ;
17988 int res1 = 0 ;
17989 PyObject *swig_obj[1] ;
17990
17991 if (!args) SWIG_fail;
17992 swig_obj[0] = args;
17993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17994 if (!SWIG_IsOK(res1)) {
17995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17996 }
17997 arg1 = reinterpret_cast< wxFileType * >(argp1);
17998 {
17999 PyThreadState* __tstate = wxPyBeginAllowThreads();
18000 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18001 wxPyEndAllowThreads(__tstate);
18002 if (PyErr_Occurred()) SWIG_fail;
18003 }
18004 resultobj = result;
18005 return resultobj;
18006 fail:
18007 return NULL;
18008 }
18009
18010
18011 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18012 PyObject *resultobj = 0;
18013 wxFileType *arg1 = (wxFileType *) 0 ;
18014 PyObject *result = 0 ;
18015 void *argp1 = 0 ;
18016 int res1 = 0 ;
18017 PyObject *swig_obj[1] ;
18018
18019 if (!args) SWIG_fail;
18020 swig_obj[0] = args;
18021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18022 if (!SWIG_IsOK(res1)) {
18023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18024 }
18025 arg1 = reinterpret_cast< wxFileType * >(argp1);
18026 {
18027 PyThreadState* __tstate = wxPyBeginAllowThreads();
18028 result = (PyObject *)wxFileType_GetExtensions(arg1);
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 resultobj = result;
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18040 PyObject *resultobj = 0;
18041 wxFileType *arg1 = (wxFileType *) 0 ;
18042 wxIcon *result = 0 ;
18043 void *argp1 = 0 ;
18044 int res1 = 0 ;
18045 PyObject *swig_obj[1] ;
18046
18047 if (!args) SWIG_fail;
18048 swig_obj[0] = args;
18049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18050 if (!SWIG_IsOK(res1)) {
18051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18052 }
18053 arg1 = reinterpret_cast< wxFileType * >(argp1);
18054 {
18055 PyThreadState* __tstate = wxPyBeginAllowThreads();
18056 result = (wxIcon *)wxFileType_GetIcon(arg1);
18057 wxPyEndAllowThreads(__tstate);
18058 if (PyErr_Occurred()) SWIG_fail;
18059 }
18060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18061 return resultobj;
18062 fail:
18063 return NULL;
18064 }
18065
18066
18067 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18068 PyObject *resultobj = 0;
18069 wxFileType *arg1 = (wxFileType *) 0 ;
18070 PyObject *result = 0 ;
18071 void *argp1 = 0 ;
18072 int res1 = 0 ;
18073 PyObject *swig_obj[1] ;
18074
18075 if (!args) SWIG_fail;
18076 swig_obj[0] = args;
18077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18078 if (!SWIG_IsOK(res1)) {
18079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18080 }
18081 arg1 = reinterpret_cast< wxFileType * >(argp1);
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 resultobj = result;
18089 return resultobj;
18090 fail:
18091 return NULL;
18092 }
18093
18094
18095 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18096 PyObject *resultobj = 0;
18097 wxFileType *arg1 = (wxFileType *) 0 ;
18098 PyObject *result = 0 ;
18099 void *argp1 = 0 ;
18100 int res1 = 0 ;
18101 PyObject *swig_obj[1] ;
18102
18103 if (!args) SWIG_fail;
18104 swig_obj[0] = args;
18105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18108 }
18109 arg1 = reinterpret_cast< wxFileType * >(argp1);
18110 {
18111 PyThreadState* __tstate = wxPyBeginAllowThreads();
18112 result = (PyObject *)wxFileType_GetDescription(arg1);
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 resultobj = result;
18117 return resultobj;
18118 fail:
18119 return NULL;
18120 }
18121
18122
18123 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18124 PyObject *resultobj = 0;
18125 wxFileType *arg1 = (wxFileType *) 0 ;
18126 wxString *arg2 = 0 ;
18127 wxString const &arg3_defvalue = wxPyEmptyString ;
18128 wxString *arg3 = (wxString *) &arg3_defvalue ;
18129 PyObject *result = 0 ;
18130 void *argp1 = 0 ;
18131 int res1 = 0 ;
18132 bool temp2 = false ;
18133 bool temp3 = false ;
18134 PyObject * obj0 = 0 ;
18135 PyObject * obj1 = 0 ;
18136 PyObject * obj2 = 0 ;
18137 char * kwnames[] = {
18138 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18139 };
18140
18141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18143 if (!SWIG_IsOK(res1)) {
18144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18145 }
18146 arg1 = reinterpret_cast< wxFileType * >(argp1);
18147 {
18148 arg2 = wxString_in_helper(obj1);
18149 if (arg2 == NULL) SWIG_fail;
18150 temp2 = true;
18151 }
18152 if (obj2) {
18153 {
18154 arg3 = wxString_in_helper(obj2);
18155 if (arg3 == NULL) SWIG_fail;
18156 temp3 = true;
18157 }
18158 }
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 resultobj = result;
18166 {
18167 if (temp2)
18168 delete arg2;
18169 }
18170 {
18171 if (temp3)
18172 delete arg3;
18173 }
18174 return resultobj;
18175 fail:
18176 {
18177 if (temp2)
18178 delete arg2;
18179 }
18180 {
18181 if (temp3)
18182 delete arg3;
18183 }
18184 return NULL;
18185 }
18186
18187
18188 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18189 PyObject *resultobj = 0;
18190 wxFileType *arg1 = (wxFileType *) 0 ;
18191 wxString *arg2 = 0 ;
18192 wxString const &arg3_defvalue = wxPyEmptyString ;
18193 wxString *arg3 = (wxString *) &arg3_defvalue ;
18194 PyObject *result = 0 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 bool temp2 = false ;
18198 bool temp3 = false ;
18199 PyObject * obj0 = 0 ;
18200 PyObject * obj1 = 0 ;
18201 PyObject * obj2 = 0 ;
18202 char * kwnames[] = {
18203 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18204 };
18205
18206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18208 if (!SWIG_IsOK(res1)) {
18209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18210 }
18211 arg1 = reinterpret_cast< wxFileType * >(argp1);
18212 {
18213 arg2 = wxString_in_helper(obj1);
18214 if (arg2 == NULL) SWIG_fail;
18215 temp2 = true;
18216 }
18217 if (obj2) {
18218 {
18219 arg3 = wxString_in_helper(obj2);
18220 if (arg3 == NULL) SWIG_fail;
18221 temp3 = true;
18222 }
18223 }
18224 {
18225 PyThreadState* __tstate = wxPyBeginAllowThreads();
18226 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18227 wxPyEndAllowThreads(__tstate);
18228 if (PyErr_Occurred()) SWIG_fail;
18229 }
18230 resultobj = result;
18231 {
18232 if (temp2)
18233 delete arg2;
18234 }
18235 {
18236 if (temp3)
18237 delete arg3;
18238 }
18239 return resultobj;
18240 fail:
18241 {
18242 if (temp2)
18243 delete arg2;
18244 }
18245 {
18246 if (temp3)
18247 delete arg3;
18248 }
18249 return NULL;
18250 }
18251
18252
18253 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18254 PyObject *resultobj = 0;
18255 wxFileType *arg1 = (wxFileType *) 0 ;
18256 wxString *arg2 = 0 ;
18257 wxString const &arg3_defvalue = wxPyEmptyString ;
18258 wxString *arg3 = (wxString *) &arg3_defvalue ;
18259 PyObject *result = 0 ;
18260 void *argp1 = 0 ;
18261 int res1 = 0 ;
18262 bool temp2 = false ;
18263 bool temp3 = false ;
18264 PyObject * obj0 = 0 ;
18265 PyObject * obj1 = 0 ;
18266 PyObject * obj2 = 0 ;
18267 char * kwnames[] = {
18268 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18269 };
18270
18271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18273 if (!SWIG_IsOK(res1)) {
18274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18275 }
18276 arg1 = reinterpret_cast< wxFileType * >(argp1);
18277 {
18278 arg2 = wxString_in_helper(obj1);
18279 if (arg2 == NULL) SWIG_fail;
18280 temp2 = true;
18281 }
18282 if (obj2) {
18283 {
18284 arg3 = wxString_in_helper(obj2);
18285 if (arg3 == NULL) SWIG_fail;
18286 temp3 = true;
18287 }
18288 }
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18292 wxPyEndAllowThreads(__tstate);
18293 if (PyErr_Occurred()) SWIG_fail;
18294 }
18295 resultobj = result;
18296 {
18297 if (temp2)
18298 delete arg2;
18299 }
18300 {
18301 if (temp3)
18302 delete arg3;
18303 }
18304 return resultobj;
18305 fail:
18306 {
18307 if (temp2)
18308 delete arg2;
18309 }
18310 {
18311 if (temp3)
18312 delete arg3;
18313 }
18314 return NULL;
18315 }
18316
18317
18318 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18319 PyObject *resultobj = 0;
18320 wxFileType *arg1 = (wxFileType *) 0 ;
18321 wxString *arg2 = 0 ;
18322 wxString *arg3 = 0 ;
18323 bool arg4 = (bool) true ;
18324 bool result;
18325 void *argp1 = 0 ;
18326 int res1 = 0 ;
18327 bool temp2 = false ;
18328 bool temp3 = false ;
18329 bool val4 ;
18330 int ecode4 = 0 ;
18331 PyObject * obj0 = 0 ;
18332 PyObject * obj1 = 0 ;
18333 PyObject * obj2 = 0 ;
18334 PyObject * obj3 = 0 ;
18335 char * kwnames[] = {
18336 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18337 };
18338
18339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18341 if (!SWIG_IsOK(res1)) {
18342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18343 }
18344 arg1 = reinterpret_cast< wxFileType * >(argp1);
18345 {
18346 arg2 = wxString_in_helper(obj1);
18347 if (arg2 == NULL) SWIG_fail;
18348 temp2 = true;
18349 }
18350 {
18351 arg3 = wxString_in_helper(obj2);
18352 if (arg3 == NULL) SWIG_fail;
18353 temp3 = true;
18354 }
18355 if (obj3) {
18356 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18357 if (!SWIG_IsOK(ecode4)) {
18358 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18359 }
18360 arg4 = static_cast< bool >(val4);
18361 }
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 {
18369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18370 }
18371 {
18372 if (temp2)
18373 delete arg2;
18374 }
18375 {
18376 if (temp3)
18377 delete arg3;
18378 }
18379 return resultobj;
18380 fail:
18381 {
18382 if (temp2)
18383 delete arg2;
18384 }
18385 {
18386 if (temp3)
18387 delete arg3;
18388 }
18389 return NULL;
18390 }
18391
18392
18393 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18394 PyObject *resultobj = 0;
18395 wxFileType *arg1 = (wxFileType *) 0 ;
18396 wxString const &arg2_defvalue = wxPyEmptyString ;
18397 wxString *arg2 = (wxString *) &arg2_defvalue ;
18398 int arg3 = (int) 0 ;
18399 bool result;
18400 void *argp1 = 0 ;
18401 int res1 = 0 ;
18402 bool temp2 = false ;
18403 int val3 ;
18404 int ecode3 = 0 ;
18405 PyObject * obj0 = 0 ;
18406 PyObject * obj1 = 0 ;
18407 PyObject * obj2 = 0 ;
18408 char * kwnames[] = {
18409 (char *) "self",(char *) "cmd",(char *) "index", NULL
18410 };
18411
18412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18414 if (!SWIG_IsOK(res1)) {
18415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18416 }
18417 arg1 = reinterpret_cast< wxFileType * >(argp1);
18418 if (obj1) {
18419 {
18420 arg2 = wxString_in_helper(obj1);
18421 if (arg2 == NULL) SWIG_fail;
18422 temp2 = true;
18423 }
18424 }
18425 if (obj2) {
18426 ecode3 = SWIG_AsVal_int(obj2, &val3);
18427 if (!SWIG_IsOK(ecode3)) {
18428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18429 }
18430 arg3 = static_cast< int >(val3);
18431 }
18432 {
18433 PyThreadState* __tstate = wxPyBeginAllowThreads();
18434 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 {
18439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18440 }
18441 {
18442 if (temp2)
18443 delete arg2;
18444 }
18445 return resultobj;
18446 fail:
18447 {
18448 if (temp2)
18449 delete arg2;
18450 }
18451 return NULL;
18452 }
18453
18454
18455 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18456 PyObject *resultobj = 0;
18457 wxFileType *arg1 = (wxFileType *) 0 ;
18458 bool result;
18459 void *argp1 = 0 ;
18460 int res1 = 0 ;
18461 PyObject *swig_obj[1] ;
18462
18463 if (!args) SWIG_fail;
18464 swig_obj[0] = args;
18465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18466 if (!SWIG_IsOK(res1)) {
18467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18468 }
18469 arg1 = reinterpret_cast< wxFileType * >(argp1);
18470 {
18471 PyThreadState* __tstate = wxPyBeginAllowThreads();
18472 result = (bool)(arg1)->Unassociate();
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 {
18477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18478 }
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18486 PyObject *resultobj = 0;
18487 wxString *arg1 = 0 ;
18488 wxString *arg2 = 0 ;
18489 wxString const &arg3_defvalue = wxPyEmptyString ;
18490 wxString *arg3 = (wxString *) &arg3_defvalue ;
18491 wxString result;
18492 bool temp1 = false ;
18493 bool temp2 = false ;
18494 bool temp3 = false ;
18495 PyObject * obj0 = 0 ;
18496 PyObject * obj1 = 0 ;
18497 PyObject * obj2 = 0 ;
18498 char * kwnames[] = {
18499 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18500 };
18501
18502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18503 {
18504 arg1 = wxString_in_helper(obj0);
18505 if (arg1 == NULL) SWIG_fail;
18506 temp1 = true;
18507 }
18508 {
18509 arg2 = wxString_in_helper(obj1);
18510 if (arg2 == NULL) SWIG_fail;
18511 temp2 = true;
18512 }
18513 if (obj2) {
18514 {
18515 arg3 = wxString_in_helper(obj2);
18516 if (arg3 == NULL) SWIG_fail;
18517 temp3 = true;
18518 }
18519 }
18520 {
18521 PyThreadState* __tstate = wxPyBeginAllowThreads();
18522 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18523 wxPyEndAllowThreads(__tstate);
18524 if (PyErr_Occurred()) SWIG_fail;
18525 }
18526 {
18527 #if wxUSE_UNICODE
18528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18529 #else
18530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18531 #endif
18532 }
18533 {
18534 if (temp1)
18535 delete arg1;
18536 }
18537 {
18538 if (temp2)
18539 delete arg2;
18540 }
18541 {
18542 if (temp3)
18543 delete arg3;
18544 }
18545 return resultobj;
18546 fail:
18547 {
18548 if (temp1)
18549 delete arg1;
18550 }
18551 {
18552 if (temp2)
18553 delete arg2;
18554 }
18555 {
18556 if (temp3)
18557 delete arg3;
18558 }
18559 return NULL;
18560 }
18561
18562
18563 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18564 PyObject *obj;
18565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18566 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18567 return SWIG_Py_Void();
18568 }
18569
18570 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18571 return SWIG_Python_InitShadowInstance(args);
18572 }
18573
18574 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18575 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18576 return 1;
18577 }
18578
18579
18580 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18581 PyObject *pyobj = 0;
18582
18583 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18584 return pyobj;
18585 }
18586
18587
18588 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj = 0;
18590 wxString *arg1 = 0 ;
18591 wxString *arg2 = 0 ;
18592 bool result;
18593 bool temp1 = false ;
18594 bool temp2 = false ;
18595 PyObject * obj0 = 0 ;
18596 PyObject * obj1 = 0 ;
18597 char * kwnames[] = {
18598 (char *) "mimeType",(char *) "wildcard", NULL
18599 };
18600
18601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18602 {
18603 arg1 = wxString_in_helper(obj0);
18604 if (arg1 == NULL) SWIG_fail;
18605 temp1 = true;
18606 }
18607 {
18608 arg2 = wxString_in_helper(obj1);
18609 if (arg2 == NULL) SWIG_fail;
18610 temp2 = true;
18611 }
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 {
18619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18620 }
18621 {
18622 if (temp1)
18623 delete arg1;
18624 }
18625 {
18626 if (temp2)
18627 delete arg2;
18628 }
18629 return resultobj;
18630 fail:
18631 {
18632 if (temp1)
18633 delete arg1;
18634 }
18635 {
18636 if (temp2)
18637 delete arg2;
18638 }
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxMimeTypesManager *result = 0 ;
18646
18647 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18662 PyObject *resultobj = 0;
18663 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18664 int arg2 = (int) wxMAILCAP_ALL ;
18665 wxString const &arg3_defvalue = wxPyEmptyString ;
18666 wxString *arg3 = (wxString *) &arg3_defvalue ;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 int val2 ;
18670 int ecode2 = 0 ;
18671 bool temp3 = false ;
18672 PyObject * obj0 = 0 ;
18673 PyObject * obj1 = 0 ;
18674 PyObject * obj2 = 0 ;
18675 char * kwnames[] = {
18676 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18677 };
18678
18679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18681 if (!SWIG_IsOK(res1)) {
18682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18683 }
18684 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18685 if (obj1) {
18686 ecode2 = SWIG_AsVal_int(obj1, &val2);
18687 if (!SWIG_IsOK(ecode2)) {
18688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18689 }
18690 arg2 = static_cast< int >(val2);
18691 }
18692 if (obj2) {
18693 {
18694 arg3 = wxString_in_helper(obj2);
18695 if (arg3 == NULL) SWIG_fail;
18696 temp3 = true;
18697 }
18698 }
18699 {
18700 PyThreadState* __tstate = wxPyBeginAllowThreads();
18701 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18702 wxPyEndAllowThreads(__tstate);
18703 if (PyErr_Occurred()) SWIG_fail;
18704 }
18705 resultobj = SWIG_Py_Void();
18706 {
18707 if (temp3)
18708 delete arg3;
18709 }
18710 return resultobj;
18711 fail:
18712 {
18713 if (temp3)
18714 delete arg3;
18715 }
18716 return NULL;
18717 }
18718
18719
18720 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18721 PyObject *resultobj = 0;
18722 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18723 void *argp1 = 0 ;
18724 int res1 = 0 ;
18725 PyObject *swig_obj[1] ;
18726
18727 if (!args) SWIG_fail;
18728 swig_obj[0] = args;
18729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18730 if (!SWIG_IsOK(res1)) {
18731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18732 }
18733 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18734 {
18735 PyThreadState* __tstate = wxPyBeginAllowThreads();
18736 (arg1)->ClearData();
18737 wxPyEndAllowThreads(__tstate);
18738 if (PyErr_Occurred()) SWIG_fail;
18739 }
18740 resultobj = SWIG_Py_Void();
18741 return resultobj;
18742 fail:
18743 return NULL;
18744 }
18745
18746
18747 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18748 PyObject *resultobj = 0;
18749 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18750 wxString *arg2 = 0 ;
18751 wxFileType *result = 0 ;
18752 void *argp1 = 0 ;
18753 int res1 = 0 ;
18754 bool temp2 = false ;
18755 PyObject * obj0 = 0 ;
18756 PyObject * obj1 = 0 ;
18757 char * kwnames[] = {
18758 (char *) "self",(char *) "ext", NULL
18759 };
18760
18761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18763 if (!SWIG_IsOK(res1)) {
18764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18765 }
18766 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18767 {
18768 arg2 = wxString_in_helper(obj1);
18769 if (arg2 == NULL) SWIG_fail;
18770 temp2 = true;
18771 }
18772 {
18773 PyThreadState* __tstate = wxPyBeginAllowThreads();
18774 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18775 wxPyEndAllowThreads(__tstate);
18776 if (PyErr_Occurred()) SWIG_fail;
18777 }
18778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18779 {
18780 if (temp2)
18781 delete arg2;
18782 }
18783 return resultobj;
18784 fail:
18785 {
18786 if (temp2)
18787 delete arg2;
18788 }
18789 return NULL;
18790 }
18791
18792
18793 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18794 PyObject *resultobj = 0;
18795 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18796 wxString *arg2 = 0 ;
18797 wxFileType *result = 0 ;
18798 void *argp1 = 0 ;
18799 int res1 = 0 ;
18800 bool temp2 = false ;
18801 PyObject * obj0 = 0 ;
18802 PyObject * obj1 = 0 ;
18803 char * kwnames[] = {
18804 (char *) "self",(char *) "mimeType", NULL
18805 };
18806
18807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18809 if (!SWIG_IsOK(res1)) {
18810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18811 }
18812 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18813 {
18814 arg2 = wxString_in_helper(obj1);
18815 if (arg2 == NULL) SWIG_fail;
18816 temp2 = true;
18817 }
18818 {
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18825 {
18826 if (temp2)
18827 delete arg2;
18828 }
18829 return resultobj;
18830 fail:
18831 {
18832 if (temp2)
18833 delete arg2;
18834 }
18835 return NULL;
18836 }
18837
18838
18839 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18840 PyObject *resultobj = 0;
18841 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18842 wxString *arg2 = 0 ;
18843 bool arg3 = (bool) false ;
18844 bool result;
18845 void *argp1 = 0 ;
18846 int res1 = 0 ;
18847 bool temp2 = false ;
18848 bool val3 ;
18849 int ecode3 = 0 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 PyObject * obj2 = 0 ;
18853 char * kwnames[] = {
18854 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18855 };
18856
18857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18859 if (!SWIG_IsOK(res1)) {
18860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18861 }
18862 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18863 {
18864 arg2 = wxString_in_helper(obj1);
18865 if (arg2 == NULL) SWIG_fail;
18866 temp2 = true;
18867 }
18868 if (obj2) {
18869 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18870 if (!SWIG_IsOK(ecode3)) {
18871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18872 }
18873 arg3 = static_cast< bool >(val3);
18874 }
18875 {
18876 PyThreadState* __tstate = wxPyBeginAllowThreads();
18877 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18878 wxPyEndAllowThreads(__tstate);
18879 if (PyErr_Occurred()) SWIG_fail;
18880 }
18881 {
18882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18883 }
18884 {
18885 if (temp2)
18886 delete arg2;
18887 }
18888 return resultobj;
18889 fail:
18890 {
18891 if (temp2)
18892 delete arg2;
18893 }
18894 return NULL;
18895 }
18896
18897
18898 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj = 0;
18900 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18901 wxString *arg2 = 0 ;
18902 bool result;
18903 void *argp1 = 0 ;
18904 int res1 = 0 ;
18905 bool temp2 = false ;
18906 PyObject * obj0 = 0 ;
18907 PyObject * obj1 = 0 ;
18908 char * kwnames[] = {
18909 (char *) "self",(char *) "filename", NULL
18910 };
18911
18912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
18913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18914 if (!SWIG_IsOK(res1)) {
18915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18916 }
18917 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18918 {
18919 arg2 = wxString_in_helper(obj1);
18920 if (arg2 == NULL) SWIG_fail;
18921 temp2 = true;
18922 }
18923 {
18924 PyThreadState* __tstate = wxPyBeginAllowThreads();
18925 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 {
18930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18931 }
18932 {
18933 if (temp2)
18934 delete arg2;
18935 }
18936 return resultobj;
18937 fail:
18938 {
18939 if (temp2)
18940 delete arg2;
18941 }
18942 return NULL;
18943 }
18944
18945
18946 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18947 PyObject *resultobj = 0;
18948 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18949 PyObject *result = 0 ;
18950 void *argp1 = 0 ;
18951 int res1 = 0 ;
18952 PyObject *swig_obj[1] ;
18953
18954 if (!args) SWIG_fail;
18955 swig_obj[0] = args;
18956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18957 if (!SWIG_IsOK(res1)) {
18958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18959 }
18960 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18964 wxPyEndAllowThreads(__tstate);
18965 if (PyErr_Occurred()) SWIG_fail;
18966 }
18967 resultobj = result;
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18975 PyObject *resultobj = 0;
18976 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18977 wxFileTypeInfo *arg2 = 0 ;
18978 void *argp1 = 0 ;
18979 int res1 = 0 ;
18980 void *argp2 = 0 ;
18981 int res2 = 0 ;
18982 PyObject * obj0 = 0 ;
18983 PyObject * obj1 = 0 ;
18984 char * kwnames[] = {
18985 (char *) "self",(char *) "ft", NULL
18986 };
18987
18988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18990 if (!SWIG_IsOK(res1)) {
18991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18992 }
18993 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18994 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18995 if (!SWIG_IsOK(res2)) {
18996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18997 }
18998 if (!argp2) {
18999 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19000 }
19001 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19002 {
19003 PyThreadState* __tstate = wxPyBeginAllowThreads();
19004 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19005 wxPyEndAllowThreads(__tstate);
19006 if (PyErr_Occurred()) SWIG_fail;
19007 }
19008 resultobj = SWIG_Py_Void();
19009 return resultobj;
19010 fail:
19011 return NULL;
19012 }
19013
19014
19015 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19016 PyObject *resultobj = 0;
19017 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19018 wxFileTypeInfo *arg2 = 0 ;
19019 wxFileType *result = 0 ;
19020 void *argp1 = 0 ;
19021 int res1 = 0 ;
19022 void *argp2 = 0 ;
19023 int res2 = 0 ;
19024 PyObject * obj0 = 0 ;
19025 PyObject * obj1 = 0 ;
19026 char * kwnames[] = {
19027 (char *) "self",(char *) "ftInfo", NULL
19028 };
19029
19030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19032 if (!SWIG_IsOK(res1)) {
19033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19034 }
19035 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19037 if (!SWIG_IsOK(res2)) {
19038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19039 }
19040 if (!argp2) {
19041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19042 }
19043 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19044 {
19045 PyThreadState* __tstate = wxPyBeginAllowThreads();
19046 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19047 wxPyEndAllowThreads(__tstate);
19048 if (PyErr_Occurred()) SWIG_fail;
19049 }
19050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19051 return resultobj;
19052 fail:
19053 return NULL;
19054 }
19055
19056
19057 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19058 PyObject *resultobj = 0;
19059 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19060 wxFileType *arg2 = (wxFileType *) 0 ;
19061 bool result;
19062 void *argp1 = 0 ;
19063 int res1 = 0 ;
19064 void *argp2 = 0 ;
19065 int res2 = 0 ;
19066 PyObject * obj0 = 0 ;
19067 PyObject * obj1 = 0 ;
19068 char * kwnames[] = {
19069 (char *) "self",(char *) "ft", NULL
19070 };
19071
19072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19074 if (!SWIG_IsOK(res1)) {
19075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19076 }
19077 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19078 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19079 if (!SWIG_IsOK(res2)) {
19080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19081 }
19082 arg2 = reinterpret_cast< wxFileType * >(argp2);
19083 {
19084 PyThreadState* __tstate = wxPyBeginAllowThreads();
19085 result = (bool)(arg1)->Unassociate(arg2);
19086 wxPyEndAllowThreads(__tstate);
19087 if (PyErr_Occurred()) SWIG_fail;
19088 }
19089 {
19090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19091 }
19092 return resultobj;
19093 fail:
19094 return NULL;
19095 }
19096
19097
19098 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19099 PyObject *resultobj = 0;
19100 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19101 void *argp1 = 0 ;
19102 int res1 = 0 ;
19103 PyObject *swig_obj[1] ;
19104
19105 if (!args) SWIG_fail;
19106 swig_obj[0] = args;
19107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19108 if (!SWIG_IsOK(res1)) {
19109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19110 }
19111 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19112 {
19113 PyThreadState* __tstate = wxPyBeginAllowThreads();
19114 delete arg1;
19115
19116 wxPyEndAllowThreads(__tstate);
19117 if (PyErr_Occurred()) SWIG_fail;
19118 }
19119 resultobj = SWIG_Py_Void();
19120 return resultobj;
19121 fail:
19122 return NULL;
19123 }
19124
19125
19126 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19127 PyObject *obj;
19128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19129 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19130 return SWIG_Py_Void();
19131 }
19132
19133 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19134 return SWIG_Python_InitShadowInstance(args);
19135 }
19136
19137 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19138 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19139 return 1;
19140 }
19141
19142
19143 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19144 PyObject *pyobj = 0;
19145
19146 {
19147 #if wxUSE_UNICODE
19148 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19149 #else
19150 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19151 #endif
19152 }
19153 return pyobj;
19154 }
19155
19156
19157 SWIGINTERN int ART_MENU_set(PyObject *) {
19158 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19159 return 1;
19160 }
19161
19162
19163 SWIGINTERN PyObject *ART_MENU_get(void) {
19164 PyObject *pyobj = 0;
19165
19166 {
19167 #if wxUSE_UNICODE
19168 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19169 #else
19170 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19171 #endif
19172 }
19173 return pyobj;
19174 }
19175
19176
19177 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19178 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19179 return 1;
19180 }
19181
19182
19183 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19184 PyObject *pyobj = 0;
19185
19186 {
19187 #if wxUSE_UNICODE
19188 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19189 #else
19190 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19191 #endif
19192 }
19193 return pyobj;
19194 }
19195
19196
19197 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19198 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19199 return 1;
19200 }
19201
19202
19203 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19204 PyObject *pyobj = 0;
19205
19206 {
19207 #if wxUSE_UNICODE
19208 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19209 #else
19210 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19211 #endif
19212 }
19213 return pyobj;
19214 }
19215
19216
19217 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19218 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19219 return 1;
19220 }
19221
19222
19223 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19224 PyObject *pyobj = 0;
19225
19226 {
19227 #if wxUSE_UNICODE
19228 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19229 #else
19230 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19231 #endif
19232 }
19233 return pyobj;
19234 }
19235
19236
19237 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19238 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19239 return 1;
19240 }
19241
19242
19243 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19244 PyObject *pyobj = 0;
19245
19246 {
19247 #if wxUSE_UNICODE
19248 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19249 #else
19250 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19251 #endif
19252 }
19253 return pyobj;
19254 }
19255
19256
19257 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19258 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19259 return 1;
19260 }
19261
19262
19263 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19264 PyObject *pyobj = 0;
19265
19266 {
19267 #if wxUSE_UNICODE
19268 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19269 #else
19270 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19271 #endif
19272 }
19273 return pyobj;
19274 }
19275
19276
19277 SWIGINTERN int ART_OTHER_set(PyObject *) {
19278 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19279 return 1;
19280 }
19281
19282
19283 SWIGINTERN PyObject *ART_OTHER_get(void) {
19284 PyObject *pyobj = 0;
19285
19286 {
19287 #if wxUSE_UNICODE
19288 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19289 #else
19290 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19291 #endif
19292 }
19293 return pyobj;
19294 }
19295
19296
19297 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19298 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19299 return 1;
19300 }
19301
19302
19303 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19304 PyObject *pyobj = 0;
19305
19306 {
19307 #if wxUSE_UNICODE
19308 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19309 #else
19310 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19311 #endif
19312 }
19313 return pyobj;
19314 }
19315
19316
19317 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19318 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19319 return 1;
19320 }
19321
19322
19323 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19324 PyObject *pyobj = 0;
19325
19326 {
19327 #if wxUSE_UNICODE
19328 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19329 #else
19330 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19331 #endif
19332 }
19333 return pyobj;
19334 }
19335
19336
19337 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19338 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19339 return 1;
19340 }
19341
19342
19343 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19344 PyObject *pyobj = 0;
19345
19346 {
19347 #if wxUSE_UNICODE
19348 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19349 #else
19350 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19351 #endif
19352 }
19353 return pyobj;
19354 }
19355
19356
19357 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19358 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19359 return 1;
19360 }
19361
19362
19363 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19364 PyObject *pyobj = 0;
19365
19366 {
19367 #if wxUSE_UNICODE
19368 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19369 #else
19370 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19371 #endif
19372 }
19373 return pyobj;
19374 }
19375
19376
19377 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19378 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19379 return 1;
19380 }
19381
19382
19383 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19384 PyObject *pyobj = 0;
19385
19386 {
19387 #if wxUSE_UNICODE
19388 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19389 #else
19390 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19391 #endif
19392 }
19393 return pyobj;
19394 }
19395
19396
19397 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19398 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19399 return 1;
19400 }
19401
19402
19403 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19404 PyObject *pyobj = 0;
19405
19406 {
19407 #if wxUSE_UNICODE
19408 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19409 #else
19410 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19411 #endif
19412 }
19413 return pyobj;
19414 }
19415
19416
19417 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19418 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19419 return 1;
19420 }
19421
19422
19423 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19424 PyObject *pyobj = 0;
19425
19426 {
19427 #if wxUSE_UNICODE
19428 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19429 #else
19430 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19431 #endif
19432 }
19433 return pyobj;
19434 }
19435
19436
19437 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19438 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19439 return 1;
19440 }
19441
19442
19443 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19444 PyObject *pyobj = 0;
19445
19446 {
19447 #if wxUSE_UNICODE
19448 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19449 #else
19450 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19451 #endif
19452 }
19453 return pyobj;
19454 }
19455
19456
19457 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19458 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19459 return 1;
19460 }
19461
19462
19463 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19464 PyObject *pyobj = 0;
19465
19466 {
19467 #if wxUSE_UNICODE
19468 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19469 #else
19470 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19471 #endif
19472 }
19473 return pyobj;
19474 }
19475
19476
19477 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19478 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19479 return 1;
19480 }
19481
19482
19483 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19484 PyObject *pyobj = 0;
19485
19486 {
19487 #if wxUSE_UNICODE
19488 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19489 #else
19490 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19491 #endif
19492 }
19493 return pyobj;
19494 }
19495
19496
19497 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19498 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19499 return 1;
19500 }
19501
19502
19503 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19504 PyObject *pyobj = 0;
19505
19506 {
19507 #if wxUSE_UNICODE
19508 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19509 #else
19510 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19511 #endif
19512 }
19513 return pyobj;
19514 }
19515
19516
19517 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19518 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19519 return 1;
19520 }
19521
19522
19523 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19524 PyObject *pyobj = 0;
19525
19526 {
19527 #if wxUSE_UNICODE
19528 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19529 #else
19530 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19531 #endif
19532 }
19533 return pyobj;
19534 }
19535
19536
19537 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19538 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19539 return 1;
19540 }
19541
19542
19543 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19544 PyObject *pyobj = 0;
19545
19546 {
19547 #if wxUSE_UNICODE
19548 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19549 #else
19550 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19551 #endif
19552 }
19553 return pyobj;
19554 }
19555
19556
19557 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19558 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19559 return 1;
19560 }
19561
19562
19563 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19564 PyObject *pyobj = 0;
19565
19566 {
19567 #if wxUSE_UNICODE
19568 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19569 #else
19570 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19571 #endif
19572 }
19573 return pyobj;
19574 }
19575
19576
19577 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19578 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19579 return 1;
19580 }
19581
19582
19583 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19584 PyObject *pyobj = 0;
19585
19586 {
19587 #if wxUSE_UNICODE
19588 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19589 #else
19590 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19591 #endif
19592 }
19593 return pyobj;
19594 }
19595
19596
19597 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19598 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19599 return 1;
19600 }
19601
19602
19603 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19604 PyObject *pyobj = 0;
19605
19606 {
19607 #if wxUSE_UNICODE
19608 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19609 #else
19610 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19611 #endif
19612 }
19613 return pyobj;
19614 }
19615
19616
19617 SWIGINTERN int ART_PRINT_set(PyObject *) {
19618 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19619 return 1;
19620 }
19621
19622
19623 SWIGINTERN PyObject *ART_PRINT_get(void) {
19624 PyObject *pyobj = 0;
19625
19626 {
19627 #if wxUSE_UNICODE
19628 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19629 #else
19630 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19631 #endif
19632 }
19633 return pyobj;
19634 }
19635
19636
19637 SWIGINTERN int ART_HELP_set(PyObject *) {
19638 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19639 return 1;
19640 }
19641
19642
19643 SWIGINTERN PyObject *ART_HELP_get(void) {
19644 PyObject *pyobj = 0;
19645
19646 {
19647 #if wxUSE_UNICODE
19648 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19649 #else
19650 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19651 #endif
19652 }
19653 return pyobj;
19654 }
19655
19656
19657 SWIGINTERN int ART_TIP_set(PyObject *) {
19658 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19659 return 1;
19660 }
19661
19662
19663 SWIGINTERN PyObject *ART_TIP_get(void) {
19664 PyObject *pyobj = 0;
19665
19666 {
19667 #if wxUSE_UNICODE
19668 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19669 #else
19670 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19671 #endif
19672 }
19673 return pyobj;
19674 }
19675
19676
19677 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19678 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19679 return 1;
19680 }
19681
19682
19683 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19684 PyObject *pyobj = 0;
19685
19686 {
19687 #if wxUSE_UNICODE
19688 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19689 #else
19690 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19691 #endif
19692 }
19693 return pyobj;
19694 }
19695
19696
19697 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19698 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19699 return 1;
19700 }
19701
19702
19703 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19704 PyObject *pyobj = 0;
19705
19706 {
19707 #if wxUSE_UNICODE
19708 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19709 #else
19710 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19711 #endif
19712 }
19713 return pyobj;
19714 }
19715
19716
19717 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19718 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19719 return 1;
19720 }
19721
19722
19723 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19724 PyObject *pyobj = 0;
19725
19726 {
19727 #if wxUSE_UNICODE
19728 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19729 #else
19730 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19731 #endif
19732 }
19733 return pyobj;
19734 }
19735
19736
19737 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19738 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19739 return 1;
19740 }
19741
19742
19743 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19744 PyObject *pyobj = 0;
19745
19746 {
19747 #if wxUSE_UNICODE
19748 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19749 #else
19750 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19751 #endif
19752 }
19753 return pyobj;
19754 }
19755
19756
19757 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19758 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19759 return 1;
19760 }
19761
19762
19763 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19764 PyObject *pyobj = 0;
19765
19766 {
19767 #if wxUSE_UNICODE
19768 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19769 #else
19770 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19771 #endif
19772 }
19773 return pyobj;
19774 }
19775
19776
19777 SWIGINTERN int ART_CDROM_set(PyObject *) {
19778 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19779 return 1;
19780 }
19781
19782
19783 SWIGINTERN PyObject *ART_CDROM_get(void) {
19784 PyObject *pyobj = 0;
19785
19786 {
19787 #if wxUSE_UNICODE
19788 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19789 #else
19790 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19791 #endif
19792 }
19793 return pyobj;
19794 }
19795
19796
19797 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19798 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19799 return 1;
19800 }
19801
19802
19803 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19804 PyObject *pyobj = 0;
19805
19806 {
19807 #if wxUSE_UNICODE
19808 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19809 #else
19810 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19811 #endif
19812 }
19813 return pyobj;
19814 }
19815
19816
19817 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19818 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19819 return 1;
19820 }
19821
19822
19823 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19824 PyObject *pyobj = 0;
19825
19826 {
19827 #if wxUSE_UNICODE
19828 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19829 #else
19830 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19831 #endif
19832 }
19833 return pyobj;
19834 }
19835
19836
19837 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19838 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19839 return 1;
19840 }
19841
19842
19843 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19844 PyObject *pyobj = 0;
19845
19846 {
19847 #if wxUSE_UNICODE
19848 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19849 #else
19850 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19851 #endif
19852 }
19853 return pyobj;
19854 }
19855
19856
19857 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19858 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19859 return 1;
19860 }
19861
19862
19863 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19864 PyObject *pyobj = 0;
19865
19866 {
19867 #if wxUSE_UNICODE
19868 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19869 #else
19870 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19871 #endif
19872 }
19873 return pyobj;
19874 }
19875
19876
19877 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19878 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19879 return 1;
19880 }
19881
19882
19883 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19884 PyObject *pyobj = 0;
19885
19886 {
19887 #if wxUSE_UNICODE
19888 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19889 #else
19890 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19891 #endif
19892 }
19893 return pyobj;
19894 }
19895
19896
19897 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
19898 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
19899 return 1;
19900 }
19901
19902
19903 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
19904 PyObject *pyobj = 0;
19905
19906 {
19907 #if wxUSE_UNICODE
19908 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19909 #else
19910 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19911 #endif
19912 }
19913 return pyobj;
19914 }
19915
19916
19917 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
19918 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
19919 return 1;
19920 }
19921
19922
19923 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
19924 PyObject *pyobj = 0;
19925
19926 {
19927 #if wxUSE_UNICODE
19928 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19929 #else
19930 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19931 #endif
19932 }
19933 return pyobj;
19934 }
19935
19936
19937 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19938 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19939 return 1;
19940 }
19941
19942
19943 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19944 PyObject *pyobj = 0;
19945
19946 {
19947 #if wxUSE_UNICODE
19948 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19949 #else
19950 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19951 #endif
19952 }
19953 return pyobj;
19954 }
19955
19956
19957 SWIGINTERN int ART_ERROR_set(PyObject *) {
19958 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19959 return 1;
19960 }
19961
19962
19963 SWIGINTERN PyObject *ART_ERROR_get(void) {
19964 PyObject *pyobj = 0;
19965
19966 {
19967 #if wxUSE_UNICODE
19968 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19969 #else
19970 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19971 #endif
19972 }
19973 return pyobj;
19974 }
19975
19976
19977 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19978 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19979 return 1;
19980 }
19981
19982
19983 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19984 PyObject *pyobj = 0;
19985
19986 {
19987 #if wxUSE_UNICODE
19988 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19989 #else
19990 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19991 #endif
19992 }
19993 return pyobj;
19994 }
19995
19996
19997 SWIGINTERN int ART_WARNING_set(PyObject *) {
19998 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19999 return 1;
20000 }
20001
20002
20003 SWIGINTERN PyObject *ART_WARNING_get(void) {
20004 PyObject *pyobj = 0;
20005
20006 {
20007 #if wxUSE_UNICODE
20008 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20009 #else
20010 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20011 #endif
20012 }
20013 return pyobj;
20014 }
20015
20016
20017 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20018 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20019 return 1;
20020 }
20021
20022
20023 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20024 PyObject *pyobj = 0;
20025
20026 {
20027 #if wxUSE_UNICODE
20028 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20029 #else
20030 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20031 #endif
20032 }
20033 return pyobj;
20034 }
20035
20036
20037 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20038 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20039 return 1;
20040 }
20041
20042
20043 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20044 PyObject *pyobj = 0;
20045
20046 {
20047 #if wxUSE_UNICODE
20048 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20049 #else
20050 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20051 #endif
20052 }
20053 return pyobj;
20054 }
20055
20056
20057 SWIGINTERN int ART_COPY_set(PyObject *) {
20058 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20059 return 1;
20060 }
20061
20062
20063 SWIGINTERN PyObject *ART_COPY_get(void) {
20064 PyObject *pyobj = 0;
20065
20066 {
20067 #if wxUSE_UNICODE
20068 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20069 #else
20070 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20071 #endif
20072 }
20073 return pyobj;
20074 }
20075
20076
20077 SWIGINTERN int ART_CUT_set(PyObject *) {
20078 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20079 return 1;
20080 }
20081
20082
20083 SWIGINTERN PyObject *ART_CUT_get(void) {
20084 PyObject *pyobj = 0;
20085
20086 {
20087 #if wxUSE_UNICODE
20088 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20089 #else
20090 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20091 #endif
20092 }
20093 return pyobj;
20094 }
20095
20096
20097 SWIGINTERN int ART_PASTE_set(PyObject *) {
20098 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20099 return 1;
20100 }
20101
20102
20103 SWIGINTERN PyObject *ART_PASTE_get(void) {
20104 PyObject *pyobj = 0;
20105
20106 {
20107 #if wxUSE_UNICODE
20108 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20109 #else
20110 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20111 #endif
20112 }
20113 return pyobj;
20114 }
20115
20116
20117 SWIGINTERN int ART_DELETE_set(PyObject *) {
20118 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20119 return 1;
20120 }
20121
20122
20123 SWIGINTERN PyObject *ART_DELETE_get(void) {
20124 PyObject *pyobj = 0;
20125
20126 {
20127 #if wxUSE_UNICODE
20128 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20129 #else
20130 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20131 #endif
20132 }
20133 return pyobj;
20134 }
20135
20136
20137 SWIGINTERN int ART_NEW_set(PyObject *) {
20138 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20139 return 1;
20140 }
20141
20142
20143 SWIGINTERN PyObject *ART_NEW_get(void) {
20144 PyObject *pyobj = 0;
20145
20146 {
20147 #if wxUSE_UNICODE
20148 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20149 #else
20150 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20151 #endif
20152 }
20153 return pyobj;
20154 }
20155
20156
20157 SWIGINTERN int ART_UNDO_set(PyObject *) {
20158 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20159 return 1;
20160 }
20161
20162
20163 SWIGINTERN PyObject *ART_UNDO_get(void) {
20164 PyObject *pyobj = 0;
20165
20166 {
20167 #if wxUSE_UNICODE
20168 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20169 #else
20170 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20171 #endif
20172 }
20173 return pyobj;
20174 }
20175
20176
20177 SWIGINTERN int ART_REDO_set(PyObject *) {
20178 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20179 return 1;
20180 }
20181
20182
20183 SWIGINTERN PyObject *ART_REDO_get(void) {
20184 PyObject *pyobj = 0;
20185
20186 {
20187 #if wxUSE_UNICODE
20188 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20189 #else
20190 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20191 #endif
20192 }
20193 return pyobj;
20194 }
20195
20196
20197 SWIGINTERN int ART_QUIT_set(PyObject *) {
20198 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20199 return 1;
20200 }
20201
20202
20203 SWIGINTERN PyObject *ART_QUIT_get(void) {
20204 PyObject *pyobj = 0;
20205
20206 {
20207 #if wxUSE_UNICODE
20208 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20209 #else
20210 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20211 #endif
20212 }
20213 return pyobj;
20214 }
20215
20216
20217 SWIGINTERN int ART_FIND_set(PyObject *) {
20218 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20219 return 1;
20220 }
20221
20222
20223 SWIGINTERN PyObject *ART_FIND_get(void) {
20224 PyObject *pyobj = 0;
20225
20226 {
20227 #if wxUSE_UNICODE
20228 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20229 #else
20230 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20231 #endif
20232 }
20233 return pyobj;
20234 }
20235
20236
20237 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20238 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20239 return 1;
20240 }
20241
20242
20243 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20244 PyObject *pyobj = 0;
20245
20246 {
20247 #if wxUSE_UNICODE
20248 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20249 #else
20250 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20251 #endif
20252 }
20253 return pyobj;
20254 }
20255
20256
20257 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20258 PyObject *resultobj = 0;
20259 wxPyArtProvider *result = 0 ;
20260
20261 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20262 {
20263 if (!wxPyCheckForApp()) SWIG_fail;
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (wxPyArtProvider *)new wxPyArtProvider();
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *resultobj = 0;
20278 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20279 void *argp1 = 0 ;
20280 int res1 = 0 ;
20281 PyObject *swig_obj[1] ;
20282
20283 if (!args) SWIG_fail;
20284 swig_obj[0] = args;
20285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20286 if (!SWIG_IsOK(res1)) {
20287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20288 }
20289 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20290 {
20291 PyThreadState* __tstate = wxPyBeginAllowThreads();
20292 delete arg1;
20293
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 resultobj = SWIG_Py_Void();
20298 return resultobj;
20299 fail:
20300 return NULL;
20301 }
20302
20303
20304 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20305 PyObject *resultobj = 0;
20306 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20307 PyObject *arg2 = (PyObject *) 0 ;
20308 PyObject *arg3 = (PyObject *) 0 ;
20309 void *argp1 = 0 ;
20310 int res1 = 0 ;
20311 PyObject * obj0 = 0 ;
20312 PyObject * obj1 = 0 ;
20313 PyObject * obj2 = 0 ;
20314 char * kwnames[] = {
20315 (char *) "self",(char *) "self",(char *) "_class", NULL
20316 };
20317
20318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20320 if (!SWIG_IsOK(res1)) {
20321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20322 }
20323 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20324 arg2 = obj1;
20325 arg3 = obj2;
20326 {
20327 PyThreadState* __tstate = wxPyBeginAllowThreads();
20328 (arg1)->_setCallbackInfo(arg2,arg3);
20329 wxPyEndAllowThreads(__tstate);
20330 if (PyErr_Occurred()) SWIG_fail;
20331 }
20332 resultobj = SWIG_Py_Void();
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj = 0;
20341 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20342 int res1 = 0 ;
20343 PyObject * obj0 = 0 ;
20344 char * kwnames[] = {
20345 (char *) "provider", NULL
20346 };
20347
20348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
20349 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20350 if (!SWIG_IsOK(res1)) {
20351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20352 }
20353 {
20354 PyThreadState* __tstate = wxPyBeginAllowThreads();
20355 wxPyArtProvider::PushProvider(arg1);
20356 wxPyEndAllowThreads(__tstate);
20357 if (PyErr_Occurred()) SWIG_fail;
20358 }
20359 resultobj = SWIG_Py_Void();
20360 return resultobj;
20361 fail:
20362 return NULL;
20363 }
20364
20365
20366 SWIGINTERN PyObject *_wrap_ArtProvider_InsertProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20367 PyObject *resultobj = 0;
20368 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20369 int res1 = 0 ;
20370 PyObject * obj0 = 0 ;
20371 char * kwnames[] = {
20372 (char *) "provider", NULL
20373 };
20374
20375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_InsertProvider",kwnames,&obj0)) SWIG_fail;
20376 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20377 if (!SWIG_IsOK(res1)) {
20378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_InsertProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20379 }
20380 {
20381 PyThreadState* __tstate = wxPyBeginAllowThreads();
20382 wxPyArtProvider::InsertProvider(arg1);
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 resultobj = SWIG_Py_Void();
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20394 PyObject *resultobj = 0;
20395 bool result;
20396
20397 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 result = (bool)wxPyArtProvider::PopProvider();
20401 wxPyEndAllowThreads(__tstate);
20402 if (PyErr_Occurred()) SWIG_fail;
20403 }
20404 {
20405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20406 }
20407 return resultobj;
20408 fail:
20409 return NULL;
20410 }
20411
20412
20413 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20414 PyObject *resultobj = 0;
20415 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20416 bool result;
20417 void *argp1 = 0 ;
20418 int res1 = 0 ;
20419 PyObject * obj0 = 0 ;
20420 char * kwnames[] = {
20421 (char *) "provider", NULL
20422 };
20423
20424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
20425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20426 if (!SWIG_IsOK(res1)) {
20427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20428 }
20429 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 {
20437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20438 }
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20446 PyObject *resultobj = 0;
20447 wxString *arg1 = 0 ;
20448 wxString const &arg2_defvalue = wxPyART_OTHER ;
20449 wxString *arg2 = (wxString *) &arg2_defvalue ;
20450 wxSize const &arg3_defvalue = wxDefaultSize ;
20451 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20452 wxBitmap result;
20453 bool temp1 = false ;
20454 bool temp2 = false ;
20455 wxSize temp3 ;
20456 PyObject * obj0 = 0 ;
20457 PyObject * obj1 = 0 ;
20458 PyObject * obj2 = 0 ;
20459 char * kwnames[] = {
20460 (char *) "id",(char *) "client",(char *) "size", NULL
20461 };
20462
20463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20464 {
20465 arg1 = wxString_in_helper(obj0);
20466 if (arg1 == NULL) SWIG_fail;
20467 temp1 = true;
20468 }
20469 if (obj1) {
20470 {
20471 arg2 = wxString_in_helper(obj1);
20472 if (arg2 == NULL) SWIG_fail;
20473 temp2 = true;
20474 }
20475 }
20476 if (obj2) {
20477 {
20478 arg3 = &temp3;
20479 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20480 }
20481 }
20482 {
20483 if (!wxPyCheckForApp()) SWIG_fail;
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20486 wxPyEndAllowThreads(__tstate);
20487 if (PyErr_Occurred()) SWIG_fail;
20488 }
20489 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20490 {
20491 if (temp1)
20492 delete arg1;
20493 }
20494 {
20495 if (temp2)
20496 delete arg2;
20497 }
20498 return resultobj;
20499 fail:
20500 {
20501 if (temp1)
20502 delete arg1;
20503 }
20504 {
20505 if (temp2)
20506 delete arg2;
20507 }
20508 return NULL;
20509 }
20510
20511
20512 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20513 PyObject *resultobj = 0;
20514 wxString *arg1 = 0 ;
20515 wxString const &arg2_defvalue = wxPyART_OTHER ;
20516 wxString *arg2 = (wxString *) &arg2_defvalue ;
20517 wxSize const &arg3_defvalue = wxDefaultSize ;
20518 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20519 wxIcon result;
20520 bool temp1 = false ;
20521 bool temp2 = false ;
20522 wxSize temp3 ;
20523 PyObject * obj0 = 0 ;
20524 PyObject * obj1 = 0 ;
20525 PyObject * obj2 = 0 ;
20526 char * kwnames[] = {
20527 (char *) "id",(char *) "client",(char *) "size", NULL
20528 };
20529
20530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20531 {
20532 arg1 = wxString_in_helper(obj0);
20533 if (arg1 == NULL) SWIG_fail;
20534 temp1 = true;
20535 }
20536 if (obj1) {
20537 {
20538 arg2 = wxString_in_helper(obj1);
20539 if (arg2 == NULL) SWIG_fail;
20540 temp2 = true;
20541 }
20542 }
20543 if (obj2) {
20544 {
20545 arg3 = &temp3;
20546 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20547 }
20548 }
20549 {
20550 if (!wxPyCheckForApp()) SWIG_fail;
20551 PyThreadState* __tstate = wxPyBeginAllowThreads();
20552 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20557 {
20558 if (temp1)
20559 delete arg1;
20560 }
20561 {
20562 if (temp2)
20563 delete arg2;
20564 }
20565 return resultobj;
20566 fail:
20567 {
20568 if (temp1)
20569 delete arg1;
20570 }
20571 {
20572 if (temp2)
20573 delete arg2;
20574 }
20575 return NULL;
20576 }
20577
20578
20579 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20580 PyObject *resultobj = 0;
20581 wxString *arg1 = 0 ;
20582 bool arg2 = (bool) false ;
20583 wxSize result;
20584 bool temp1 = false ;
20585 bool val2 ;
20586 int ecode2 = 0 ;
20587 PyObject * obj0 = 0 ;
20588 PyObject * obj1 = 0 ;
20589 char * kwnames[] = {
20590 (char *) "client",(char *) "platform_dependent", NULL
20591 };
20592
20593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20594 {
20595 arg1 = wxString_in_helper(obj0);
20596 if (arg1 == NULL) SWIG_fail;
20597 temp1 = true;
20598 }
20599 if (obj1) {
20600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20601 if (!SWIG_IsOK(ecode2)) {
20602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20603 }
20604 arg2 = static_cast< bool >(val2);
20605 }
20606 {
20607 PyThreadState* __tstate = wxPyBeginAllowThreads();
20608 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20609 wxPyEndAllowThreads(__tstate);
20610 if (PyErr_Occurred()) SWIG_fail;
20611 }
20612 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20613 {
20614 if (temp1)
20615 delete arg1;
20616 }
20617 return resultobj;
20618 fail:
20619 {
20620 if (temp1)
20621 delete arg1;
20622 }
20623 return NULL;
20624 }
20625
20626
20627 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20628 PyObject *resultobj = 0;
20629 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20630 void *argp1 = 0 ;
20631 int res1 = 0 ;
20632 PyObject *swig_obj[1] ;
20633
20634 if (!args) SWIG_fail;
20635 swig_obj[0] = args;
20636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20637 if (!SWIG_IsOK(res1)) {
20638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20639 }
20640 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20641 {
20642 PyThreadState* __tstate = wxPyBeginAllowThreads();
20643 wxPyArtProvider_Destroy(arg1);
20644 wxPyEndAllowThreads(__tstate);
20645 if (PyErr_Occurred()) SWIG_fail;
20646 }
20647 resultobj = SWIG_Py_Void();
20648 return resultobj;
20649 fail:
20650 return NULL;
20651 }
20652
20653
20654 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20655 PyObject *obj;
20656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20657 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20658 return SWIG_Py_Void();
20659 }
20660
20661 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20662 return SWIG_Python_InitShadowInstance(args);
20663 }
20664
20665 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20666 PyObject *resultobj = 0;
20667 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20668 void *argp1 = 0 ;
20669 int res1 = 0 ;
20670 PyObject *swig_obj[1] ;
20671
20672 if (!args) SWIG_fail;
20673 swig_obj[0] = args;
20674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20675 if (!SWIG_IsOK(res1)) {
20676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20677 }
20678 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20679 {
20680 PyThreadState* __tstate = wxPyBeginAllowThreads();
20681 delete arg1;
20682
20683 wxPyEndAllowThreads(__tstate);
20684 if (PyErr_Occurred()) SWIG_fail;
20685 }
20686 resultobj = SWIG_Py_Void();
20687 return resultobj;
20688 fail:
20689 return NULL;
20690 }
20691
20692
20693 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20694 PyObject *resultobj = 0;
20695 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20696 wxConfigBase *result = 0 ;
20697 int res1 = 0 ;
20698 PyObject * obj0 = 0 ;
20699 char * kwnames[] = {
20700 (char *) "config", NULL
20701 };
20702
20703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20704 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20705 if (!SWIG_IsOK(res1)) {
20706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20707 }
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20711 wxPyEndAllowThreads(__tstate);
20712 if (PyErr_Occurred()) SWIG_fail;
20713 }
20714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20715 return resultobj;
20716 fail:
20717 return NULL;
20718 }
20719
20720
20721 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20722 PyObject *resultobj = 0;
20723 bool arg1 = (bool) true ;
20724 wxConfigBase *result = 0 ;
20725 bool val1 ;
20726 int ecode1 = 0 ;
20727 PyObject * obj0 = 0 ;
20728 char * kwnames[] = {
20729 (char *) "createOnDemand", NULL
20730 };
20731
20732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20733 if (obj0) {
20734 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20735 if (!SWIG_IsOK(ecode1)) {
20736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20737 }
20738 arg1 = static_cast< bool >(val1);
20739 }
20740 {
20741 PyThreadState* __tstate = wxPyBeginAllowThreads();
20742 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20743 wxPyEndAllowThreads(__tstate);
20744 if (PyErr_Occurred()) SWIG_fail;
20745 }
20746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20747 return resultobj;
20748 fail:
20749 return NULL;
20750 }
20751
20752
20753 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20754 PyObject *resultobj = 0;
20755 wxConfigBase *result = 0 ;
20756
20757 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20758 {
20759 PyThreadState* __tstate = wxPyBeginAllowThreads();
20760 result = (wxConfigBase *)wxConfigBase::Create();
20761 wxPyEndAllowThreads(__tstate);
20762 if (PyErr_Occurred()) SWIG_fail;
20763 }
20764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20765 return resultobj;
20766 fail:
20767 return NULL;
20768 }
20769
20770
20771 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20772 PyObject *resultobj = 0;
20773
20774 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 wxConfigBase::DontCreateOnDemand();
20778 wxPyEndAllowThreads(__tstate);
20779 if (PyErr_Occurred()) SWIG_fail;
20780 }
20781 resultobj = SWIG_Py_Void();
20782 return resultobj;
20783 fail:
20784 return NULL;
20785 }
20786
20787
20788 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20789 PyObject *resultobj = 0;
20790 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20791 wxString *arg2 = 0 ;
20792 void *argp1 = 0 ;
20793 int res1 = 0 ;
20794 bool temp2 = false ;
20795 PyObject * obj0 = 0 ;
20796 PyObject * obj1 = 0 ;
20797 char * kwnames[] = {
20798 (char *) "self",(char *) "path", NULL
20799 };
20800
20801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20803 if (!SWIG_IsOK(res1)) {
20804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20805 }
20806 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20807 {
20808 arg2 = wxString_in_helper(obj1);
20809 if (arg2 == NULL) SWIG_fail;
20810 temp2 = true;
20811 }
20812 {
20813 PyThreadState* __tstate = wxPyBeginAllowThreads();
20814 (arg1)->SetPath((wxString const &)*arg2);
20815 wxPyEndAllowThreads(__tstate);
20816 if (PyErr_Occurred()) SWIG_fail;
20817 }
20818 resultobj = SWIG_Py_Void();
20819 {
20820 if (temp2)
20821 delete arg2;
20822 }
20823 return resultobj;
20824 fail:
20825 {
20826 if (temp2)
20827 delete arg2;
20828 }
20829 return NULL;
20830 }
20831
20832
20833 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20834 PyObject *resultobj = 0;
20835 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20836 wxString *result = 0 ;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 PyObject *swig_obj[1] ;
20840
20841 if (!args) SWIG_fail;
20842 swig_obj[0] = args;
20843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20844 if (!SWIG_IsOK(res1)) {
20845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20846 }
20847 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 {
20851 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20852 result = (wxString *) &_result_ref;
20853 }
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 #if wxUSE_UNICODE
20859 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20860 #else
20861 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20862 #endif
20863 }
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20871 PyObject *resultobj = 0;
20872 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20873 PyObject *result = 0 ;
20874 void *argp1 = 0 ;
20875 int res1 = 0 ;
20876 PyObject *swig_obj[1] ;
20877
20878 if (!args) SWIG_fail;
20879 swig_obj[0] = args;
20880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20881 if (!SWIG_IsOK(res1)) {
20882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20883 }
20884 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20885 {
20886 PyThreadState* __tstate = wxPyBeginAllowThreads();
20887 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20888 wxPyEndAllowThreads(__tstate);
20889 if (PyErr_Occurred()) SWIG_fail;
20890 }
20891 resultobj = result;
20892 return resultobj;
20893 fail:
20894 return NULL;
20895 }
20896
20897
20898 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20899 PyObject *resultobj = 0;
20900 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20901 long arg2 ;
20902 PyObject *result = 0 ;
20903 void *argp1 = 0 ;
20904 int res1 = 0 ;
20905 long val2 ;
20906 int ecode2 = 0 ;
20907 PyObject * obj0 = 0 ;
20908 PyObject * obj1 = 0 ;
20909 char * kwnames[] = {
20910 (char *) "self",(char *) "index", NULL
20911 };
20912
20913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20915 if (!SWIG_IsOK(res1)) {
20916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20917 }
20918 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20919 ecode2 = SWIG_AsVal_long(obj1, &val2);
20920 if (!SWIG_IsOK(ecode2)) {
20921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
20922 }
20923 arg2 = static_cast< long >(val2);
20924 {
20925 PyThreadState* __tstate = wxPyBeginAllowThreads();
20926 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
20927 wxPyEndAllowThreads(__tstate);
20928 if (PyErr_Occurred()) SWIG_fail;
20929 }
20930 resultobj = result;
20931 return resultobj;
20932 fail:
20933 return NULL;
20934 }
20935
20936
20937 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20938 PyObject *resultobj = 0;
20939 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20940 PyObject *result = 0 ;
20941 void *argp1 = 0 ;
20942 int res1 = 0 ;
20943 PyObject *swig_obj[1] ;
20944
20945 if (!args) SWIG_fail;
20946 swig_obj[0] = args;
20947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20948 if (!SWIG_IsOK(res1)) {
20949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20950 }
20951 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
20955 wxPyEndAllowThreads(__tstate);
20956 if (PyErr_Occurred()) SWIG_fail;
20957 }
20958 resultobj = result;
20959 return resultobj;
20960 fail:
20961 return NULL;
20962 }
20963
20964
20965 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20966 PyObject *resultobj = 0;
20967 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20968 long arg2 ;
20969 PyObject *result = 0 ;
20970 void *argp1 = 0 ;
20971 int res1 = 0 ;
20972 long val2 ;
20973 int ecode2 = 0 ;
20974 PyObject * obj0 = 0 ;
20975 PyObject * obj1 = 0 ;
20976 char * kwnames[] = {
20977 (char *) "self",(char *) "index", NULL
20978 };
20979
20980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20982 if (!SWIG_IsOK(res1)) {
20983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20984 }
20985 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20986 ecode2 = SWIG_AsVal_long(obj1, &val2);
20987 if (!SWIG_IsOK(ecode2)) {
20988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20989 }
20990 arg2 = static_cast< long >(val2);
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20994 wxPyEndAllowThreads(__tstate);
20995 if (PyErr_Occurred()) SWIG_fail;
20996 }
20997 resultobj = result;
20998 return resultobj;
20999 fail:
21000 return NULL;
21001 }
21002
21003
21004 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21005 PyObject *resultobj = 0;
21006 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21007 bool arg2 = (bool) false ;
21008 size_t result;
21009 void *argp1 = 0 ;
21010 int res1 = 0 ;
21011 bool val2 ;
21012 int ecode2 = 0 ;
21013 PyObject * obj0 = 0 ;
21014 PyObject * obj1 = 0 ;
21015 char * kwnames[] = {
21016 (char *) "self",(char *) "recursive", NULL
21017 };
21018
21019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21021 if (!SWIG_IsOK(res1)) {
21022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21023 }
21024 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21025 if (obj1) {
21026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21027 if (!SWIG_IsOK(ecode2)) {
21028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21029 }
21030 arg2 = static_cast< bool >(val2);
21031 }
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21046 PyObject *resultobj = 0;
21047 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21048 bool arg2 = (bool) false ;
21049 size_t result;
21050 void *argp1 = 0 ;
21051 int res1 = 0 ;
21052 bool val2 ;
21053 int ecode2 = 0 ;
21054 PyObject * obj0 = 0 ;
21055 PyObject * obj1 = 0 ;
21056 char * kwnames[] = {
21057 (char *) "self",(char *) "recursive", NULL
21058 };
21059
21060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21062 if (!SWIG_IsOK(res1)) {
21063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21064 }
21065 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21066 if (obj1) {
21067 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21068 if (!SWIG_IsOK(ecode2)) {
21069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21070 }
21071 arg2 = static_cast< bool >(val2);
21072 }
21073 {
21074 PyThreadState* __tstate = wxPyBeginAllowThreads();
21075 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj = 0;
21088 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21089 wxString *arg2 = 0 ;
21090 bool result;
21091 void *argp1 = 0 ;
21092 int res1 = 0 ;
21093 bool temp2 = false ;
21094 PyObject * obj0 = 0 ;
21095 PyObject * obj1 = 0 ;
21096 char * kwnames[] = {
21097 (char *) "self",(char *) "name", NULL
21098 };
21099
21100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21102 if (!SWIG_IsOK(res1)) {
21103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21104 }
21105 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21106 {
21107 arg2 = wxString_in_helper(obj1);
21108 if (arg2 == NULL) SWIG_fail;
21109 temp2 = true;
21110 }
21111 {
21112 PyThreadState* __tstate = wxPyBeginAllowThreads();
21113 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21114 wxPyEndAllowThreads(__tstate);
21115 if (PyErr_Occurred()) SWIG_fail;
21116 }
21117 {
21118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21119 }
21120 {
21121 if (temp2)
21122 delete arg2;
21123 }
21124 return resultobj;
21125 fail:
21126 {
21127 if (temp2)
21128 delete arg2;
21129 }
21130 return NULL;
21131 }
21132
21133
21134 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21135 PyObject *resultobj = 0;
21136 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21137 wxString *arg2 = 0 ;
21138 bool result;
21139 void *argp1 = 0 ;
21140 int res1 = 0 ;
21141 bool temp2 = false ;
21142 PyObject * obj0 = 0 ;
21143 PyObject * obj1 = 0 ;
21144 char * kwnames[] = {
21145 (char *) "self",(char *) "name", NULL
21146 };
21147
21148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21150 if (!SWIG_IsOK(res1)) {
21151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21152 }
21153 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21154 {
21155 arg2 = wxString_in_helper(obj1);
21156 if (arg2 == NULL) SWIG_fail;
21157 temp2 = true;
21158 }
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21162 wxPyEndAllowThreads(__tstate);
21163 if (PyErr_Occurred()) SWIG_fail;
21164 }
21165 {
21166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21167 }
21168 {
21169 if (temp2)
21170 delete arg2;
21171 }
21172 return resultobj;
21173 fail:
21174 {
21175 if (temp2)
21176 delete arg2;
21177 }
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21183 PyObject *resultobj = 0;
21184 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21185 wxString *arg2 = 0 ;
21186 bool result;
21187 void *argp1 = 0 ;
21188 int res1 = 0 ;
21189 bool temp2 = false ;
21190 PyObject * obj0 = 0 ;
21191 PyObject * obj1 = 0 ;
21192 char * kwnames[] = {
21193 (char *) "self",(char *) "name", NULL
21194 };
21195
21196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21200 }
21201 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21202 {
21203 arg2 = wxString_in_helper(obj1);
21204 if (arg2 == NULL) SWIG_fail;
21205 temp2 = true;
21206 }
21207 {
21208 PyThreadState* __tstate = wxPyBeginAllowThreads();
21209 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21210 wxPyEndAllowThreads(__tstate);
21211 if (PyErr_Occurred()) SWIG_fail;
21212 }
21213 {
21214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21215 }
21216 {
21217 if (temp2)
21218 delete arg2;
21219 }
21220 return resultobj;
21221 fail:
21222 {
21223 if (temp2)
21224 delete arg2;
21225 }
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj = 0;
21232 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21233 wxString *arg2 = 0 ;
21234 wxConfigBase::EntryType result;
21235 void *argp1 = 0 ;
21236 int res1 = 0 ;
21237 bool temp2 = false ;
21238 PyObject * obj0 = 0 ;
21239 PyObject * obj1 = 0 ;
21240 char * kwnames[] = {
21241 (char *) "self",(char *) "name", NULL
21242 };
21243
21244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21246 if (!SWIG_IsOK(res1)) {
21247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21248 }
21249 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21250 {
21251 arg2 = wxString_in_helper(obj1);
21252 if (arg2 == NULL) SWIG_fail;
21253 temp2 = true;
21254 }
21255 {
21256 PyThreadState* __tstate = wxPyBeginAllowThreads();
21257 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21258 wxPyEndAllowThreads(__tstate);
21259 if (PyErr_Occurred()) SWIG_fail;
21260 }
21261 resultobj = SWIG_From_int(static_cast< int >(result));
21262 {
21263 if (temp2)
21264 delete arg2;
21265 }
21266 return resultobj;
21267 fail:
21268 {
21269 if (temp2)
21270 delete arg2;
21271 }
21272 return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21277 PyObject *resultobj = 0;
21278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21279 wxString *arg2 = 0 ;
21280 wxString const &arg3_defvalue = wxPyEmptyString ;
21281 wxString *arg3 = (wxString *) &arg3_defvalue ;
21282 wxString result;
21283 void *argp1 = 0 ;
21284 int res1 = 0 ;
21285 bool temp2 = false ;
21286 bool temp3 = false ;
21287 PyObject * obj0 = 0 ;
21288 PyObject * obj1 = 0 ;
21289 PyObject * obj2 = 0 ;
21290 char * kwnames[] = {
21291 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21292 };
21293
21294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21296 if (!SWIG_IsOK(res1)) {
21297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21298 }
21299 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21300 {
21301 arg2 = wxString_in_helper(obj1);
21302 if (arg2 == NULL) SWIG_fail;
21303 temp2 = true;
21304 }
21305 if (obj2) {
21306 {
21307 arg3 = wxString_in_helper(obj2);
21308 if (arg3 == NULL) SWIG_fail;
21309 temp3 = true;
21310 }
21311 }
21312 {
21313 PyThreadState* __tstate = wxPyBeginAllowThreads();
21314 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21315 wxPyEndAllowThreads(__tstate);
21316 if (PyErr_Occurred()) SWIG_fail;
21317 }
21318 {
21319 #if wxUSE_UNICODE
21320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21321 #else
21322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21323 #endif
21324 }
21325 {
21326 if (temp2)
21327 delete arg2;
21328 }
21329 {
21330 if (temp3)
21331 delete arg3;
21332 }
21333 return resultobj;
21334 fail:
21335 {
21336 if (temp2)
21337 delete arg2;
21338 }
21339 {
21340 if (temp3)
21341 delete arg3;
21342 }
21343 return NULL;
21344 }
21345
21346
21347 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21348 PyObject *resultobj = 0;
21349 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21350 wxString *arg2 = 0 ;
21351 long arg3 = (long) 0 ;
21352 long result;
21353 void *argp1 = 0 ;
21354 int res1 = 0 ;
21355 bool temp2 = false ;
21356 long val3 ;
21357 int ecode3 = 0 ;
21358 PyObject * obj0 = 0 ;
21359 PyObject * obj1 = 0 ;
21360 PyObject * obj2 = 0 ;
21361 char * kwnames[] = {
21362 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21363 };
21364
21365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21367 if (!SWIG_IsOK(res1)) {
21368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21369 }
21370 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21371 {
21372 arg2 = wxString_in_helper(obj1);
21373 if (arg2 == NULL) SWIG_fail;
21374 temp2 = true;
21375 }
21376 if (obj2) {
21377 ecode3 = SWIG_AsVal_long(obj2, &val3);
21378 if (!SWIG_IsOK(ecode3)) {
21379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21380 }
21381 arg3 = static_cast< long >(val3);
21382 }
21383 {
21384 PyThreadState* __tstate = wxPyBeginAllowThreads();
21385 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 resultobj = SWIG_From_long(static_cast< long >(result));
21390 {
21391 if (temp2)
21392 delete arg2;
21393 }
21394 return resultobj;
21395 fail:
21396 {
21397 if (temp2)
21398 delete arg2;
21399 }
21400 return NULL;
21401 }
21402
21403
21404 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21405 PyObject *resultobj = 0;
21406 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21407 wxString *arg2 = 0 ;
21408 double arg3 = (double) 0.0 ;
21409 double result;
21410 void *argp1 = 0 ;
21411 int res1 = 0 ;
21412 bool temp2 = false ;
21413 double val3 ;
21414 int ecode3 = 0 ;
21415 PyObject * obj0 = 0 ;
21416 PyObject * obj1 = 0 ;
21417 PyObject * obj2 = 0 ;
21418 char * kwnames[] = {
21419 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21420 };
21421
21422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21424 if (!SWIG_IsOK(res1)) {
21425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21426 }
21427 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21428 {
21429 arg2 = wxString_in_helper(obj1);
21430 if (arg2 == NULL) SWIG_fail;
21431 temp2 = true;
21432 }
21433 if (obj2) {
21434 ecode3 = SWIG_AsVal_double(obj2, &val3);
21435 if (!SWIG_IsOK(ecode3)) {
21436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21437 }
21438 arg3 = static_cast< double >(val3);
21439 }
21440 {
21441 PyThreadState* __tstate = wxPyBeginAllowThreads();
21442 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21443 wxPyEndAllowThreads(__tstate);
21444 if (PyErr_Occurred()) SWIG_fail;
21445 }
21446 resultobj = SWIG_From_double(static_cast< double >(result));
21447 {
21448 if (temp2)
21449 delete arg2;
21450 }
21451 return resultobj;
21452 fail:
21453 {
21454 if (temp2)
21455 delete arg2;
21456 }
21457 return NULL;
21458 }
21459
21460
21461 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21462 PyObject *resultobj = 0;
21463 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21464 wxString *arg2 = 0 ;
21465 bool arg3 = (bool) false ;
21466 bool result;
21467 void *argp1 = 0 ;
21468 int res1 = 0 ;
21469 bool temp2 = false ;
21470 bool val3 ;
21471 int ecode3 = 0 ;
21472 PyObject * obj0 = 0 ;
21473 PyObject * obj1 = 0 ;
21474 PyObject * obj2 = 0 ;
21475 char * kwnames[] = {
21476 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21477 };
21478
21479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21481 if (!SWIG_IsOK(res1)) {
21482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21483 }
21484 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21485 {
21486 arg2 = wxString_in_helper(obj1);
21487 if (arg2 == NULL) SWIG_fail;
21488 temp2 = true;
21489 }
21490 if (obj2) {
21491 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21492 if (!SWIG_IsOK(ecode3)) {
21493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21494 }
21495 arg3 = static_cast< bool >(val3);
21496 }
21497 {
21498 PyThreadState* __tstate = wxPyBeginAllowThreads();
21499 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 {
21504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21505 }
21506 {
21507 if (temp2)
21508 delete arg2;
21509 }
21510 return resultobj;
21511 fail:
21512 {
21513 if (temp2)
21514 delete arg2;
21515 }
21516 return NULL;
21517 }
21518
21519
21520 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21521 PyObject *resultobj = 0;
21522 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21523 wxString *arg2 = 0 ;
21524 wxString *arg3 = 0 ;
21525 bool result;
21526 void *argp1 = 0 ;
21527 int res1 = 0 ;
21528 bool temp2 = false ;
21529 bool temp3 = false ;
21530 PyObject * obj0 = 0 ;
21531 PyObject * obj1 = 0 ;
21532 PyObject * obj2 = 0 ;
21533 char * kwnames[] = {
21534 (char *) "self",(char *) "key",(char *) "value", NULL
21535 };
21536
21537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21539 if (!SWIG_IsOK(res1)) {
21540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21541 }
21542 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21543 {
21544 arg2 = wxString_in_helper(obj1);
21545 if (arg2 == NULL) SWIG_fail;
21546 temp2 = true;
21547 }
21548 {
21549 arg3 = wxString_in_helper(obj2);
21550 if (arg3 == NULL) SWIG_fail;
21551 temp3 = true;
21552 }
21553 {
21554 PyThreadState* __tstate = wxPyBeginAllowThreads();
21555 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21556 wxPyEndAllowThreads(__tstate);
21557 if (PyErr_Occurred()) SWIG_fail;
21558 }
21559 {
21560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21561 }
21562 {
21563 if (temp2)
21564 delete arg2;
21565 }
21566 {
21567 if (temp3)
21568 delete arg3;
21569 }
21570 return resultobj;
21571 fail:
21572 {
21573 if (temp2)
21574 delete arg2;
21575 }
21576 {
21577 if (temp3)
21578 delete arg3;
21579 }
21580 return NULL;
21581 }
21582
21583
21584 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21585 PyObject *resultobj = 0;
21586 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21587 wxString *arg2 = 0 ;
21588 long arg3 ;
21589 bool result;
21590 void *argp1 = 0 ;
21591 int res1 = 0 ;
21592 bool temp2 = false ;
21593 long val3 ;
21594 int ecode3 = 0 ;
21595 PyObject * obj0 = 0 ;
21596 PyObject * obj1 = 0 ;
21597 PyObject * obj2 = 0 ;
21598 char * kwnames[] = {
21599 (char *) "self",(char *) "key",(char *) "value", NULL
21600 };
21601
21602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21604 if (!SWIG_IsOK(res1)) {
21605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21606 }
21607 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21608 {
21609 arg2 = wxString_in_helper(obj1);
21610 if (arg2 == NULL) SWIG_fail;
21611 temp2 = true;
21612 }
21613 ecode3 = SWIG_AsVal_long(obj2, &val3);
21614 if (!SWIG_IsOK(ecode3)) {
21615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21616 }
21617 arg3 = static_cast< long >(val3);
21618 {
21619 PyThreadState* __tstate = wxPyBeginAllowThreads();
21620 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21621 wxPyEndAllowThreads(__tstate);
21622 if (PyErr_Occurred()) SWIG_fail;
21623 }
21624 {
21625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21626 }
21627 {
21628 if (temp2)
21629 delete arg2;
21630 }
21631 return resultobj;
21632 fail:
21633 {
21634 if (temp2)
21635 delete arg2;
21636 }
21637 return NULL;
21638 }
21639
21640
21641 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21642 PyObject *resultobj = 0;
21643 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21644 wxString *arg2 = 0 ;
21645 double arg3 ;
21646 bool result;
21647 void *argp1 = 0 ;
21648 int res1 = 0 ;
21649 bool temp2 = false ;
21650 double val3 ;
21651 int ecode3 = 0 ;
21652 PyObject * obj0 = 0 ;
21653 PyObject * obj1 = 0 ;
21654 PyObject * obj2 = 0 ;
21655 char * kwnames[] = {
21656 (char *) "self",(char *) "key",(char *) "value", NULL
21657 };
21658
21659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21661 if (!SWIG_IsOK(res1)) {
21662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21663 }
21664 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21665 {
21666 arg2 = wxString_in_helper(obj1);
21667 if (arg2 == NULL) SWIG_fail;
21668 temp2 = true;
21669 }
21670 ecode3 = SWIG_AsVal_double(obj2, &val3);
21671 if (!SWIG_IsOK(ecode3)) {
21672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21673 }
21674 arg3 = static_cast< double >(val3);
21675 {
21676 PyThreadState* __tstate = wxPyBeginAllowThreads();
21677 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21678 wxPyEndAllowThreads(__tstate);
21679 if (PyErr_Occurred()) SWIG_fail;
21680 }
21681 {
21682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21683 }
21684 {
21685 if (temp2)
21686 delete arg2;
21687 }
21688 return resultobj;
21689 fail:
21690 {
21691 if (temp2)
21692 delete arg2;
21693 }
21694 return NULL;
21695 }
21696
21697
21698 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21699 PyObject *resultobj = 0;
21700 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21701 wxString *arg2 = 0 ;
21702 bool arg3 ;
21703 bool result;
21704 void *argp1 = 0 ;
21705 int res1 = 0 ;
21706 bool temp2 = false ;
21707 bool val3 ;
21708 int ecode3 = 0 ;
21709 PyObject * obj0 = 0 ;
21710 PyObject * obj1 = 0 ;
21711 PyObject * obj2 = 0 ;
21712 char * kwnames[] = {
21713 (char *) "self",(char *) "key",(char *) "value", NULL
21714 };
21715
21716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21718 if (!SWIG_IsOK(res1)) {
21719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21720 }
21721 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21722 {
21723 arg2 = wxString_in_helper(obj1);
21724 if (arg2 == NULL) SWIG_fail;
21725 temp2 = true;
21726 }
21727 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21728 if (!SWIG_IsOK(ecode3)) {
21729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21730 }
21731 arg3 = static_cast< bool >(val3);
21732 {
21733 PyThreadState* __tstate = wxPyBeginAllowThreads();
21734 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21735 wxPyEndAllowThreads(__tstate);
21736 if (PyErr_Occurred()) SWIG_fail;
21737 }
21738 {
21739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21740 }
21741 {
21742 if (temp2)
21743 delete arg2;
21744 }
21745 return resultobj;
21746 fail:
21747 {
21748 if (temp2)
21749 delete arg2;
21750 }
21751 return NULL;
21752 }
21753
21754
21755 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21756 PyObject *resultobj = 0;
21757 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21758 bool arg2 = (bool) false ;
21759 bool result;
21760 void *argp1 = 0 ;
21761 int res1 = 0 ;
21762 bool val2 ;
21763 int ecode2 = 0 ;
21764 PyObject * obj0 = 0 ;
21765 PyObject * obj1 = 0 ;
21766 char * kwnames[] = {
21767 (char *) "self",(char *) "currentOnly", NULL
21768 };
21769
21770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21772 if (!SWIG_IsOK(res1)) {
21773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21774 }
21775 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21776 if (obj1) {
21777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21778 if (!SWIG_IsOK(ecode2)) {
21779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21780 }
21781 arg2 = static_cast< bool >(val2);
21782 }
21783 {
21784 PyThreadState* __tstate = wxPyBeginAllowThreads();
21785 result = (bool)(arg1)->Flush(arg2);
21786 wxPyEndAllowThreads(__tstate);
21787 if (PyErr_Occurred()) SWIG_fail;
21788 }
21789 {
21790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21791 }
21792 return resultobj;
21793 fail:
21794 return NULL;
21795 }
21796
21797
21798 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21799 PyObject *resultobj = 0;
21800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21801 wxString *arg2 = 0 ;
21802 wxString *arg3 = 0 ;
21803 bool result;
21804 void *argp1 = 0 ;
21805 int res1 = 0 ;
21806 bool temp2 = false ;
21807 bool temp3 = false ;
21808 PyObject * obj0 = 0 ;
21809 PyObject * obj1 = 0 ;
21810 PyObject * obj2 = 0 ;
21811 char * kwnames[] = {
21812 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21813 };
21814
21815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21817 if (!SWIG_IsOK(res1)) {
21818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21819 }
21820 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21821 {
21822 arg2 = wxString_in_helper(obj1);
21823 if (arg2 == NULL) SWIG_fail;
21824 temp2 = true;
21825 }
21826 {
21827 arg3 = wxString_in_helper(obj2);
21828 if (arg3 == NULL) SWIG_fail;
21829 temp3 = true;
21830 }
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 {
21838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21839 }
21840 {
21841 if (temp2)
21842 delete arg2;
21843 }
21844 {
21845 if (temp3)
21846 delete arg3;
21847 }
21848 return resultobj;
21849 fail:
21850 {
21851 if (temp2)
21852 delete arg2;
21853 }
21854 {
21855 if (temp3)
21856 delete arg3;
21857 }
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21863 PyObject *resultobj = 0;
21864 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21865 wxString *arg2 = 0 ;
21866 wxString *arg3 = 0 ;
21867 bool result;
21868 void *argp1 = 0 ;
21869 int res1 = 0 ;
21870 bool temp2 = false ;
21871 bool temp3 = false ;
21872 PyObject * obj0 = 0 ;
21873 PyObject * obj1 = 0 ;
21874 PyObject * obj2 = 0 ;
21875 char * kwnames[] = {
21876 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21877 };
21878
21879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21881 if (!SWIG_IsOK(res1)) {
21882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21883 }
21884 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21885 {
21886 arg2 = wxString_in_helper(obj1);
21887 if (arg2 == NULL) SWIG_fail;
21888 temp2 = true;
21889 }
21890 {
21891 arg3 = wxString_in_helper(obj2);
21892 if (arg3 == NULL) SWIG_fail;
21893 temp3 = true;
21894 }
21895 {
21896 PyThreadState* __tstate = wxPyBeginAllowThreads();
21897 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21898 wxPyEndAllowThreads(__tstate);
21899 if (PyErr_Occurred()) SWIG_fail;
21900 }
21901 {
21902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21903 }
21904 {
21905 if (temp2)
21906 delete arg2;
21907 }
21908 {
21909 if (temp3)
21910 delete arg3;
21911 }
21912 return resultobj;
21913 fail:
21914 {
21915 if (temp2)
21916 delete arg2;
21917 }
21918 {
21919 if (temp3)
21920 delete arg3;
21921 }
21922 return NULL;
21923 }
21924
21925
21926 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21927 PyObject *resultobj = 0;
21928 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21929 wxString *arg2 = 0 ;
21930 bool arg3 = (bool) true ;
21931 bool result;
21932 void *argp1 = 0 ;
21933 int res1 = 0 ;
21934 bool temp2 = false ;
21935 bool val3 ;
21936 int ecode3 = 0 ;
21937 PyObject * obj0 = 0 ;
21938 PyObject * obj1 = 0 ;
21939 PyObject * obj2 = 0 ;
21940 char * kwnames[] = {
21941 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
21942 };
21943
21944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21946 if (!SWIG_IsOK(res1)) {
21947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21948 }
21949 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21950 {
21951 arg2 = wxString_in_helper(obj1);
21952 if (arg2 == NULL) SWIG_fail;
21953 temp2 = true;
21954 }
21955 if (obj2) {
21956 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21957 if (!SWIG_IsOK(ecode3)) {
21958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
21959 }
21960 arg3 = static_cast< bool >(val3);
21961 }
21962 {
21963 PyThreadState* __tstate = wxPyBeginAllowThreads();
21964 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 {
21969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21970 }
21971 {
21972 if (temp2)
21973 delete arg2;
21974 }
21975 return resultobj;
21976 fail:
21977 {
21978 if (temp2)
21979 delete arg2;
21980 }
21981 return NULL;
21982 }
21983
21984
21985 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21986 PyObject *resultobj = 0;
21987 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21988 wxString *arg2 = 0 ;
21989 bool result;
21990 void *argp1 = 0 ;
21991 int res1 = 0 ;
21992 bool temp2 = false ;
21993 PyObject * obj0 = 0 ;
21994 PyObject * obj1 = 0 ;
21995 char * kwnames[] = {
21996 (char *) "self",(char *) "key", NULL
21997 };
21998
21999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22001 if (!SWIG_IsOK(res1)) {
22002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22003 }
22004 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22005 {
22006 arg2 = wxString_in_helper(obj1);
22007 if (arg2 == NULL) SWIG_fail;
22008 temp2 = true;
22009 }
22010 {
22011 PyThreadState* __tstate = wxPyBeginAllowThreads();
22012 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 {
22017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22018 }
22019 {
22020 if (temp2)
22021 delete arg2;
22022 }
22023 return resultobj;
22024 fail:
22025 {
22026 if (temp2)
22027 delete arg2;
22028 }
22029 return NULL;
22030 }
22031
22032
22033 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22034 PyObject *resultobj = 0;
22035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22036 bool result;
22037 void *argp1 = 0 ;
22038 int res1 = 0 ;
22039 PyObject *swig_obj[1] ;
22040
22041 if (!args) SWIG_fail;
22042 swig_obj[0] = args;
22043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22044 if (!SWIG_IsOK(res1)) {
22045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22046 }
22047 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22048 {
22049 PyThreadState* __tstate = wxPyBeginAllowThreads();
22050 result = (bool)(arg1)->DeleteAll();
22051 wxPyEndAllowThreads(__tstate);
22052 if (PyErr_Occurred()) SWIG_fail;
22053 }
22054 {
22055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22056 }
22057 return resultobj;
22058 fail:
22059 return NULL;
22060 }
22061
22062
22063 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22064 PyObject *resultobj = 0;
22065 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22066 bool arg2 = (bool) true ;
22067 void *argp1 = 0 ;
22068 int res1 = 0 ;
22069 bool val2 ;
22070 int ecode2 = 0 ;
22071 PyObject * obj0 = 0 ;
22072 PyObject * obj1 = 0 ;
22073 char * kwnames[] = {
22074 (char *) "self",(char *) "doIt", NULL
22075 };
22076
22077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22079 if (!SWIG_IsOK(res1)) {
22080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22081 }
22082 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22083 if (obj1) {
22084 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22085 if (!SWIG_IsOK(ecode2)) {
22086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22087 }
22088 arg2 = static_cast< bool >(val2);
22089 }
22090 {
22091 PyThreadState* __tstate = wxPyBeginAllowThreads();
22092 (arg1)->SetExpandEnvVars(arg2);
22093 wxPyEndAllowThreads(__tstate);
22094 if (PyErr_Occurred()) SWIG_fail;
22095 }
22096 resultobj = SWIG_Py_Void();
22097 return resultobj;
22098 fail:
22099 return NULL;
22100 }
22101
22102
22103 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22104 PyObject *resultobj = 0;
22105 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22106 bool result;
22107 void *argp1 = 0 ;
22108 int res1 = 0 ;
22109 PyObject *swig_obj[1] ;
22110
22111 if (!args) SWIG_fail;
22112 swig_obj[0] = args;
22113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22114 if (!SWIG_IsOK(res1)) {
22115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22116 }
22117 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22118 {
22119 PyThreadState* __tstate = wxPyBeginAllowThreads();
22120 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22121 wxPyEndAllowThreads(__tstate);
22122 if (PyErr_Occurred()) SWIG_fail;
22123 }
22124 {
22125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22126 }
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22134 PyObject *resultobj = 0;
22135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22136 bool arg2 = (bool) true ;
22137 void *argp1 = 0 ;
22138 int res1 = 0 ;
22139 bool val2 ;
22140 int ecode2 = 0 ;
22141 PyObject * obj0 = 0 ;
22142 PyObject * obj1 = 0 ;
22143 char * kwnames[] = {
22144 (char *) "self",(char *) "doIt", NULL
22145 };
22146
22147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22149 if (!SWIG_IsOK(res1)) {
22150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22151 }
22152 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22153 if (obj1) {
22154 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22155 if (!SWIG_IsOK(ecode2)) {
22156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22157 }
22158 arg2 = static_cast< bool >(val2);
22159 }
22160 {
22161 PyThreadState* __tstate = wxPyBeginAllowThreads();
22162 (arg1)->SetRecordDefaults(arg2);
22163 wxPyEndAllowThreads(__tstate);
22164 if (PyErr_Occurred()) SWIG_fail;
22165 }
22166 resultobj = SWIG_Py_Void();
22167 return resultobj;
22168 fail:
22169 return NULL;
22170 }
22171
22172
22173 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22174 PyObject *resultobj = 0;
22175 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22176 bool result;
22177 void *argp1 = 0 ;
22178 int res1 = 0 ;
22179 PyObject *swig_obj[1] ;
22180
22181 if (!args) SWIG_fail;
22182 swig_obj[0] = args;
22183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22184 if (!SWIG_IsOK(res1)) {
22185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22186 }
22187 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22188 {
22189 PyThreadState* __tstate = wxPyBeginAllowThreads();
22190 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22191 wxPyEndAllowThreads(__tstate);
22192 if (PyErr_Occurred()) SWIG_fail;
22193 }
22194 {
22195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22196 }
22197 return resultobj;
22198 fail:
22199 return NULL;
22200 }
22201
22202
22203 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22204 PyObject *resultobj = 0;
22205 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22206 wxString *arg2 = 0 ;
22207 wxString result;
22208 void *argp1 = 0 ;
22209 int res1 = 0 ;
22210 bool temp2 = false ;
22211 PyObject * obj0 = 0 ;
22212 PyObject * obj1 = 0 ;
22213 char * kwnames[] = {
22214 (char *) "self",(char *) "str", NULL
22215 };
22216
22217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22219 if (!SWIG_IsOK(res1)) {
22220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22221 }
22222 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22223 {
22224 arg2 = wxString_in_helper(obj1);
22225 if (arg2 == NULL) SWIG_fail;
22226 temp2 = true;
22227 }
22228 {
22229 PyThreadState* __tstate = wxPyBeginAllowThreads();
22230 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22231 wxPyEndAllowThreads(__tstate);
22232 if (PyErr_Occurred()) SWIG_fail;
22233 }
22234 {
22235 #if wxUSE_UNICODE
22236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22237 #else
22238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22239 #endif
22240 }
22241 {
22242 if (temp2)
22243 delete arg2;
22244 }
22245 return resultobj;
22246 fail:
22247 {
22248 if (temp2)
22249 delete arg2;
22250 }
22251 return NULL;
22252 }
22253
22254
22255 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22256 PyObject *resultobj = 0;
22257 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22258 wxString result;
22259 void *argp1 = 0 ;
22260 int res1 = 0 ;
22261 PyObject *swig_obj[1] ;
22262
22263 if (!args) SWIG_fail;
22264 swig_obj[0] = args;
22265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22266 if (!SWIG_IsOK(res1)) {
22267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22268 }
22269 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22270 {
22271 PyThreadState* __tstate = wxPyBeginAllowThreads();
22272 result = ((wxConfigBase const *)arg1)->GetAppName();
22273 wxPyEndAllowThreads(__tstate);
22274 if (PyErr_Occurred()) SWIG_fail;
22275 }
22276 {
22277 #if wxUSE_UNICODE
22278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22279 #else
22280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22281 #endif
22282 }
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22290 PyObject *resultobj = 0;
22291 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22292 wxString result;
22293 void *argp1 = 0 ;
22294 int res1 = 0 ;
22295 PyObject *swig_obj[1] ;
22296
22297 if (!args) SWIG_fail;
22298 swig_obj[0] = args;
22299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22300 if (!SWIG_IsOK(res1)) {
22301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22302 }
22303 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22304 {
22305 PyThreadState* __tstate = wxPyBeginAllowThreads();
22306 result = ((wxConfigBase const *)arg1)->GetVendorName();
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 {
22311 #if wxUSE_UNICODE
22312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22313 #else
22314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22315 #endif
22316 }
22317 return resultobj;
22318 fail:
22319 return NULL;
22320 }
22321
22322
22323 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22324 PyObject *resultobj = 0;
22325 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22326 wxString *arg2 = 0 ;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 bool temp2 = false ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 char * kwnames[] = {
22333 (char *) "self",(char *) "appName", NULL
22334 };
22335
22336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22338 if (!SWIG_IsOK(res1)) {
22339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22340 }
22341 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22342 {
22343 arg2 = wxString_in_helper(obj1);
22344 if (arg2 == NULL) SWIG_fail;
22345 temp2 = true;
22346 }
22347 {
22348 PyThreadState* __tstate = wxPyBeginAllowThreads();
22349 (arg1)->SetAppName((wxString const &)*arg2);
22350 wxPyEndAllowThreads(__tstate);
22351 if (PyErr_Occurred()) SWIG_fail;
22352 }
22353 resultobj = SWIG_Py_Void();
22354 {
22355 if (temp2)
22356 delete arg2;
22357 }
22358 return resultobj;
22359 fail:
22360 {
22361 if (temp2)
22362 delete arg2;
22363 }
22364 return NULL;
22365 }
22366
22367
22368 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22369 PyObject *resultobj = 0;
22370 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22371 wxString *arg2 = 0 ;
22372 void *argp1 = 0 ;
22373 int res1 = 0 ;
22374 bool temp2 = false ;
22375 PyObject * obj0 = 0 ;
22376 PyObject * obj1 = 0 ;
22377 char * kwnames[] = {
22378 (char *) "self",(char *) "vendorName", NULL
22379 };
22380
22381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22383 if (!SWIG_IsOK(res1)) {
22384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22385 }
22386 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22387 {
22388 arg2 = wxString_in_helper(obj1);
22389 if (arg2 == NULL) SWIG_fail;
22390 temp2 = true;
22391 }
22392 {
22393 PyThreadState* __tstate = wxPyBeginAllowThreads();
22394 (arg1)->SetVendorName((wxString const &)*arg2);
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 resultobj = SWIG_Py_Void();
22399 {
22400 if (temp2)
22401 delete arg2;
22402 }
22403 return resultobj;
22404 fail:
22405 {
22406 if (temp2)
22407 delete arg2;
22408 }
22409 return NULL;
22410 }
22411
22412
22413 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22414 PyObject *resultobj = 0;
22415 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22416 long arg2 ;
22417 void *argp1 = 0 ;
22418 int res1 = 0 ;
22419 long val2 ;
22420 int ecode2 = 0 ;
22421 PyObject * obj0 = 0 ;
22422 PyObject * obj1 = 0 ;
22423 char * kwnames[] = {
22424 (char *) "self",(char *) "style", NULL
22425 };
22426
22427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22429 if (!SWIG_IsOK(res1)) {
22430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22431 }
22432 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22433 ecode2 = SWIG_AsVal_long(obj1, &val2);
22434 if (!SWIG_IsOK(ecode2)) {
22435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22436 }
22437 arg2 = static_cast< long >(val2);
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 (arg1)->SetStyle(arg2);
22441 wxPyEndAllowThreads(__tstate);
22442 if (PyErr_Occurred()) SWIG_fail;
22443 }
22444 resultobj = SWIG_Py_Void();
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22452 PyObject *resultobj = 0;
22453 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22454 long result;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 PyObject *swig_obj[1] ;
22458
22459 if (!args) SWIG_fail;
22460 swig_obj[0] = args;
22461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22462 if (!SWIG_IsOK(res1)) {
22463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22464 }
22465 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22466 {
22467 PyThreadState* __tstate = wxPyBeginAllowThreads();
22468 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22469 wxPyEndAllowThreads(__tstate);
22470 if (PyErr_Occurred()) SWIG_fail;
22471 }
22472 resultobj = SWIG_From_long(static_cast< long >(result));
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22480 PyObject *obj;
22481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22482 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22483 return SWIG_Py_Void();
22484 }
22485
22486 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22487 PyObject *resultobj = 0;
22488 wxString const &arg1_defvalue = wxPyEmptyString ;
22489 wxString *arg1 = (wxString *) &arg1_defvalue ;
22490 wxString const &arg2_defvalue = wxPyEmptyString ;
22491 wxString *arg2 = (wxString *) &arg2_defvalue ;
22492 wxString const &arg3_defvalue = wxPyEmptyString ;
22493 wxString *arg3 = (wxString *) &arg3_defvalue ;
22494 wxString const &arg4_defvalue = wxPyEmptyString ;
22495 wxString *arg4 = (wxString *) &arg4_defvalue ;
22496 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22497 wxConfig *result = 0 ;
22498 bool temp1 = false ;
22499 bool temp2 = false ;
22500 bool temp3 = false ;
22501 bool temp4 = false ;
22502 long val5 ;
22503 int ecode5 = 0 ;
22504 PyObject * obj0 = 0 ;
22505 PyObject * obj1 = 0 ;
22506 PyObject * obj2 = 0 ;
22507 PyObject * obj3 = 0 ;
22508 PyObject * obj4 = 0 ;
22509 char * kwnames[] = {
22510 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22511 };
22512
22513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22514 if (obj0) {
22515 {
22516 arg1 = wxString_in_helper(obj0);
22517 if (arg1 == NULL) SWIG_fail;
22518 temp1 = true;
22519 }
22520 }
22521 if (obj1) {
22522 {
22523 arg2 = wxString_in_helper(obj1);
22524 if (arg2 == NULL) SWIG_fail;
22525 temp2 = true;
22526 }
22527 }
22528 if (obj2) {
22529 {
22530 arg3 = wxString_in_helper(obj2);
22531 if (arg3 == NULL) SWIG_fail;
22532 temp3 = true;
22533 }
22534 }
22535 if (obj3) {
22536 {
22537 arg4 = wxString_in_helper(obj3);
22538 if (arg4 == NULL) SWIG_fail;
22539 temp4 = true;
22540 }
22541 }
22542 if (obj4) {
22543 ecode5 = SWIG_AsVal_long(obj4, &val5);
22544 if (!SWIG_IsOK(ecode5)) {
22545 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22546 }
22547 arg5 = static_cast< long >(val5);
22548 }
22549 {
22550 PyThreadState* __tstate = wxPyBeginAllowThreads();
22551 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22552 wxPyEndAllowThreads(__tstate);
22553 if (PyErr_Occurred()) SWIG_fail;
22554 }
22555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22556 {
22557 if (temp1)
22558 delete arg1;
22559 }
22560 {
22561 if (temp2)
22562 delete arg2;
22563 }
22564 {
22565 if (temp3)
22566 delete arg3;
22567 }
22568 {
22569 if (temp4)
22570 delete arg4;
22571 }
22572 return resultobj;
22573 fail:
22574 {
22575 if (temp1)
22576 delete arg1;
22577 }
22578 {
22579 if (temp2)
22580 delete arg2;
22581 }
22582 {
22583 if (temp3)
22584 delete arg3;
22585 }
22586 {
22587 if (temp4)
22588 delete arg4;
22589 }
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22595 PyObject *resultobj = 0;
22596 wxConfig *arg1 = (wxConfig *) 0 ;
22597 void *argp1 = 0 ;
22598 int res1 = 0 ;
22599 PyObject *swig_obj[1] ;
22600
22601 if (!args) SWIG_fail;
22602 swig_obj[0] = args;
22603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22604 if (!SWIG_IsOK(res1)) {
22605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22606 }
22607 arg1 = reinterpret_cast< wxConfig * >(argp1);
22608 {
22609 PyThreadState* __tstate = wxPyBeginAllowThreads();
22610 delete arg1;
22611
22612 wxPyEndAllowThreads(__tstate);
22613 if (PyErr_Occurred()) SWIG_fail;
22614 }
22615 resultobj = SWIG_Py_Void();
22616 return resultobj;
22617 fail:
22618 return NULL;
22619 }
22620
22621
22622 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22623 PyObject *obj;
22624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22625 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22626 return SWIG_Py_Void();
22627 }
22628
22629 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22630 return SWIG_Python_InitShadowInstance(args);
22631 }
22632
22633 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj = 0;
22635 wxString const &arg1_defvalue = wxPyEmptyString ;
22636 wxString *arg1 = (wxString *) &arg1_defvalue ;
22637 wxString const &arg2_defvalue = wxPyEmptyString ;
22638 wxString *arg2 = (wxString *) &arg2_defvalue ;
22639 wxString const &arg3_defvalue = wxPyEmptyString ;
22640 wxString *arg3 = (wxString *) &arg3_defvalue ;
22641 wxString const &arg4_defvalue = wxPyEmptyString ;
22642 wxString *arg4 = (wxString *) &arg4_defvalue ;
22643 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22644 wxFileConfig *result = 0 ;
22645 bool temp1 = false ;
22646 bool temp2 = false ;
22647 bool temp3 = false ;
22648 bool temp4 = false ;
22649 long val5 ;
22650 int ecode5 = 0 ;
22651 PyObject * obj0 = 0 ;
22652 PyObject * obj1 = 0 ;
22653 PyObject * obj2 = 0 ;
22654 PyObject * obj3 = 0 ;
22655 PyObject * obj4 = 0 ;
22656 char * kwnames[] = {
22657 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22658 };
22659
22660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22661 if (obj0) {
22662 {
22663 arg1 = wxString_in_helper(obj0);
22664 if (arg1 == NULL) SWIG_fail;
22665 temp1 = true;
22666 }
22667 }
22668 if (obj1) {
22669 {
22670 arg2 = wxString_in_helper(obj1);
22671 if (arg2 == NULL) SWIG_fail;
22672 temp2 = true;
22673 }
22674 }
22675 if (obj2) {
22676 {
22677 arg3 = wxString_in_helper(obj2);
22678 if (arg3 == NULL) SWIG_fail;
22679 temp3 = true;
22680 }
22681 }
22682 if (obj3) {
22683 {
22684 arg4 = wxString_in_helper(obj3);
22685 if (arg4 == NULL) SWIG_fail;
22686 temp4 = true;
22687 }
22688 }
22689 if (obj4) {
22690 ecode5 = SWIG_AsVal_long(obj4, &val5);
22691 if (!SWIG_IsOK(ecode5)) {
22692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22693 }
22694 arg5 = static_cast< long >(val5);
22695 }
22696 {
22697 PyThreadState* __tstate = wxPyBeginAllowThreads();
22698 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22699 wxPyEndAllowThreads(__tstate);
22700 if (PyErr_Occurred()) SWIG_fail;
22701 }
22702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22703 {
22704 if (temp1)
22705 delete arg1;
22706 }
22707 {
22708 if (temp2)
22709 delete arg2;
22710 }
22711 {
22712 if (temp3)
22713 delete arg3;
22714 }
22715 {
22716 if (temp4)
22717 delete arg4;
22718 }
22719 return resultobj;
22720 fail:
22721 {
22722 if (temp1)
22723 delete arg1;
22724 }
22725 {
22726 if (temp2)
22727 delete arg2;
22728 }
22729 {
22730 if (temp3)
22731 delete arg3;
22732 }
22733 {
22734 if (temp4)
22735 delete arg4;
22736 }
22737 return NULL;
22738 }
22739
22740
22741 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22742 PyObject *resultobj = 0;
22743 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22744 void *argp1 = 0 ;
22745 int res1 = 0 ;
22746 PyObject *swig_obj[1] ;
22747
22748 if (!args) SWIG_fail;
22749 swig_obj[0] = args;
22750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22751 if (!SWIG_IsOK(res1)) {
22752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22753 }
22754 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 delete arg1;
22758
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 resultobj = SWIG_Py_Void();
22763 return resultobj;
22764 fail:
22765 return NULL;
22766 }
22767
22768
22769 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22770 PyObject *obj;
22771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22772 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22773 return SWIG_Py_Void();
22774 }
22775
22776 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22777 return SWIG_Python_InitShadowInstance(args);
22778 }
22779
22780 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22781 PyObject *resultobj = 0;
22782 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22783 wxString *arg2 = 0 ;
22784 wxConfigPathChanger *result = 0 ;
22785 void *argp1 = 0 ;
22786 int res1 = 0 ;
22787 bool temp2 = false ;
22788 PyObject * obj0 = 0 ;
22789 PyObject * obj1 = 0 ;
22790 char * kwnames[] = {
22791 (char *) "config",(char *) "entry", NULL
22792 };
22793
22794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22796 if (!SWIG_IsOK(res1)) {
22797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22798 }
22799 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22800 {
22801 arg2 = wxString_in_helper(obj1);
22802 if (arg2 == NULL) SWIG_fail;
22803 temp2 = true;
22804 }
22805 {
22806 PyThreadState* __tstate = wxPyBeginAllowThreads();
22807 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22808 wxPyEndAllowThreads(__tstate);
22809 if (PyErr_Occurred()) SWIG_fail;
22810 }
22811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22812 {
22813 if (temp2)
22814 delete arg2;
22815 }
22816 return resultobj;
22817 fail:
22818 {
22819 if (temp2)
22820 delete arg2;
22821 }
22822 return NULL;
22823 }
22824
22825
22826 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22827 PyObject *resultobj = 0;
22828 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22829 void *argp1 = 0 ;
22830 int res1 = 0 ;
22831 PyObject *swig_obj[1] ;
22832
22833 if (!args) SWIG_fail;
22834 swig_obj[0] = args;
22835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22836 if (!SWIG_IsOK(res1)) {
22837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22838 }
22839 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22840 {
22841 PyThreadState* __tstate = wxPyBeginAllowThreads();
22842 delete arg1;
22843
22844 wxPyEndAllowThreads(__tstate);
22845 if (PyErr_Occurred()) SWIG_fail;
22846 }
22847 resultobj = SWIG_Py_Void();
22848 return resultobj;
22849 fail:
22850 return NULL;
22851 }
22852
22853
22854 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22855 PyObject *resultobj = 0;
22856 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22857 wxString *result = 0 ;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 PyObject *swig_obj[1] ;
22861
22862 if (!args) SWIG_fail;
22863 swig_obj[0] = args;
22864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22865 if (!SWIG_IsOK(res1)) {
22866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22867 }
22868 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22869 {
22870 PyThreadState* __tstate = wxPyBeginAllowThreads();
22871 {
22872 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22873 result = (wxString *) &_result_ref;
22874 }
22875 wxPyEndAllowThreads(__tstate);
22876 if (PyErr_Occurred()) SWIG_fail;
22877 }
22878 {
22879 #if wxUSE_UNICODE
22880 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22881 #else
22882 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22883 #endif
22884 }
22885 return resultobj;
22886 fail:
22887 return NULL;
22888 }
22889
22890
22891 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22892 PyObject *obj;
22893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22894 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22895 return SWIG_Py_Void();
22896 }
22897
22898 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22899 return SWIG_Python_InitShadowInstance(args);
22900 }
22901
22902 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22903 PyObject *resultobj = 0;
22904 wxString *arg1 = 0 ;
22905 wxString result;
22906 bool temp1 = false ;
22907 PyObject * obj0 = 0 ;
22908 char * kwnames[] = {
22909 (char *) "sz", NULL
22910 };
22911
22912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
22913 {
22914 arg1 = wxString_in_helper(obj0);
22915 if (arg1 == NULL) SWIG_fail;
22916 temp1 = true;
22917 }
22918 {
22919 PyThreadState* __tstate = wxPyBeginAllowThreads();
22920 result = wxExpandEnvVars((wxString const &)*arg1);
22921 wxPyEndAllowThreads(__tstate);
22922 if (PyErr_Occurred()) SWIG_fail;
22923 }
22924 {
22925 #if wxUSE_UNICODE
22926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22927 #else
22928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22929 #endif
22930 }
22931 {
22932 if (temp1)
22933 delete arg1;
22934 }
22935 return resultobj;
22936 fail:
22937 {
22938 if (temp1)
22939 delete arg1;
22940 }
22941 return NULL;
22942 }
22943
22944
22945 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
22946 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
22947 return 1;
22948 }
22949
22950
22951 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
22952 PyObject *pyobj = 0;
22953
22954 {
22955 #if wxUSE_UNICODE
22956 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22957 #else
22958 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22959 #endif
22960 }
22961 return pyobj;
22962 }
22963
22964
22965 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22966 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22967 return 1;
22968 }
22969
22970
22971 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22972 PyObject *pyobj = 0;
22973
22974 {
22975 #if wxUSE_UNICODE
22976 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22977 #else
22978 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22979 #endif
22980 }
22981 return pyobj;
22982 }
22983
22984
22985 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22986 PyObject *resultobj = 0;
22987 wxDateTime::Country arg1 ;
22988 int val1 ;
22989 int ecode1 = 0 ;
22990 PyObject * obj0 = 0 ;
22991 char * kwnames[] = {
22992 (char *) "country", NULL
22993 };
22994
22995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22996 ecode1 = SWIG_AsVal_int(obj0, &val1);
22997 if (!SWIG_IsOK(ecode1)) {
22998 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22999 }
23000 arg1 = static_cast< wxDateTime::Country >(val1);
23001 {
23002 PyThreadState* __tstate = wxPyBeginAllowThreads();
23003 wxDateTime::SetCountry(arg1);
23004 wxPyEndAllowThreads(__tstate);
23005 if (PyErr_Occurred()) SWIG_fail;
23006 }
23007 resultobj = SWIG_Py_Void();
23008 return resultobj;
23009 fail:
23010 return NULL;
23011 }
23012
23013
23014 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23015 PyObject *resultobj = 0;
23016 wxDateTime::Country result;
23017
23018 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 result = (wxDateTime::Country)wxDateTime::GetCountry();
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 resultobj = SWIG_From_int(static_cast< int >(result));
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23033 PyObject *resultobj = 0;
23034 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23035 bool result;
23036 int val1 ;
23037 int ecode1 = 0 ;
23038 PyObject * obj0 = 0 ;
23039 char * kwnames[] = {
23040 (char *) "country", NULL
23041 };
23042
23043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23044 if (obj0) {
23045 ecode1 = SWIG_AsVal_int(obj0, &val1);
23046 if (!SWIG_IsOK(ecode1)) {
23047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23048 }
23049 arg1 = static_cast< wxDateTime::Country >(val1);
23050 }
23051 {
23052 PyThreadState* __tstate = wxPyBeginAllowThreads();
23053 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23054 wxPyEndAllowThreads(__tstate);
23055 if (PyErr_Occurred()) SWIG_fail;
23056 }
23057 {
23058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23059 }
23060 return resultobj;
23061 fail:
23062 return NULL;
23063 }
23064
23065
23066 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23067 PyObject *resultobj = 0;
23068 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23069 int result;
23070 int val1 ;
23071 int ecode1 = 0 ;
23072 PyObject * obj0 = 0 ;
23073 char * kwnames[] = {
23074 (char *) "cal", NULL
23075 };
23076
23077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23078 if (obj0) {
23079 ecode1 = SWIG_AsVal_int(obj0, &val1);
23080 if (!SWIG_IsOK(ecode1)) {
23081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23082 }
23083 arg1 = static_cast< wxDateTime::Calendar >(val1);
23084 }
23085 {
23086 PyThreadState* __tstate = wxPyBeginAllowThreads();
23087 result = (int)wxDateTime::GetCurrentYear(arg1);
23088 wxPyEndAllowThreads(__tstate);
23089 if (PyErr_Occurred()) SWIG_fail;
23090 }
23091 resultobj = SWIG_From_int(static_cast< int >(result));
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj = 0;
23100 int arg1 ;
23101 int result;
23102 int val1 ;
23103 int ecode1 = 0 ;
23104 PyObject * obj0 = 0 ;
23105 char * kwnames[] = {
23106 (char *) "year", NULL
23107 };
23108
23109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23110 ecode1 = SWIG_AsVal_int(obj0, &val1);
23111 if (!SWIG_IsOK(ecode1)) {
23112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23113 }
23114 arg1 = static_cast< int >(val1);
23115 {
23116 PyThreadState* __tstate = wxPyBeginAllowThreads();
23117 result = (int)wxDateTime::ConvertYearToBC(arg1);
23118 wxPyEndAllowThreads(__tstate);
23119 if (PyErr_Occurred()) SWIG_fail;
23120 }
23121 resultobj = SWIG_From_int(static_cast< int >(result));
23122 return resultobj;
23123 fail:
23124 return NULL;
23125 }
23126
23127
23128 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23129 PyObject *resultobj = 0;
23130 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23131 wxDateTime::Month result;
23132 int val1 ;
23133 int ecode1 = 0 ;
23134 PyObject * obj0 = 0 ;
23135 char * kwnames[] = {
23136 (char *) "cal", NULL
23137 };
23138
23139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23140 if (obj0) {
23141 ecode1 = SWIG_AsVal_int(obj0, &val1);
23142 if (!SWIG_IsOK(ecode1)) {
23143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23144 }
23145 arg1 = static_cast< wxDateTime::Calendar >(val1);
23146 }
23147 {
23148 PyThreadState* __tstate = wxPyBeginAllowThreads();
23149 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 resultobj = SWIG_From_int(static_cast< int >(result));
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj = 0;
23162 int arg1 = (int) wxDateTime::Inv_Year ;
23163 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23164 bool result;
23165 int val1 ;
23166 int ecode1 = 0 ;
23167 int val2 ;
23168 int ecode2 = 0 ;
23169 PyObject * obj0 = 0 ;
23170 PyObject * obj1 = 0 ;
23171 char * kwnames[] = {
23172 (char *) "year",(char *) "cal", NULL
23173 };
23174
23175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23176 if (obj0) {
23177 ecode1 = SWIG_AsVal_int(obj0, &val1);
23178 if (!SWIG_IsOK(ecode1)) {
23179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23180 }
23181 arg1 = static_cast< int >(val1);
23182 }
23183 if (obj1) {
23184 ecode2 = SWIG_AsVal_int(obj1, &val2);
23185 if (!SWIG_IsOK(ecode2)) {
23186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23187 }
23188 arg2 = static_cast< wxDateTime::Calendar >(val2);
23189 }
23190 {
23191 PyThreadState* __tstate = wxPyBeginAllowThreads();
23192 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23193 wxPyEndAllowThreads(__tstate);
23194 if (PyErr_Occurred()) SWIG_fail;
23195 }
23196 {
23197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23198 }
23199 return resultobj;
23200 fail:
23201 return NULL;
23202 }
23203
23204
23205 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23206 PyObject *resultobj = 0;
23207 int arg1 = (int) wxDateTime::Inv_Year ;
23208 int result;
23209 int val1 ;
23210 int ecode1 = 0 ;
23211 PyObject * obj0 = 0 ;
23212 char * kwnames[] = {
23213 (char *) "year", NULL
23214 };
23215
23216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23217 if (obj0) {
23218 ecode1 = SWIG_AsVal_int(obj0, &val1);
23219 if (!SWIG_IsOK(ecode1)) {
23220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23221 }
23222 arg1 = static_cast< int >(val1);
23223 }
23224 {
23225 PyThreadState* __tstate = wxPyBeginAllowThreads();
23226 result = (int)wxDateTime::GetCentury(arg1);
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 resultobj = SWIG_From_int(static_cast< int >(result));
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj = 0;
23239 int arg1 ;
23240 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23241 int result;
23242 int val1 ;
23243 int ecode1 = 0 ;
23244 int val2 ;
23245 int ecode2 = 0 ;
23246 PyObject * obj0 = 0 ;
23247 PyObject * obj1 = 0 ;
23248 char * kwnames[] = {
23249 (char *) "year",(char *) "cal", NULL
23250 };
23251
23252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23253 ecode1 = SWIG_AsVal_int(obj0, &val1);
23254 if (!SWIG_IsOK(ecode1)) {
23255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23256 }
23257 arg1 = static_cast< int >(val1);
23258 if (obj1) {
23259 ecode2 = SWIG_AsVal_int(obj1, &val2);
23260 if (!SWIG_IsOK(ecode2)) {
23261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23262 }
23263 arg2 = static_cast< wxDateTime::Calendar >(val2);
23264 }
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23268 wxPyEndAllowThreads(__tstate);
23269 if (PyErr_Occurred()) SWIG_fail;
23270 }
23271 resultobj = SWIG_From_int(static_cast< int >(result));
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23279 PyObject *resultobj = 0;
23280 wxDateTime::Month arg1 ;
23281 int arg2 = (int) wxDateTime::Inv_Year ;
23282 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23283 int result;
23284 int val1 ;
23285 int ecode1 = 0 ;
23286 int val2 ;
23287 int ecode2 = 0 ;
23288 int val3 ;
23289 int ecode3 = 0 ;
23290 PyObject * obj0 = 0 ;
23291 PyObject * obj1 = 0 ;
23292 PyObject * obj2 = 0 ;
23293 char * kwnames[] = {
23294 (char *) "month",(char *) "year",(char *) "cal", NULL
23295 };
23296
23297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23298 ecode1 = SWIG_AsVal_int(obj0, &val1);
23299 if (!SWIG_IsOK(ecode1)) {
23300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23301 }
23302 arg1 = static_cast< wxDateTime::Month >(val1);
23303 if (obj1) {
23304 ecode2 = SWIG_AsVal_int(obj1, &val2);
23305 if (!SWIG_IsOK(ecode2)) {
23306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23307 }
23308 arg2 = static_cast< int >(val2);
23309 }
23310 if (obj2) {
23311 ecode3 = SWIG_AsVal_int(obj2, &val3);
23312 if (!SWIG_IsOK(ecode3)) {
23313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23314 }
23315 arg3 = static_cast< wxDateTime::Calendar >(val3);
23316 }
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 resultobj = SWIG_From_int(static_cast< int >(result));
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj = 0;
23332 wxDateTime::Month arg1 ;
23333 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23334 wxString result;
23335 int val1 ;
23336 int ecode1 = 0 ;
23337 int val2 ;
23338 int ecode2 = 0 ;
23339 PyObject * obj0 = 0 ;
23340 PyObject * obj1 = 0 ;
23341 char * kwnames[] = {
23342 (char *) "month",(char *) "flags", NULL
23343 };
23344
23345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23346 ecode1 = SWIG_AsVal_int(obj0, &val1);
23347 if (!SWIG_IsOK(ecode1)) {
23348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23349 }
23350 arg1 = static_cast< wxDateTime::Month >(val1);
23351 if (obj1) {
23352 ecode2 = SWIG_AsVal_int(obj1, &val2);
23353 if (!SWIG_IsOK(ecode2)) {
23354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23355 }
23356 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23357 }
23358 {
23359 PyThreadState* __tstate = wxPyBeginAllowThreads();
23360 result = wxDateTime::GetMonthName(arg1,arg2);
23361 wxPyEndAllowThreads(__tstate);
23362 if (PyErr_Occurred()) SWIG_fail;
23363 }
23364 {
23365 #if wxUSE_UNICODE
23366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23367 #else
23368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23369 #endif
23370 }
23371 return resultobj;
23372 fail:
23373 return NULL;
23374 }
23375
23376
23377 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23378 PyObject *resultobj = 0;
23379 wxDateTime::WeekDay arg1 ;
23380 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23381 wxString result;
23382 int val1 ;
23383 int ecode1 = 0 ;
23384 int val2 ;
23385 int ecode2 = 0 ;
23386 PyObject * obj0 = 0 ;
23387 PyObject * obj1 = 0 ;
23388 char * kwnames[] = {
23389 (char *) "weekday",(char *) "flags", NULL
23390 };
23391
23392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23393 ecode1 = SWIG_AsVal_int(obj0, &val1);
23394 if (!SWIG_IsOK(ecode1)) {
23395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23396 }
23397 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23398 if (obj1) {
23399 ecode2 = SWIG_AsVal_int(obj1, &val2);
23400 if (!SWIG_IsOK(ecode2)) {
23401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23402 }
23403 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23404 }
23405 {
23406 PyThreadState* __tstate = wxPyBeginAllowThreads();
23407 result = wxDateTime::GetWeekDayName(arg1,arg2);
23408 wxPyEndAllowThreads(__tstate);
23409 if (PyErr_Occurred()) SWIG_fail;
23410 }
23411 {
23412 #if wxUSE_UNICODE
23413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23414 #else
23415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23416 #endif
23417 }
23418 return resultobj;
23419 fail:
23420 return NULL;
23421 }
23422
23423
23424 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23425 PyObject *resultobj = 0;
23426 PyObject *result = 0 ;
23427
23428 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23429 {
23430 PyThreadState* __tstate = wxPyBeginAllowThreads();
23431 result = (PyObject *)wxDateTime_GetAmPmStrings();
23432 wxPyEndAllowThreads(__tstate);
23433 if (PyErr_Occurred()) SWIG_fail;
23434 }
23435 resultobj = result;
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj = 0;
23444 int arg1 = (int) wxDateTime::Inv_Year ;
23445 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23446 bool result;
23447 int val1 ;
23448 int ecode1 = 0 ;
23449 int val2 ;
23450 int ecode2 = 0 ;
23451 PyObject * obj0 = 0 ;
23452 PyObject * obj1 = 0 ;
23453 char * kwnames[] = {
23454 (char *) "year",(char *) "country", NULL
23455 };
23456
23457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23458 if (obj0) {
23459 ecode1 = SWIG_AsVal_int(obj0, &val1);
23460 if (!SWIG_IsOK(ecode1)) {
23461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23462 }
23463 arg1 = static_cast< int >(val1);
23464 }
23465 if (obj1) {
23466 ecode2 = SWIG_AsVal_int(obj1, &val2);
23467 if (!SWIG_IsOK(ecode2)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23469 }
23470 arg2 = static_cast< wxDateTime::Country >(val2);
23471 }
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 {
23479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23480 }
23481 return resultobj;
23482 fail:
23483 return NULL;
23484 }
23485
23486
23487 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23488 PyObject *resultobj = 0;
23489 int arg1 = (int) wxDateTime::Inv_Year ;
23490 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23491 wxDateTime result;
23492 int val1 ;
23493 int ecode1 = 0 ;
23494 int val2 ;
23495 int ecode2 = 0 ;
23496 PyObject * obj0 = 0 ;
23497 PyObject * obj1 = 0 ;
23498 char * kwnames[] = {
23499 (char *) "year",(char *) "country", NULL
23500 };
23501
23502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23503 if (obj0) {
23504 ecode1 = SWIG_AsVal_int(obj0, &val1);
23505 if (!SWIG_IsOK(ecode1)) {
23506 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23507 }
23508 arg1 = static_cast< int >(val1);
23509 }
23510 if (obj1) {
23511 ecode2 = SWIG_AsVal_int(obj1, &val2);
23512 if (!SWIG_IsOK(ecode2)) {
23513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23514 }
23515 arg2 = static_cast< wxDateTime::Country >(val2);
23516 }
23517 {
23518 PyThreadState* __tstate = wxPyBeginAllowThreads();
23519 result = wxDateTime::GetBeginDST(arg1,arg2);
23520 wxPyEndAllowThreads(__tstate);
23521 if (PyErr_Occurred()) SWIG_fail;
23522 }
23523 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23524 return resultobj;
23525 fail:
23526 return NULL;
23527 }
23528
23529
23530 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23531 PyObject *resultobj = 0;
23532 int arg1 = (int) wxDateTime::Inv_Year ;
23533 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23534 wxDateTime result;
23535 int val1 ;
23536 int ecode1 = 0 ;
23537 int val2 ;
23538 int ecode2 = 0 ;
23539 PyObject * obj0 = 0 ;
23540 PyObject * obj1 = 0 ;
23541 char * kwnames[] = {
23542 (char *) "year",(char *) "country", NULL
23543 };
23544
23545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23546 if (obj0) {
23547 ecode1 = SWIG_AsVal_int(obj0, &val1);
23548 if (!SWIG_IsOK(ecode1)) {
23549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23550 }
23551 arg1 = static_cast< int >(val1);
23552 }
23553 if (obj1) {
23554 ecode2 = SWIG_AsVal_int(obj1, &val2);
23555 if (!SWIG_IsOK(ecode2)) {
23556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23557 }
23558 arg2 = static_cast< wxDateTime::Country >(val2);
23559 }
23560 {
23561 PyThreadState* __tstate = wxPyBeginAllowThreads();
23562 result = wxDateTime::GetEndDST(arg1,arg2);
23563 wxPyEndAllowThreads(__tstate);
23564 if (PyErr_Occurred()) SWIG_fail;
23565 }
23566 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23567 return resultobj;
23568 fail:
23569 return NULL;
23570 }
23571
23572
23573 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23574 PyObject *resultobj = 0;
23575 wxDateTime result;
23576
23577 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23578 {
23579 PyThreadState* __tstate = wxPyBeginAllowThreads();
23580 result = wxDateTime::Now();
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxDateTime result;
23594
23595 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23596 {
23597 PyThreadState* __tstate = wxPyBeginAllowThreads();
23598 result = wxDateTime::UNow();
23599 wxPyEndAllowThreads(__tstate);
23600 if (PyErr_Occurred()) SWIG_fail;
23601 }
23602 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23603 return resultobj;
23604 fail:
23605 return NULL;
23606 }
23607
23608
23609 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23610 PyObject *resultobj = 0;
23611 wxDateTime result;
23612
23613 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23614 {
23615 PyThreadState* __tstate = wxPyBeginAllowThreads();
23616 result = wxDateTime::Today();
23617 wxPyEndAllowThreads(__tstate);
23618 if (PyErr_Occurred()) SWIG_fail;
23619 }
23620 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23621 return resultobj;
23622 fail:
23623 return NULL;
23624 }
23625
23626
23627 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23628 PyObject *resultobj = 0;
23629 wxDateTime *result = 0 ;
23630
23631 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (wxDateTime *)new wxDateTime();
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23646 PyObject *resultobj = 0;
23647 time_t arg1 ;
23648 wxDateTime *result = 0 ;
23649 unsigned int val1 ;
23650 int ecode1 = 0 ;
23651 PyObject * obj0 = 0 ;
23652 char * kwnames[] = {
23653 (char *) "timet", NULL
23654 };
23655
23656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23657 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23658 if (!SWIG_IsOK(ecode1)) {
23659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23660 }
23661 arg1 = static_cast< time_t >(val1);
23662 {
23663 PyThreadState* __tstate = wxPyBeginAllowThreads();
23664 result = (wxDateTime *)new wxDateTime(arg1);
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23676 PyObject *resultobj = 0;
23677 double arg1 ;
23678 wxDateTime *result = 0 ;
23679 double val1 ;
23680 int ecode1 = 0 ;
23681 PyObject * obj0 = 0 ;
23682 char * kwnames[] = {
23683 (char *) "jdn", NULL
23684 };
23685
23686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23687 ecode1 = SWIG_AsVal_double(obj0, &val1);
23688 if (!SWIG_IsOK(ecode1)) {
23689 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23690 }
23691 arg1 = static_cast< double >(val1);
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = (wxDateTime *)new wxDateTime(arg1);
23695 wxPyEndAllowThreads(__tstate);
23696 if (PyErr_Occurred()) SWIG_fail;
23697 }
23698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23699 return resultobj;
23700 fail:
23701 return NULL;
23702 }
23703
23704
23705 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23706 PyObject *resultobj = 0;
23707 int arg1 ;
23708 int arg2 = (int) 0 ;
23709 int arg3 = (int) 0 ;
23710 int arg4 = (int) 0 ;
23711 wxDateTime *result = 0 ;
23712 int val1 ;
23713 int ecode1 = 0 ;
23714 int val2 ;
23715 int ecode2 = 0 ;
23716 int val3 ;
23717 int ecode3 = 0 ;
23718 int val4 ;
23719 int ecode4 = 0 ;
23720 PyObject * obj0 = 0 ;
23721 PyObject * obj1 = 0 ;
23722 PyObject * obj2 = 0 ;
23723 PyObject * obj3 = 0 ;
23724 char * kwnames[] = {
23725 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23726 };
23727
23728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23729 ecode1 = SWIG_AsVal_int(obj0, &val1);
23730 if (!SWIG_IsOK(ecode1)) {
23731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23732 }
23733 arg1 = static_cast< int >(val1);
23734 if (obj1) {
23735 ecode2 = SWIG_AsVal_int(obj1, &val2);
23736 if (!SWIG_IsOK(ecode2)) {
23737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23738 }
23739 arg2 = static_cast< int >(val2);
23740 }
23741 if (obj2) {
23742 ecode3 = SWIG_AsVal_int(obj2, &val3);
23743 if (!SWIG_IsOK(ecode3)) {
23744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23745 }
23746 arg3 = static_cast< int >(val3);
23747 }
23748 if (obj3) {
23749 ecode4 = SWIG_AsVal_int(obj3, &val4);
23750 if (!SWIG_IsOK(ecode4)) {
23751 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23752 }
23753 arg4 = static_cast< int >(val4);
23754 }
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj = 0;
23770 int arg1 ;
23771 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23772 int arg3 = (int) wxDateTime::Inv_Year ;
23773 int arg4 = (int) 0 ;
23774 int arg5 = (int) 0 ;
23775 int arg6 = (int) 0 ;
23776 int arg7 = (int) 0 ;
23777 wxDateTime *result = 0 ;
23778 int val1 ;
23779 int ecode1 = 0 ;
23780 int val2 ;
23781 int ecode2 = 0 ;
23782 int val3 ;
23783 int ecode3 = 0 ;
23784 int val4 ;
23785 int ecode4 = 0 ;
23786 int val5 ;
23787 int ecode5 = 0 ;
23788 int val6 ;
23789 int ecode6 = 0 ;
23790 int val7 ;
23791 int ecode7 = 0 ;
23792 PyObject * obj0 = 0 ;
23793 PyObject * obj1 = 0 ;
23794 PyObject * obj2 = 0 ;
23795 PyObject * obj3 = 0 ;
23796 PyObject * obj4 = 0 ;
23797 PyObject * obj5 = 0 ;
23798 PyObject * obj6 = 0 ;
23799 char * kwnames[] = {
23800 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23801 };
23802
23803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23804 ecode1 = SWIG_AsVal_int(obj0, &val1);
23805 if (!SWIG_IsOK(ecode1)) {
23806 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23807 }
23808 arg1 = static_cast< int >(val1);
23809 if (obj1) {
23810 ecode2 = SWIG_AsVal_int(obj1, &val2);
23811 if (!SWIG_IsOK(ecode2)) {
23812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23813 }
23814 arg2 = static_cast< wxDateTime::Month >(val2);
23815 }
23816 if (obj2) {
23817 ecode3 = SWIG_AsVal_int(obj2, &val3);
23818 if (!SWIG_IsOK(ecode3)) {
23819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23820 }
23821 arg3 = static_cast< int >(val3);
23822 }
23823 if (obj3) {
23824 ecode4 = SWIG_AsVal_int(obj3, &val4);
23825 if (!SWIG_IsOK(ecode4)) {
23826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23827 }
23828 arg4 = static_cast< int >(val4);
23829 }
23830 if (obj4) {
23831 ecode5 = SWIG_AsVal_int(obj4, &val5);
23832 if (!SWIG_IsOK(ecode5)) {
23833 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23834 }
23835 arg5 = static_cast< int >(val5);
23836 }
23837 if (obj5) {
23838 ecode6 = SWIG_AsVal_int(obj5, &val6);
23839 if (!SWIG_IsOK(ecode6)) {
23840 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23841 }
23842 arg6 = static_cast< int >(val6);
23843 }
23844 if (obj6) {
23845 ecode7 = SWIG_AsVal_int(obj6, &val7);
23846 if (!SWIG_IsOK(ecode7)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23848 }
23849 arg7 = static_cast< int >(val7);
23850 }
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj = 0;
23866 wxDateTime *arg1 = 0 ;
23867 wxDateTime *result = 0 ;
23868 void *argp1 = 0 ;
23869 int res1 = 0 ;
23870 PyObject * obj0 = 0 ;
23871 char * kwnames[] = {
23872 (char *) "date", NULL
23873 };
23874
23875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23876 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23877 if (!SWIG_IsOK(res1)) {
23878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23879 }
23880 if (!argp1) {
23881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23882 }
23883 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23884 {
23885 PyThreadState* __tstate = wxPyBeginAllowThreads();
23886 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23887 wxPyEndAllowThreads(__tstate);
23888 if (PyErr_Occurred()) SWIG_fail;
23889 }
23890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23891 return resultobj;
23892 fail:
23893 return NULL;
23894 }
23895
23896
23897 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23898 PyObject *resultobj = 0;
23899 wxDateTime *arg1 = (wxDateTime *) 0 ;
23900 void *argp1 = 0 ;
23901 int res1 = 0 ;
23902 PyObject *swig_obj[1] ;
23903
23904 if (!args) SWIG_fail;
23905 swig_obj[0] = args;
23906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
23907 if (!SWIG_IsOK(res1)) {
23908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23909 }
23910 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 delete arg1;
23914
23915 wxPyEndAllowThreads(__tstate);
23916 if (PyErr_Occurred()) SWIG_fail;
23917 }
23918 resultobj = SWIG_Py_Void();
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23926 PyObject *resultobj = 0;
23927 wxDateTime *arg1 = (wxDateTime *) 0 ;
23928 wxDateTime *result = 0 ;
23929 void *argp1 = 0 ;
23930 int res1 = 0 ;
23931 PyObject *swig_obj[1] ;
23932
23933 if (!args) SWIG_fail;
23934 swig_obj[0] = args;
23935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23936 if (!SWIG_IsOK(res1)) {
23937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
23938 }
23939 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 {
23943 wxDateTime &_result_ref = (arg1)->SetToCurrent();
23944 result = (wxDateTime *) &_result_ref;
23945 }
23946 wxPyEndAllowThreads(__tstate);
23947 if (PyErr_Occurred()) SWIG_fail;
23948 }
23949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23950 return resultobj;
23951 fail:
23952 return NULL;
23953 }
23954
23955
23956 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23957 PyObject *resultobj = 0;
23958 wxDateTime *arg1 = (wxDateTime *) 0 ;
23959 time_t arg2 ;
23960 wxDateTime *result = 0 ;
23961 void *argp1 = 0 ;
23962 int res1 = 0 ;
23963 unsigned int val2 ;
23964 int ecode2 = 0 ;
23965 PyObject * obj0 = 0 ;
23966 PyObject * obj1 = 0 ;
23967 char * kwnames[] = {
23968 (char *) "self",(char *) "timet", NULL
23969 };
23970
23971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23973 if (!SWIG_IsOK(res1)) {
23974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23975 }
23976 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23977 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23978 if (!SWIG_IsOK(ecode2)) {
23979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23980 }
23981 arg2 = static_cast< time_t >(val2);
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 {
23985 wxDateTime &_result_ref = (arg1)->Set(arg2);
23986 result = (wxDateTime *) &_result_ref;
23987 }
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23992 return resultobj;
23993 fail:
23994 return NULL;
23995 }
23996
23997
23998 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj = 0;
24000 wxDateTime *arg1 = (wxDateTime *) 0 ;
24001 double arg2 ;
24002 wxDateTime *result = 0 ;
24003 void *argp1 = 0 ;
24004 int res1 = 0 ;
24005 double val2 ;
24006 int ecode2 = 0 ;
24007 PyObject * obj0 = 0 ;
24008 PyObject * obj1 = 0 ;
24009 char * kwnames[] = {
24010 (char *) "self",(char *) "jdn", NULL
24011 };
24012
24013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24015 if (!SWIG_IsOK(res1)) {
24016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24017 }
24018 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24019 ecode2 = SWIG_AsVal_double(obj1, &val2);
24020 if (!SWIG_IsOK(ecode2)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24022 }
24023 arg2 = static_cast< double >(val2);
24024 {
24025 PyThreadState* __tstate = wxPyBeginAllowThreads();
24026 {
24027 wxDateTime &_result_ref = (arg1)->Set(arg2);
24028 result = (wxDateTime *) &_result_ref;
24029 }
24030 wxPyEndAllowThreads(__tstate);
24031 if (PyErr_Occurred()) SWIG_fail;
24032 }
24033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24034 return resultobj;
24035 fail:
24036 return NULL;
24037 }
24038
24039
24040 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24041 PyObject *resultobj = 0;
24042 wxDateTime *arg1 = (wxDateTime *) 0 ;
24043 int arg2 ;
24044 int arg3 = (int) 0 ;
24045 int arg4 = (int) 0 ;
24046 int arg5 = (int) 0 ;
24047 wxDateTime *result = 0 ;
24048 void *argp1 = 0 ;
24049 int res1 = 0 ;
24050 int val2 ;
24051 int ecode2 = 0 ;
24052 int val3 ;
24053 int ecode3 = 0 ;
24054 int val4 ;
24055 int ecode4 = 0 ;
24056 int val5 ;
24057 int ecode5 = 0 ;
24058 PyObject * obj0 = 0 ;
24059 PyObject * obj1 = 0 ;
24060 PyObject * obj2 = 0 ;
24061 PyObject * obj3 = 0 ;
24062 PyObject * obj4 = 0 ;
24063 char * kwnames[] = {
24064 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24065 };
24066
24067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24069 if (!SWIG_IsOK(res1)) {
24070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24071 }
24072 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24073 ecode2 = SWIG_AsVal_int(obj1, &val2);
24074 if (!SWIG_IsOK(ecode2)) {
24075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24076 }
24077 arg2 = static_cast< int >(val2);
24078 if (obj2) {
24079 ecode3 = SWIG_AsVal_int(obj2, &val3);
24080 if (!SWIG_IsOK(ecode3)) {
24081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24082 }
24083 arg3 = static_cast< int >(val3);
24084 }
24085 if (obj3) {
24086 ecode4 = SWIG_AsVal_int(obj3, &val4);
24087 if (!SWIG_IsOK(ecode4)) {
24088 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24089 }
24090 arg4 = static_cast< int >(val4);
24091 }
24092 if (obj4) {
24093 ecode5 = SWIG_AsVal_int(obj4, &val5);
24094 if (!SWIG_IsOK(ecode5)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24096 }
24097 arg5 = static_cast< int >(val5);
24098 }
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 {
24102 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24103 result = (wxDateTime *) &_result_ref;
24104 }
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24116 PyObject *resultobj = 0;
24117 wxDateTime *arg1 = (wxDateTime *) 0 ;
24118 int arg2 ;
24119 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24120 int arg4 = (int) wxDateTime::Inv_Year ;
24121 int arg5 = (int) 0 ;
24122 int arg6 = (int) 0 ;
24123 int arg7 = (int) 0 ;
24124 int arg8 = (int) 0 ;
24125 wxDateTime *result = 0 ;
24126 void *argp1 = 0 ;
24127 int res1 = 0 ;
24128 int val2 ;
24129 int ecode2 = 0 ;
24130 int val3 ;
24131 int ecode3 = 0 ;
24132 int val4 ;
24133 int ecode4 = 0 ;
24134 int val5 ;
24135 int ecode5 = 0 ;
24136 int val6 ;
24137 int ecode6 = 0 ;
24138 int val7 ;
24139 int ecode7 = 0 ;
24140 int val8 ;
24141 int ecode8 = 0 ;
24142 PyObject * obj0 = 0 ;
24143 PyObject * obj1 = 0 ;
24144 PyObject * obj2 = 0 ;
24145 PyObject * obj3 = 0 ;
24146 PyObject * obj4 = 0 ;
24147 PyObject * obj5 = 0 ;
24148 PyObject * obj6 = 0 ;
24149 PyObject * obj7 = 0 ;
24150 char * kwnames[] = {
24151 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24152 };
24153
24154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24156 if (!SWIG_IsOK(res1)) {
24157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24158 }
24159 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24160 ecode2 = SWIG_AsVal_int(obj1, &val2);
24161 if (!SWIG_IsOK(ecode2)) {
24162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24163 }
24164 arg2 = static_cast< int >(val2);
24165 if (obj2) {
24166 ecode3 = SWIG_AsVal_int(obj2, &val3);
24167 if (!SWIG_IsOK(ecode3)) {
24168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24169 }
24170 arg3 = static_cast< wxDateTime::Month >(val3);
24171 }
24172 if (obj3) {
24173 ecode4 = SWIG_AsVal_int(obj3, &val4);
24174 if (!SWIG_IsOK(ecode4)) {
24175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24176 }
24177 arg4 = static_cast< int >(val4);
24178 }
24179 if (obj4) {
24180 ecode5 = SWIG_AsVal_int(obj4, &val5);
24181 if (!SWIG_IsOK(ecode5)) {
24182 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24183 }
24184 arg5 = static_cast< int >(val5);
24185 }
24186 if (obj5) {
24187 ecode6 = SWIG_AsVal_int(obj5, &val6);
24188 if (!SWIG_IsOK(ecode6)) {
24189 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24190 }
24191 arg6 = static_cast< int >(val6);
24192 }
24193 if (obj6) {
24194 ecode7 = SWIG_AsVal_int(obj6, &val7);
24195 if (!SWIG_IsOK(ecode7)) {
24196 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24197 }
24198 arg7 = static_cast< int >(val7);
24199 }
24200 if (obj7) {
24201 ecode8 = SWIG_AsVal_int(obj7, &val8);
24202 if (!SWIG_IsOK(ecode8)) {
24203 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24204 }
24205 arg8 = static_cast< int >(val8);
24206 }
24207 {
24208 PyThreadState* __tstate = wxPyBeginAllowThreads();
24209 {
24210 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24211 result = (wxDateTime *) &_result_ref;
24212 }
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24224 PyObject *resultobj = 0;
24225 wxDateTime *arg1 = (wxDateTime *) 0 ;
24226 wxDateTime *result = 0 ;
24227 void *argp1 = 0 ;
24228 int res1 = 0 ;
24229 PyObject *swig_obj[1] ;
24230
24231 if (!args) SWIG_fail;
24232 swig_obj[0] = args;
24233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24234 if (!SWIG_IsOK(res1)) {
24235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24236 }
24237 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24238 {
24239 PyThreadState* __tstate = wxPyBeginAllowThreads();
24240 {
24241 wxDateTime &_result_ref = (arg1)->ResetTime();
24242 result = (wxDateTime *) &_result_ref;
24243 }
24244 wxPyEndAllowThreads(__tstate);
24245 if (PyErr_Occurred()) SWIG_fail;
24246 }
24247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24248 return resultobj;
24249 fail:
24250 return NULL;
24251 }
24252
24253
24254 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24255 PyObject *resultobj = 0;
24256 wxDateTime *arg1 = (wxDateTime *) 0 ;
24257 int arg2 ;
24258 wxDateTime *result = 0 ;
24259 void *argp1 = 0 ;
24260 int res1 = 0 ;
24261 int val2 ;
24262 int ecode2 = 0 ;
24263 PyObject * obj0 = 0 ;
24264 PyObject * obj1 = 0 ;
24265 char * kwnames[] = {
24266 (char *) "self",(char *) "year", NULL
24267 };
24268
24269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24271 if (!SWIG_IsOK(res1)) {
24272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24273 }
24274 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24275 ecode2 = SWIG_AsVal_int(obj1, &val2);
24276 if (!SWIG_IsOK(ecode2)) {
24277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24278 }
24279 arg2 = static_cast< int >(val2);
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 {
24283 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24284 result = (wxDateTime *) &_result_ref;
24285 }
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj = 0;
24298 wxDateTime *arg1 = (wxDateTime *) 0 ;
24299 wxDateTime::Month arg2 ;
24300 wxDateTime *result = 0 ;
24301 void *argp1 = 0 ;
24302 int res1 = 0 ;
24303 int val2 ;
24304 int ecode2 = 0 ;
24305 PyObject * obj0 = 0 ;
24306 PyObject * obj1 = 0 ;
24307 char * kwnames[] = {
24308 (char *) "self",(char *) "month", NULL
24309 };
24310
24311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24313 if (!SWIG_IsOK(res1)) {
24314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24315 }
24316 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24317 ecode2 = SWIG_AsVal_int(obj1, &val2);
24318 if (!SWIG_IsOK(ecode2)) {
24319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24320 }
24321 arg2 = static_cast< wxDateTime::Month >(val2);
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 {
24325 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24326 result = (wxDateTime *) &_result_ref;
24327 }
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24339 PyObject *resultobj = 0;
24340 wxDateTime *arg1 = (wxDateTime *) 0 ;
24341 int arg2 ;
24342 wxDateTime *result = 0 ;
24343 void *argp1 = 0 ;
24344 int res1 = 0 ;
24345 int val2 ;
24346 int ecode2 = 0 ;
24347 PyObject * obj0 = 0 ;
24348 PyObject * obj1 = 0 ;
24349 char * kwnames[] = {
24350 (char *) "self",(char *) "day", NULL
24351 };
24352
24353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) 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_SetDay" "', 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_SetDay" "', expected argument " "2"" of type '" "int""'");
24362 }
24363 arg2 = static_cast< int >(val2);
24364 {
24365 PyThreadState* __tstate = wxPyBeginAllowThreads();
24366 {
24367 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24368 result = (wxDateTime *) &_result_ref;
24369 }
24370 wxPyEndAllowThreads(__tstate);
24371 if (PyErr_Occurred()) SWIG_fail;
24372 }
24373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj = 0;
24382 wxDateTime *arg1 = (wxDateTime *) 0 ;
24383 int arg2 ;
24384 wxDateTime *result = 0 ;
24385 void *argp1 = 0 ;
24386 int res1 = 0 ;
24387 int val2 ;
24388 int ecode2 = 0 ;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 char * kwnames[] = {
24392 (char *) "self",(char *) "hour", NULL
24393 };
24394
24395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24397 if (!SWIG_IsOK(res1)) {
24398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24399 }
24400 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24401 ecode2 = SWIG_AsVal_int(obj1, &val2);
24402 if (!SWIG_IsOK(ecode2)) {
24403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24404 }
24405 arg2 = static_cast< int >(val2);
24406 {
24407 PyThreadState* __tstate = wxPyBeginAllowThreads();
24408 {
24409 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
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_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24423 PyObject *resultobj = 0;
24424 wxDateTime *arg1 = (wxDateTime *) 0 ;
24425 int arg2 ;
24426 wxDateTime *result = 0 ;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 int val2 ;
24430 int ecode2 = 0 ;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 char * kwnames[] = {
24434 (char *) "self",(char *) "minute", NULL
24435 };
24436
24437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24439 if (!SWIG_IsOK(res1)) {
24440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24441 }
24442 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24443 ecode2 = SWIG_AsVal_int(obj1, &val2);
24444 if (!SWIG_IsOK(ecode2)) {
24445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24446 }
24447 arg2 = static_cast< int >(val2);
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 {
24451 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24452 result = (wxDateTime *) &_result_ref;
24453 }
24454 wxPyEndAllowThreads(__tstate);
24455 if (PyErr_Occurred()) SWIG_fail;
24456 }
24457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24465 PyObject *resultobj = 0;
24466 wxDateTime *arg1 = (wxDateTime *) 0 ;
24467 int arg2 ;
24468 wxDateTime *result = 0 ;
24469 void *argp1 = 0 ;
24470 int res1 = 0 ;
24471 int val2 ;
24472 int ecode2 = 0 ;
24473 PyObject * obj0 = 0 ;
24474 PyObject * obj1 = 0 ;
24475 char * kwnames[] = {
24476 (char *) "self",(char *) "second", NULL
24477 };
24478
24479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24481 if (!SWIG_IsOK(res1)) {
24482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24483 }
24484 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24485 ecode2 = SWIG_AsVal_int(obj1, &val2);
24486 if (!SWIG_IsOK(ecode2)) {
24487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24488 }
24489 arg2 = static_cast< int >(val2);
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 {
24493 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24494 result = (wxDateTime *) &_result_ref;
24495 }
24496 wxPyEndAllowThreads(__tstate);
24497 if (PyErr_Occurred()) SWIG_fail;
24498 }
24499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24500 return resultobj;
24501 fail:
24502 return NULL;
24503 }
24504
24505
24506 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24507 PyObject *resultobj = 0;
24508 wxDateTime *arg1 = (wxDateTime *) 0 ;
24509 int arg2 ;
24510 wxDateTime *result = 0 ;
24511 void *argp1 = 0 ;
24512 int res1 = 0 ;
24513 int val2 ;
24514 int ecode2 = 0 ;
24515 PyObject * obj0 = 0 ;
24516 PyObject * obj1 = 0 ;
24517 char * kwnames[] = {
24518 (char *) "self",(char *) "millisecond", NULL
24519 };
24520
24521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24523 if (!SWIG_IsOK(res1)) {
24524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24525 }
24526 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24527 ecode2 = SWIG_AsVal_int(obj1, &val2);
24528 if (!SWIG_IsOK(ecode2)) {
24529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24530 }
24531 arg2 = static_cast< int >(val2);
24532 {
24533 PyThreadState* __tstate = wxPyBeginAllowThreads();
24534 {
24535 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24536 result = (wxDateTime *) &_result_ref;
24537 }
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj = 0;
24550 wxDateTime *arg1 = (wxDateTime *) 0 ;
24551 wxDateTime::WeekDay arg2 ;
24552 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24553 wxDateTime *result = 0 ;
24554 void *argp1 = 0 ;
24555 int res1 = 0 ;
24556 int val2 ;
24557 int ecode2 = 0 ;
24558 int val3 ;
24559 int ecode3 = 0 ;
24560 PyObject * obj0 = 0 ;
24561 PyObject * obj1 = 0 ;
24562 PyObject * obj2 = 0 ;
24563 char * kwnames[] = {
24564 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24565 };
24566
24567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24569 if (!SWIG_IsOK(res1)) {
24570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24571 }
24572 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24573 ecode2 = SWIG_AsVal_int(obj1, &val2);
24574 if (!SWIG_IsOK(ecode2)) {
24575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24576 }
24577 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24578 if (obj2) {
24579 ecode3 = SWIG_AsVal_int(obj2, &val3);
24580 if (!SWIG_IsOK(ecode3)) {
24581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24582 }
24583 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24584 }
24585 {
24586 PyThreadState* __tstate = wxPyBeginAllowThreads();
24587 {
24588 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24589 result = (wxDateTime *) &_result_ref;
24590 }
24591 wxPyEndAllowThreads(__tstate);
24592 if (PyErr_Occurred()) SWIG_fail;
24593 }
24594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24595 return resultobj;
24596 fail:
24597 return NULL;
24598 }
24599
24600
24601 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24602 PyObject *resultobj = 0;
24603 wxDateTime *arg1 = (wxDateTime *) 0 ;
24604 wxDateTime::WeekDay arg2 ;
24605 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24606 wxDateTime result;
24607 void *argp1 = 0 ;
24608 int res1 = 0 ;
24609 int val2 ;
24610 int ecode2 = 0 ;
24611 int val3 ;
24612 int ecode3 = 0 ;
24613 PyObject * obj0 = 0 ;
24614 PyObject * obj1 = 0 ;
24615 PyObject * obj2 = 0 ;
24616 char * kwnames[] = {
24617 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24618 };
24619
24620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24622 if (!SWIG_IsOK(res1)) {
24623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24624 }
24625 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24626 ecode2 = SWIG_AsVal_int(obj1, &val2);
24627 if (!SWIG_IsOK(ecode2)) {
24628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24629 }
24630 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24631 if (obj2) {
24632 ecode3 = SWIG_AsVal_int(obj2, &val3);
24633 if (!SWIG_IsOK(ecode3)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24635 }
24636 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24637 }
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24641 wxPyEndAllowThreads(__tstate);
24642 if (PyErr_Occurred()) SWIG_fail;
24643 }
24644 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj = 0;
24653 wxDateTime *arg1 = (wxDateTime *) 0 ;
24654 wxDateTime::WeekDay arg2 ;
24655 wxDateTime *result = 0 ;
24656 void *argp1 = 0 ;
24657 int res1 = 0 ;
24658 int val2 ;
24659 int ecode2 = 0 ;
24660 PyObject * obj0 = 0 ;
24661 PyObject * obj1 = 0 ;
24662 char * kwnames[] = {
24663 (char *) "self",(char *) "weekday", NULL
24664 };
24665
24666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24670 }
24671 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24672 ecode2 = SWIG_AsVal_int(obj1, &val2);
24673 if (!SWIG_IsOK(ecode2)) {
24674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24675 }
24676 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24677 {
24678 PyThreadState* __tstate = wxPyBeginAllowThreads();
24679 {
24680 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24681 result = (wxDateTime *) &_result_ref;
24682 }
24683 wxPyEndAllowThreads(__tstate);
24684 if (PyErr_Occurred()) SWIG_fail;
24685 }
24686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24687 return resultobj;
24688 fail:
24689 return NULL;
24690 }
24691
24692
24693 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24694 PyObject *resultobj = 0;
24695 wxDateTime *arg1 = (wxDateTime *) 0 ;
24696 wxDateTime::WeekDay arg2 ;
24697 wxDateTime result;
24698 void *argp1 = 0 ;
24699 int res1 = 0 ;
24700 int val2 ;
24701 int ecode2 = 0 ;
24702 PyObject * obj0 = 0 ;
24703 PyObject * obj1 = 0 ;
24704 char * kwnames[] = {
24705 (char *) "self",(char *) "weekday", NULL
24706 };
24707
24708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24710 if (!SWIG_IsOK(res1)) {
24711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24712 }
24713 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24714 ecode2 = SWIG_AsVal_int(obj1, &val2);
24715 if (!SWIG_IsOK(ecode2)) {
24716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24717 }
24718 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24719 {
24720 PyThreadState* __tstate = wxPyBeginAllowThreads();
24721 result = (arg1)->GetNextWeekDay(arg2);
24722 wxPyEndAllowThreads(__tstate);
24723 if (PyErr_Occurred()) SWIG_fail;
24724 }
24725 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24726 return resultobj;
24727 fail:
24728 return NULL;
24729 }
24730
24731
24732 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj = 0;
24734 wxDateTime *arg1 = (wxDateTime *) 0 ;
24735 wxDateTime::WeekDay arg2 ;
24736 wxDateTime *result = 0 ;
24737 void *argp1 = 0 ;
24738 int res1 = 0 ;
24739 int val2 ;
24740 int ecode2 = 0 ;
24741 PyObject * obj0 = 0 ;
24742 PyObject * obj1 = 0 ;
24743 char * kwnames[] = {
24744 (char *) "self",(char *) "weekday", NULL
24745 };
24746
24747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24749 if (!SWIG_IsOK(res1)) {
24750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24751 }
24752 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24753 ecode2 = SWIG_AsVal_int(obj1, &val2);
24754 if (!SWIG_IsOK(ecode2)) {
24755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24756 }
24757 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24758 {
24759 PyThreadState* __tstate = wxPyBeginAllowThreads();
24760 {
24761 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24762 result = (wxDateTime *) &_result_ref;
24763 }
24764 wxPyEndAllowThreads(__tstate);
24765 if (PyErr_Occurred()) SWIG_fail;
24766 }
24767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24768 return resultobj;
24769 fail:
24770 return NULL;
24771 }
24772
24773
24774 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24775 PyObject *resultobj = 0;
24776 wxDateTime *arg1 = (wxDateTime *) 0 ;
24777 wxDateTime::WeekDay arg2 ;
24778 wxDateTime result;
24779 void *argp1 = 0 ;
24780 int res1 = 0 ;
24781 int val2 ;
24782 int ecode2 = 0 ;
24783 PyObject * obj0 = 0 ;
24784 PyObject * obj1 = 0 ;
24785 char * kwnames[] = {
24786 (char *) "self",(char *) "weekday", NULL
24787 };
24788
24789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24791 if (!SWIG_IsOK(res1)) {
24792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24793 }
24794 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24795 ecode2 = SWIG_AsVal_int(obj1, &val2);
24796 if (!SWIG_IsOK(ecode2)) {
24797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24798 }
24799 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 result = (arg1)->GetPrevWeekDay(arg2);
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24807 return resultobj;
24808 fail:
24809 return NULL;
24810 }
24811
24812
24813 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24814 PyObject *resultobj = 0;
24815 wxDateTime *arg1 = (wxDateTime *) 0 ;
24816 wxDateTime::WeekDay arg2 ;
24817 int arg3 = (int) 1 ;
24818 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24819 int arg5 = (int) wxDateTime::Inv_Year ;
24820 bool result;
24821 void *argp1 = 0 ;
24822 int res1 = 0 ;
24823 int val2 ;
24824 int ecode2 = 0 ;
24825 int val3 ;
24826 int ecode3 = 0 ;
24827 int val4 ;
24828 int ecode4 = 0 ;
24829 int val5 ;
24830 int ecode5 = 0 ;
24831 PyObject * obj0 = 0 ;
24832 PyObject * obj1 = 0 ;
24833 PyObject * obj2 = 0 ;
24834 PyObject * obj3 = 0 ;
24835 PyObject * obj4 = 0 ;
24836 char * kwnames[] = {
24837 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24838 };
24839
24840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24842 if (!SWIG_IsOK(res1)) {
24843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24844 }
24845 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24846 ecode2 = SWIG_AsVal_int(obj1, &val2);
24847 if (!SWIG_IsOK(ecode2)) {
24848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24849 }
24850 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24851 if (obj2) {
24852 ecode3 = SWIG_AsVal_int(obj2, &val3);
24853 if (!SWIG_IsOK(ecode3)) {
24854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24855 }
24856 arg3 = static_cast< int >(val3);
24857 }
24858 if (obj3) {
24859 ecode4 = SWIG_AsVal_int(obj3, &val4);
24860 if (!SWIG_IsOK(ecode4)) {
24861 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24862 }
24863 arg4 = static_cast< wxDateTime::Month >(val4);
24864 }
24865 if (obj4) {
24866 ecode5 = SWIG_AsVal_int(obj4, &val5);
24867 if (!SWIG_IsOK(ecode5)) {
24868 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24869 }
24870 arg5 = static_cast< int >(val5);
24871 }
24872 {
24873 PyThreadState* __tstate = wxPyBeginAllowThreads();
24874 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 {
24879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24880 }
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24888 PyObject *resultobj = 0;
24889 wxDateTime *arg1 = (wxDateTime *) 0 ;
24890 wxDateTime::WeekDay arg2 ;
24891 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24892 int arg4 = (int) wxDateTime::Inv_Year ;
24893 bool result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 int val2 ;
24897 int ecode2 = 0 ;
24898 int val3 ;
24899 int ecode3 = 0 ;
24900 int val4 ;
24901 int ecode4 = 0 ;
24902 PyObject * obj0 = 0 ;
24903 PyObject * obj1 = 0 ;
24904 PyObject * obj2 = 0 ;
24905 PyObject * obj3 = 0 ;
24906 char * kwnames[] = {
24907 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24908 };
24909
24910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24912 if (!SWIG_IsOK(res1)) {
24913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24914 }
24915 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24916 ecode2 = SWIG_AsVal_int(obj1, &val2);
24917 if (!SWIG_IsOK(ecode2)) {
24918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24919 }
24920 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24921 if (obj2) {
24922 ecode3 = SWIG_AsVal_int(obj2, &val3);
24923 if (!SWIG_IsOK(ecode3)) {
24924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24925 }
24926 arg3 = static_cast< wxDateTime::Month >(val3);
24927 }
24928 if (obj3) {
24929 ecode4 = SWIG_AsVal_int(obj3, &val4);
24930 if (!SWIG_IsOK(ecode4)) {
24931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24932 }
24933 arg4 = static_cast< int >(val4);
24934 }
24935 {
24936 PyThreadState* __tstate = wxPyBeginAllowThreads();
24937 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 {
24942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24943 }
24944 return resultobj;
24945 fail:
24946 return NULL;
24947 }
24948
24949
24950 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24951 PyObject *resultobj = 0;
24952 wxDateTime *arg1 = (wxDateTime *) 0 ;
24953 wxDateTime::WeekDay arg2 ;
24954 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24955 int arg4 = (int) wxDateTime::Inv_Year ;
24956 wxDateTime result;
24957 void *argp1 = 0 ;
24958 int res1 = 0 ;
24959 int val2 ;
24960 int ecode2 = 0 ;
24961 int val3 ;
24962 int ecode3 = 0 ;
24963 int val4 ;
24964 int ecode4 = 0 ;
24965 PyObject * obj0 = 0 ;
24966 PyObject * obj1 = 0 ;
24967 PyObject * obj2 = 0 ;
24968 PyObject * obj3 = 0 ;
24969 char * kwnames[] = {
24970 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24971 };
24972
24973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24975 if (!SWIG_IsOK(res1)) {
24976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24977 }
24978 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24979 ecode2 = SWIG_AsVal_int(obj1, &val2);
24980 if (!SWIG_IsOK(ecode2)) {
24981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24982 }
24983 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24984 if (obj2) {
24985 ecode3 = SWIG_AsVal_int(obj2, &val3);
24986 if (!SWIG_IsOK(ecode3)) {
24987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24988 }
24989 arg3 = static_cast< wxDateTime::Month >(val3);
24990 }
24991 if (obj3) {
24992 ecode4 = SWIG_AsVal_int(obj3, &val4);
24993 if (!SWIG_IsOK(ecode4)) {
24994 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24995 }
24996 arg4 = static_cast< int >(val4);
24997 }
24998 {
24999 PyThreadState* __tstate = wxPyBeginAllowThreads();
25000 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25001 wxPyEndAllowThreads(__tstate);
25002 if (PyErr_Occurred()) SWIG_fail;
25003 }
25004 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25012 PyObject *resultobj = 0;
25013 wxDateTime *arg1 = (wxDateTime *) 0 ;
25014 int arg2 ;
25015 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25016 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25017 bool result;
25018 void *argp1 = 0 ;
25019 int res1 = 0 ;
25020 int val2 ;
25021 int ecode2 = 0 ;
25022 int val3 ;
25023 int ecode3 = 0 ;
25024 int val4 ;
25025 int ecode4 = 0 ;
25026 PyObject * obj0 = 0 ;
25027 PyObject * obj1 = 0 ;
25028 PyObject * obj2 = 0 ;
25029 PyObject * obj3 = 0 ;
25030 char * kwnames[] = {
25031 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25032 };
25033
25034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25036 if (!SWIG_IsOK(res1)) {
25037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25038 }
25039 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25040 ecode2 = SWIG_AsVal_int(obj1, &val2);
25041 if (!SWIG_IsOK(ecode2)) {
25042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25043 }
25044 arg2 = static_cast< int >(val2);
25045 if (obj2) {
25046 ecode3 = SWIG_AsVal_int(obj2, &val3);
25047 if (!SWIG_IsOK(ecode3)) {
25048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25049 }
25050 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25051 }
25052 if (obj3) {
25053 ecode4 = SWIG_AsVal_int(obj3, &val4);
25054 if (!SWIG_IsOK(ecode4)) {
25055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25056 }
25057 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25058 }
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 {
25066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25067 }
25068 return resultobj;
25069 fail:
25070 return NULL;
25071 }
25072
25073
25074 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25075 PyObject *resultobj = 0;
25076 wxDateTime *arg1 = (wxDateTime *) 0 ;
25077 int arg2 ;
25078 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25079 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25080 wxDateTime result;
25081 void *argp1 = 0 ;
25082 int res1 = 0 ;
25083 int val2 ;
25084 int ecode2 = 0 ;
25085 int val3 ;
25086 int ecode3 = 0 ;
25087 int val4 ;
25088 int ecode4 = 0 ;
25089 PyObject * obj0 = 0 ;
25090 PyObject * obj1 = 0 ;
25091 PyObject * obj2 = 0 ;
25092 PyObject * obj3 = 0 ;
25093 char * kwnames[] = {
25094 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25095 };
25096
25097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25099 if (!SWIG_IsOK(res1)) {
25100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25101 }
25102 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25103 ecode2 = SWIG_AsVal_int(obj1, &val2);
25104 if (!SWIG_IsOK(ecode2)) {
25105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25106 }
25107 arg2 = static_cast< int >(val2);
25108 if (obj2) {
25109 ecode3 = SWIG_AsVal_int(obj2, &val3);
25110 if (!SWIG_IsOK(ecode3)) {
25111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25112 }
25113 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25114 }
25115 if (obj3) {
25116 ecode4 = SWIG_AsVal_int(obj3, &val4);
25117 if (!SWIG_IsOK(ecode4)) {
25118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25119 }
25120 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25121 }
25122 {
25123 PyThreadState* __tstate = wxPyBeginAllowThreads();
25124 result = (arg1)->GetWeek(arg2,arg3,arg4);
25125 wxPyEndAllowThreads(__tstate);
25126 if (PyErr_Occurred()) SWIG_fail;
25127 }
25128 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25136 PyObject *resultobj = 0;
25137 int arg1 ;
25138 int arg2 ;
25139 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25140 wxDateTime result;
25141 int val1 ;
25142 int ecode1 = 0 ;
25143 int val2 ;
25144 int ecode2 = 0 ;
25145 int val3 ;
25146 int ecode3 = 0 ;
25147 PyObject * obj0 = 0 ;
25148 PyObject * obj1 = 0 ;
25149 PyObject * obj2 = 0 ;
25150 char * kwnames[] = {
25151 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25152 };
25153
25154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25155 ecode1 = SWIG_AsVal_int(obj0, &val1);
25156 if (!SWIG_IsOK(ecode1)) {
25157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25158 }
25159 arg1 = static_cast< int >(val1);
25160 ecode2 = SWIG_AsVal_int(obj1, &val2);
25161 if (!SWIG_IsOK(ecode2)) {
25162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25163 }
25164 arg2 = static_cast< int >(val2);
25165 if (obj2) {
25166 ecode3 = SWIG_AsVal_int(obj2, &val3);
25167 if (!SWIG_IsOK(ecode3)) {
25168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25169 }
25170 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25171 }
25172 {
25173 PyThreadState* __tstate = wxPyBeginAllowThreads();
25174 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25175 wxPyEndAllowThreads(__tstate);
25176 if (PyErr_Occurred()) SWIG_fail;
25177 }
25178 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25179 return resultobj;
25180 fail:
25181 return NULL;
25182 }
25183
25184
25185 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25186 PyObject *resultobj = 0;
25187 wxDateTime *arg1 = (wxDateTime *) 0 ;
25188 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25189 int arg3 = (int) wxDateTime::Inv_Year ;
25190 wxDateTime *result = 0 ;
25191 void *argp1 = 0 ;
25192 int res1 = 0 ;
25193 int val2 ;
25194 int ecode2 = 0 ;
25195 int val3 ;
25196 int ecode3 = 0 ;
25197 PyObject * obj0 = 0 ;
25198 PyObject * obj1 = 0 ;
25199 PyObject * obj2 = 0 ;
25200 char * kwnames[] = {
25201 (char *) "self",(char *) "month",(char *) "year", NULL
25202 };
25203
25204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25206 if (!SWIG_IsOK(res1)) {
25207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25208 }
25209 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25210 if (obj1) {
25211 ecode2 = SWIG_AsVal_int(obj1, &val2);
25212 if (!SWIG_IsOK(ecode2)) {
25213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25214 }
25215 arg2 = static_cast< wxDateTime::Month >(val2);
25216 }
25217 if (obj2) {
25218 ecode3 = SWIG_AsVal_int(obj2, &val3);
25219 if (!SWIG_IsOK(ecode3)) {
25220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25221 }
25222 arg3 = static_cast< int >(val3);
25223 }
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 {
25227 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25228 result = (wxDateTime *) &_result_ref;
25229 }
25230 wxPyEndAllowThreads(__tstate);
25231 if (PyErr_Occurred()) SWIG_fail;
25232 }
25233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25241 PyObject *resultobj = 0;
25242 wxDateTime *arg1 = (wxDateTime *) 0 ;
25243 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25244 int arg3 = (int) wxDateTime::Inv_Year ;
25245 wxDateTime result;
25246 void *argp1 = 0 ;
25247 int res1 = 0 ;
25248 int val2 ;
25249 int ecode2 = 0 ;
25250 int val3 ;
25251 int ecode3 = 0 ;
25252 PyObject * obj0 = 0 ;
25253 PyObject * obj1 = 0 ;
25254 PyObject * obj2 = 0 ;
25255 char * kwnames[] = {
25256 (char *) "self",(char *) "month",(char *) "year", NULL
25257 };
25258
25259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25261 if (!SWIG_IsOK(res1)) {
25262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25263 }
25264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25265 if (obj1) {
25266 ecode2 = SWIG_AsVal_int(obj1, &val2);
25267 if (!SWIG_IsOK(ecode2)) {
25268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25269 }
25270 arg2 = static_cast< wxDateTime::Month >(val2);
25271 }
25272 if (obj2) {
25273 ecode3 = SWIG_AsVal_int(obj2, &val3);
25274 if (!SWIG_IsOK(ecode3)) {
25275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25276 }
25277 arg3 = static_cast< int >(val3);
25278 }
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 result = (arg1)->GetLastMonthDay(arg2,arg3);
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25293 PyObject *resultobj = 0;
25294 wxDateTime *arg1 = (wxDateTime *) 0 ;
25295 int arg2 ;
25296 wxDateTime *result = 0 ;
25297 void *argp1 = 0 ;
25298 int res1 = 0 ;
25299 int val2 ;
25300 int ecode2 = 0 ;
25301 PyObject * obj0 = 0 ;
25302 PyObject * obj1 = 0 ;
25303 char * kwnames[] = {
25304 (char *) "self",(char *) "yday", NULL
25305 };
25306
25307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25309 if (!SWIG_IsOK(res1)) {
25310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25311 }
25312 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25313 ecode2 = SWIG_AsVal_int(obj1, &val2);
25314 if (!SWIG_IsOK(ecode2)) {
25315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25316 }
25317 arg2 = static_cast< int >(val2);
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 {
25321 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25322 result = (wxDateTime *) &_result_ref;
25323 }
25324 wxPyEndAllowThreads(__tstate);
25325 if (PyErr_Occurred()) SWIG_fail;
25326 }
25327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25328 return resultobj;
25329 fail:
25330 return NULL;
25331 }
25332
25333
25334 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj = 0;
25336 wxDateTime *arg1 = (wxDateTime *) 0 ;
25337 int arg2 ;
25338 wxDateTime result;
25339 void *argp1 = 0 ;
25340 int res1 = 0 ;
25341 int val2 ;
25342 int ecode2 = 0 ;
25343 PyObject * obj0 = 0 ;
25344 PyObject * obj1 = 0 ;
25345 char * kwnames[] = {
25346 (char *) "self",(char *) "yday", NULL
25347 };
25348
25349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25351 if (!SWIG_IsOK(res1)) {
25352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25353 }
25354 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25355 ecode2 = SWIG_AsVal_int(obj1, &val2);
25356 if (!SWIG_IsOK(ecode2)) {
25357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25358 }
25359 arg2 = static_cast< int >(val2);
25360 {
25361 PyThreadState* __tstate = wxPyBeginAllowThreads();
25362 result = (arg1)->GetYearDay(arg2);
25363 wxPyEndAllowThreads(__tstate);
25364 if (PyErr_Occurred()) SWIG_fail;
25365 }
25366 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25367 return resultobj;
25368 fail:
25369 return NULL;
25370 }
25371
25372
25373 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25374 PyObject *resultobj = 0;
25375 wxDateTime *arg1 = (wxDateTime *) 0 ;
25376 double result;
25377 void *argp1 = 0 ;
25378 int res1 = 0 ;
25379 PyObject *swig_obj[1] ;
25380
25381 if (!args) SWIG_fail;
25382 swig_obj[0] = args;
25383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25384 if (!SWIG_IsOK(res1)) {
25385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25386 }
25387 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25388 {
25389 PyThreadState* __tstate = wxPyBeginAllowThreads();
25390 result = (double)(arg1)->GetJulianDayNumber();
25391 wxPyEndAllowThreads(__tstate);
25392 if (PyErr_Occurred()) SWIG_fail;
25393 }
25394 resultobj = SWIG_From_double(static_cast< double >(result));
25395 return resultobj;
25396 fail:
25397 return NULL;
25398 }
25399
25400
25401 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25402 PyObject *resultobj = 0;
25403 wxDateTime *arg1 = (wxDateTime *) 0 ;
25404 double result;
25405 void *argp1 = 0 ;
25406 int res1 = 0 ;
25407 PyObject *swig_obj[1] ;
25408
25409 if (!args) SWIG_fail;
25410 swig_obj[0] = args;
25411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25412 if (!SWIG_IsOK(res1)) {
25413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25414 }
25415 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 result = (double)(arg1)->GetJDN();
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 resultobj = SWIG_From_double(static_cast< double >(result));
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 PyObject *resultobj = 0;
25431 wxDateTime *arg1 = (wxDateTime *) 0 ;
25432 double result;
25433 void *argp1 = 0 ;
25434 int res1 = 0 ;
25435 PyObject *swig_obj[1] ;
25436
25437 if (!args) SWIG_fail;
25438 swig_obj[0] = args;
25439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25440 if (!SWIG_IsOK(res1)) {
25441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25442 }
25443 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25444 {
25445 PyThreadState* __tstate = wxPyBeginAllowThreads();
25446 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25447 wxPyEndAllowThreads(__tstate);
25448 if (PyErr_Occurred()) SWIG_fail;
25449 }
25450 resultobj = SWIG_From_double(static_cast< double >(result));
25451 return resultobj;
25452 fail:
25453 return NULL;
25454 }
25455
25456
25457 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25458 PyObject *resultobj = 0;
25459 wxDateTime *arg1 = (wxDateTime *) 0 ;
25460 double result;
25461 void *argp1 = 0 ;
25462 int res1 = 0 ;
25463 PyObject *swig_obj[1] ;
25464
25465 if (!args) SWIG_fail;
25466 swig_obj[0] = args;
25467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25468 if (!SWIG_IsOK(res1)) {
25469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25470 }
25471 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25472 {
25473 PyThreadState* __tstate = wxPyBeginAllowThreads();
25474 result = (double)(arg1)->GetMJD();
25475 wxPyEndAllowThreads(__tstate);
25476 if (PyErr_Occurred()) SWIG_fail;
25477 }
25478 resultobj = SWIG_From_double(static_cast< double >(result));
25479 return resultobj;
25480 fail:
25481 return NULL;
25482 }
25483
25484
25485 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25486 PyObject *resultobj = 0;
25487 wxDateTime *arg1 = (wxDateTime *) 0 ;
25488 double result;
25489 void *argp1 = 0 ;
25490 int res1 = 0 ;
25491 PyObject *swig_obj[1] ;
25492
25493 if (!args) SWIG_fail;
25494 swig_obj[0] = args;
25495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25496 if (!SWIG_IsOK(res1)) {
25497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25498 }
25499 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25500 {
25501 PyThreadState* __tstate = wxPyBeginAllowThreads();
25502 result = (double)(arg1)->GetRataDie();
25503 wxPyEndAllowThreads(__tstate);
25504 if (PyErr_Occurred()) SWIG_fail;
25505 }
25506 resultobj = SWIG_From_double(static_cast< double >(result));
25507 return resultobj;
25508 fail:
25509 return NULL;
25510 }
25511
25512
25513 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25514 PyObject *resultobj = 0;
25515 wxDateTime *arg1 = (wxDateTime *) 0 ;
25516 wxDateTime::TimeZone *arg2 = 0 ;
25517 bool arg3 = (bool) false ;
25518 wxDateTime result;
25519 void *argp1 = 0 ;
25520 int res1 = 0 ;
25521 bool temp2 = false ;
25522 bool val3 ;
25523 int ecode3 = 0 ;
25524 PyObject * obj0 = 0 ;
25525 PyObject * obj1 = 0 ;
25526 PyObject * obj2 = 0 ;
25527 char * kwnames[] = {
25528 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25529 };
25530
25531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25533 if (!SWIG_IsOK(res1)) {
25534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25535 }
25536 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25537 {
25538 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25539 temp2 = true;
25540 }
25541 if (obj2) {
25542 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25543 if (!SWIG_IsOK(ecode3)) {
25544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25545 }
25546 arg3 = static_cast< bool >(val3);
25547 }
25548 {
25549 PyThreadState* __tstate = wxPyBeginAllowThreads();
25550 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25555 {
25556 if (temp2) delete arg2;
25557 }
25558 return resultobj;
25559 fail:
25560 {
25561 if (temp2) delete arg2;
25562 }
25563 return NULL;
25564 }
25565
25566
25567 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25568 PyObject *resultobj = 0;
25569 wxDateTime *arg1 = (wxDateTime *) 0 ;
25570 wxDateTime::TimeZone *arg2 = 0 ;
25571 bool arg3 = (bool) false ;
25572 wxDateTime *result = 0 ;
25573 void *argp1 = 0 ;
25574 int res1 = 0 ;
25575 bool temp2 = false ;
25576 bool val3 ;
25577 int ecode3 = 0 ;
25578 PyObject * obj0 = 0 ;
25579 PyObject * obj1 = 0 ;
25580 PyObject * obj2 = 0 ;
25581 char * kwnames[] = {
25582 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25583 };
25584
25585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25587 if (!SWIG_IsOK(res1)) {
25588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25589 }
25590 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25591 {
25592 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25593 temp2 = true;
25594 }
25595 if (obj2) {
25596 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25597 if (!SWIG_IsOK(ecode3)) {
25598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25599 }
25600 arg3 = static_cast< bool >(val3);
25601 }
25602 {
25603 PyThreadState* __tstate = wxPyBeginAllowThreads();
25604 {
25605 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25606 result = (wxDateTime *) &_result_ref;
25607 }
25608 wxPyEndAllowThreads(__tstate);
25609 if (PyErr_Occurred()) SWIG_fail;
25610 }
25611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25612 {
25613 if (temp2) delete arg2;
25614 }
25615 return resultobj;
25616 fail:
25617 {
25618 if (temp2) delete arg2;
25619 }
25620 return NULL;
25621 }
25622
25623
25624 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25625 PyObject *resultobj = 0;
25626 wxDateTime *arg1 = (wxDateTime *) 0 ;
25627 wxDateTime::TimeZone *arg2 = 0 ;
25628 bool arg3 = (bool) false ;
25629 wxDateTime result;
25630 void *argp1 = 0 ;
25631 int res1 = 0 ;
25632 bool temp2 = false ;
25633 bool val3 ;
25634 int ecode3 = 0 ;
25635 PyObject * obj0 = 0 ;
25636 PyObject * obj1 = 0 ;
25637 PyObject * obj2 = 0 ;
25638 char * kwnames[] = {
25639 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25640 };
25641
25642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25644 if (!SWIG_IsOK(res1)) {
25645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25646 }
25647 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25648 {
25649 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25650 temp2 = true;
25651 }
25652 if (obj2) {
25653 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25654 if (!SWIG_IsOK(ecode3)) {
25655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25656 }
25657 arg3 = static_cast< bool >(val3);
25658 }
25659 {
25660 PyThreadState* __tstate = wxPyBeginAllowThreads();
25661 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25662 wxPyEndAllowThreads(__tstate);
25663 if (PyErr_Occurred()) SWIG_fail;
25664 }
25665 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25666 {
25667 if (temp2) delete arg2;
25668 }
25669 return resultobj;
25670 fail:
25671 {
25672 if (temp2) delete arg2;
25673 }
25674 return NULL;
25675 }
25676
25677
25678 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25679 PyObject *resultobj = 0;
25680 wxDateTime *arg1 = (wxDateTime *) 0 ;
25681 wxDateTime::TimeZone *arg2 = 0 ;
25682 bool arg3 = (bool) false ;
25683 wxDateTime *result = 0 ;
25684 void *argp1 = 0 ;
25685 int res1 = 0 ;
25686 bool temp2 = false ;
25687 bool val3 ;
25688 int ecode3 = 0 ;
25689 PyObject * obj0 = 0 ;
25690 PyObject * obj1 = 0 ;
25691 PyObject * obj2 = 0 ;
25692 char * kwnames[] = {
25693 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25694 };
25695
25696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25698 if (!SWIG_IsOK(res1)) {
25699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25700 }
25701 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25702 {
25703 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25704 temp2 = true;
25705 }
25706 if (obj2) {
25707 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25708 if (!SWIG_IsOK(ecode3)) {
25709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25710 }
25711 arg3 = static_cast< bool >(val3);
25712 }
25713 {
25714 PyThreadState* __tstate = wxPyBeginAllowThreads();
25715 {
25716 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25717 result = (wxDateTime *) &_result_ref;
25718 }
25719 wxPyEndAllowThreads(__tstate);
25720 if (PyErr_Occurred()) SWIG_fail;
25721 }
25722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25723 {
25724 if (temp2) delete arg2;
25725 }
25726 return resultobj;
25727 fail:
25728 {
25729 if (temp2) delete arg2;
25730 }
25731 return NULL;
25732 }
25733
25734
25735 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25736 PyObject *resultobj = 0;
25737 wxDateTime *arg1 = (wxDateTime *) 0 ;
25738 bool arg2 = (bool) false ;
25739 wxDateTime result;
25740 void *argp1 = 0 ;
25741 int res1 = 0 ;
25742 bool val2 ;
25743 int ecode2 = 0 ;
25744 PyObject * obj0 = 0 ;
25745 PyObject * obj1 = 0 ;
25746 char * kwnames[] = {
25747 (char *) "self",(char *) "noDST", NULL
25748 };
25749
25750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25754 }
25755 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25756 if (obj1) {
25757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25758 if (!SWIG_IsOK(ecode2)) {
25759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25760 }
25761 arg2 = static_cast< bool >(val2);
25762 }
25763 {
25764 PyThreadState* __tstate = wxPyBeginAllowThreads();
25765 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25766 wxPyEndAllowThreads(__tstate);
25767 if (PyErr_Occurred()) SWIG_fail;
25768 }
25769 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25770 return resultobj;
25771 fail:
25772 return NULL;
25773 }
25774
25775
25776 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25777 PyObject *resultobj = 0;
25778 wxDateTime *arg1 = (wxDateTime *) 0 ;
25779 bool arg2 = (bool) false ;
25780 wxDateTime *result = 0 ;
25781 void *argp1 = 0 ;
25782 int res1 = 0 ;
25783 bool val2 ;
25784 int ecode2 = 0 ;
25785 PyObject * obj0 = 0 ;
25786 PyObject * obj1 = 0 ;
25787 char * kwnames[] = {
25788 (char *) "self",(char *) "noDST", NULL
25789 };
25790
25791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25793 if (!SWIG_IsOK(res1)) {
25794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25795 }
25796 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25797 if (obj1) {
25798 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25799 if (!SWIG_IsOK(ecode2)) {
25800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25801 }
25802 arg2 = static_cast< bool >(val2);
25803 }
25804 {
25805 PyThreadState* __tstate = wxPyBeginAllowThreads();
25806 {
25807 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25808 result = (wxDateTime *) &_result_ref;
25809 }
25810 wxPyEndAllowThreads(__tstate);
25811 if (PyErr_Occurred()) SWIG_fail;
25812 }
25813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25814 return resultobj;
25815 fail:
25816 return NULL;
25817 }
25818
25819
25820 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25821 PyObject *resultobj = 0;
25822 wxDateTime *arg1 = (wxDateTime *) 0 ;
25823 bool arg2 = (bool) false ;
25824 wxDateTime result;
25825 void *argp1 = 0 ;
25826 int res1 = 0 ;
25827 bool val2 ;
25828 int ecode2 = 0 ;
25829 PyObject * obj0 = 0 ;
25830 PyObject * obj1 = 0 ;
25831 char * kwnames[] = {
25832 (char *) "self",(char *) "noDST", NULL
25833 };
25834
25835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25837 if (!SWIG_IsOK(res1)) {
25838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25839 }
25840 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25841 if (obj1) {
25842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25843 if (!SWIG_IsOK(ecode2)) {
25844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25845 }
25846 arg2 = static_cast< bool >(val2);
25847 }
25848 {
25849 PyThreadState* __tstate = wxPyBeginAllowThreads();
25850 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25851 wxPyEndAllowThreads(__tstate);
25852 if (PyErr_Occurred()) SWIG_fail;
25853 }
25854 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25855 return resultobj;
25856 fail:
25857 return NULL;
25858 }
25859
25860
25861 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25862 PyObject *resultobj = 0;
25863 wxDateTime *arg1 = (wxDateTime *) 0 ;
25864 bool arg2 = (bool) false ;
25865 wxDateTime *result = 0 ;
25866 void *argp1 = 0 ;
25867 int res1 = 0 ;
25868 bool val2 ;
25869 int ecode2 = 0 ;
25870 PyObject * obj0 = 0 ;
25871 PyObject * obj1 = 0 ;
25872 char * kwnames[] = {
25873 (char *) "self",(char *) "noDST", NULL
25874 };
25875
25876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25878 if (!SWIG_IsOK(res1)) {
25879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25880 }
25881 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25882 if (obj1) {
25883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25884 if (!SWIG_IsOK(ecode2)) {
25885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25886 }
25887 arg2 = static_cast< bool >(val2);
25888 }
25889 {
25890 PyThreadState* __tstate = wxPyBeginAllowThreads();
25891 {
25892 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25893 result = (wxDateTime *) &_result_ref;
25894 }
25895 wxPyEndAllowThreads(__tstate);
25896 if (PyErr_Occurred()) SWIG_fail;
25897 }
25898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25899 return resultobj;
25900 fail:
25901 return NULL;
25902 }
25903
25904
25905 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25906 PyObject *resultobj = 0;
25907 wxDateTime *arg1 = (wxDateTime *) 0 ;
25908 bool arg2 = (bool) false ;
25909 wxDateTime result;
25910 void *argp1 = 0 ;
25911 int res1 = 0 ;
25912 bool val2 ;
25913 int ecode2 = 0 ;
25914 PyObject * obj0 = 0 ;
25915 PyObject * obj1 = 0 ;
25916 char * kwnames[] = {
25917 (char *) "self",(char *) "noDST", NULL
25918 };
25919
25920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25922 if (!SWIG_IsOK(res1)) {
25923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25924 }
25925 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25926 if (obj1) {
25927 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25928 if (!SWIG_IsOK(ecode2)) {
25929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
25930 }
25931 arg2 = static_cast< bool >(val2);
25932 }
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25940 return resultobj;
25941 fail:
25942 return NULL;
25943 }
25944
25945
25946 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25947 PyObject *resultobj = 0;
25948 wxDateTime *arg1 = (wxDateTime *) 0 ;
25949 bool arg2 = (bool) false ;
25950 wxDateTime *result = 0 ;
25951 void *argp1 = 0 ;
25952 int res1 = 0 ;
25953 bool val2 ;
25954 int ecode2 = 0 ;
25955 PyObject * obj0 = 0 ;
25956 PyObject * obj1 = 0 ;
25957 char * kwnames[] = {
25958 (char *) "self",(char *) "noDST", NULL
25959 };
25960
25961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25963 if (!SWIG_IsOK(res1)) {
25964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25965 }
25966 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25967 if (obj1) {
25968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25969 if (!SWIG_IsOK(ecode2)) {
25970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25971 }
25972 arg2 = static_cast< bool >(val2);
25973 }
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 {
25977 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25978 result = (wxDateTime *) &_result_ref;
25979 }
25980 wxPyEndAllowThreads(__tstate);
25981 if (PyErr_Occurred()) SWIG_fail;
25982 }
25983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25984 return resultobj;
25985 fail:
25986 return NULL;
25987 }
25988
25989
25990 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25991 PyObject *resultobj = 0;
25992 wxDateTime *arg1 = (wxDateTime *) 0 ;
25993 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25994 int result;
25995 void *argp1 = 0 ;
25996 int res1 = 0 ;
25997 int val2 ;
25998 int ecode2 = 0 ;
25999 PyObject * obj0 = 0 ;
26000 PyObject * obj1 = 0 ;
26001 char * kwnames[] = {
26002 (char *) "self",(char *) "country", NULL
26003 };
26004
26005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26007 if (!SWIG_IsOK(res1)) {
26008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26009 }
26010 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26011 if (obj1) {
26012 ecode2 = SWIG_AsVal_int(obj1, &val2);
26013 if (!SWIG_IsOK(ecode2)) {
26014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26015 }
26016 arg2 = static_cast< wxDateTime::Country >(val2);
26017 }
26018 {
26019 PyThreadState* __tstate = wxPyBeginAllowThreads();
26020 result = (int)(arg1)->IsDST(arg2);
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 resultobj = SWIG_From_int(static_cast< int >(result));
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26032 PyObject *resultobj = 0;
26033 wxDateTime *arg1 = (wxDateTime *) 0 ;
26034 bool result;
26035 void *argp1 = 0 ;
26036 int res1 = 0 ;
26037 PyObject *swig_obj[1] ;
26038
26039 if (!args) SWIG_fail;
26040 swig_obj[0] = args;
26041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26044 }
26045 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 result = (bool)((wxDateTime const *)arg1)->IsValid();
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 {
26053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26054 }
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26062 PyObject *resultobj = 0;
26063 wxDateTime *arg1 = (wxDateTime *) 0 ;
26064 time_t result;
26065 void *argp1 = 0 ;
26066 int res1 = 0 ;
26067 PyObject *swig_obj[1] ;
26068
26069 if (!args) SWIG_fail;
26070 swig_obj[0] = args;
26071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26072 if (!SWIG_IsOK(res1)) {
26073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26074 }
26075 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26090 PyObject *resultobj = 0;
26091 wxDateTime *arg1 = (wxDateTime *) 0 ;
26092 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26093 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26094 int result;
26095 void *argp1 = 0 ;
26096 int res1 = 0 ;
26097 bool temp2 = false ;
26098 PyObject * obj0 = 0 ;
26099 PyObject * obj1 = 0 ;
26100 char * kwnames[] = {
26101 (char *) "self",(char *) "tz", NULL
26102 };
26103
26104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26106 if (!SWIG_IsOK(res1)) {
26107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26108 }
26109 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26110 if (obj1) {
26111 {
26112 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26113 temp2 = true;
26114 }
26115 }
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 resultobj = SWIG_From_int(static_cast< int >(result));
26123 {
26124 if (temp2) delete arg2;
26125 }
26126 return resultobj;
26127 fail:
26128 {
26129 if (temp2) delete arg2;
26130 }
26131 return NULL;
26132 }
26133
26134
26135 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26136 PyObject *resultobj = 0;
26137 wxDateTime *arg1 = (wxDateTime *) 0 ;
26138 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26139 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26140 wxDateTime::Month result;
26141 void *argp1 = 0 ;
26142 int res1 = 0 ;
26143 bool temp2 = false ;
26144 PyObject * obj0 = 0 ;
26145 PyObject * obj1 = 0 ;
26146 char * kwnames[] = {
26147 (char *) "self",(char *) "tz", NULL
26148 };
26149
26150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26152 if (!SWIG_IsOK(res1)) {
26153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26154 }
26155 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26156 if (obj1) {
26157 {
26158 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26159 temp2 = true;
26160 }
26161 }
26162 {
26163 PyThreadState* __tstate = wxPyBeginAllowThreads();
26164 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26165 wxPyEndAllowThreads(__tstate);
26166 if (PyErr_Occurred()) SWIG_fail;
26167 }
26168 resultobj = SWIG_From_int(static_cast< int >(result));
26169 {
26170 if (temp2) delete arg2;
26171 }
26172 return resultobj;
26173 fail:
26174 {
26175 if (temp2) delete arg2;
26176 }
26177 return NULL;
26178 }
26179
26180
26181 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26182 PyObject *resultobj = 0;
26183 wxDateTime *arg1 = (wxDateTime *) 0 ;
26184 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26185 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26186 int result;
26187 void *argp1 = 0 ;
26188 int res1 = 0 ;
26189 bool temp2 = false ;
26190 PyObject * obj0 = 0 ;
26191 PyObject * obj1 = 0 ;
26192 char * kwnames[] = {
26193 (char *) "self",(char *) "tz", NULL
26194 };
26195
26196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26198 if (!SWIG_IsOK(res1)) {
26199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26200 }
26201 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26202 if (obj1) {
26203 {
26204 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26205 temp2 = true;
26206 }
26207 }
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 resultobj = SWIG_From_int(static_cast< int >(result));
26215 {
26216 if (temp2) delete arg2;
26217 }
26218 return resultobj;
26219 fail:
26220 {
26221 if (temp2) delete arg2;
26222 }
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26228 PyObject *resultobj = 0;
26229 wxDateTime *arg1 = (wxDateTime *) 0 ;
26230 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26231 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26232 wxDateTime::WeekDay result;
26233 void *argp1 = 0 ;
26234 int res1 = 0 ;
26235 bool temp2 = false ;
26236 PyObject * obj0 = 0 ;
26237 PyObject * obj1 = 0 ;
26238 char * kwnames[] = {
26239 (char *) "self",(char *) "tz", NULL
26240 };
26241
26242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26244 if (!SWIG_IsOK(res1)) {
26245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26246 }
26247 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26248 if (obj1) {
26249 {
26250 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26251 temp2 = true;
26252 }
26253 }
26254 {
26255 PyThreadState* __tstate = wxPyBeginAllowThreads();
26256 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26257 wxPyEndAllowThreads(__tstate);
26258 if (PyErr_Occurred()) SWIG_fail;
26259 }
26260 resultobj = SWIG_From_int(static_cast< int >(result));
26261 {
26262 if (temp2) delete arg2;
26263 }
26264 return resultobj;
26265 fail:
26266 {
26267 if (temp2) delete arg2;
26268 }
26269 return NULL;
26270 }
26271
26272
26273 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26274 PyObject *resultobj = 0;
26275 wxDateTime *arg1 = (wxDateTime *) 0 ;
26276 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26277 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26278 int result;
26279 void *argp1 = 0 ;
26280 int res1 = 0 ;
26281 bool temp2 = false ;
26282 PyObject * obj0 = 0 ;
26283 PyObject * obj1 = 0 ;
26284 char * kwnames[] = {
26285 (char *) "self",(char *) "tz", NULL
26286 };
26287
26288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26290 if (!SWIG_IsOK(res1)) {
26291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26292 }
26293 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26294 if (obj1) {
26295 {
26296 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26297 temp2 = true;
26298 }
26299 }
26300 {
26301 PyThreadState* __tstate = wxPyBeginAllowThreads();
26302 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 resultobj = SWIG_From_int(static_cast< int >(result));
26307 {
26308 if (temp2) delete arg2;
26309 }
26310 return resultobj;
26311 fail:
26312 {
26313 if (temp2) delete arg2;
26314 }
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj = 0;
26321 wxDateTime *arg1 = (wxDateTime *) 0 ;
26322 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26323 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26324 int result;
26325 void *argp1 = 0 ;
26326 int res1 = 0 ;
26327 bool temp2 = false ;
26328 PyObject * obj0 = 0 ;
26329 PyObject * obj1 = 0 ;
26330 char * kwnames[] = {
26331 (char *) "self",(char *) "tz", NULL
26332 };
26333
26334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26336 if (!SWIG_IsOK(res1)) {
26337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26338 }
26339 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26340 if (obj1) {
26341 {
26342 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26343 temp2 = true;
26344 }
26345 }
26346 {
26347 PyThreadState* __tstate = wxPyBeginAllowThreads();
26348 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26349 wxPyEndAllowThreads(__tstate);
26350 if (PyErr_Occurred()) SWIG_fail;
26351 }
26352 resultobj = SWIG_From_int(static_cast< int >(result));
26353 {
26354 if (temp2) delete arg2;
26355 }
26356 return resultobj;
26357 fail:
26358 {
26359 if (temp2) delete arg2;
26360 }
26361 return NULL;
26362 }
26363
26364
26365 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26366 PyObject *resultobj = 0;
26367 wxDateTime *arg1 = (wxDateTime *) 0 ;
26368 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26369 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26370 int result;
26371 void *argp1 = 0 ;
26372 int res1 = 0 ;
26373 bool temp2 = false ;
26374 PyObject * obj0 = 0 ;
26375 PyObject * obj1 = 0 ;
26376 char * kwnames[] = {
26377 (char *) "self",(char *) "tz", NULL
26378 };
26379
26380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26382 if (!SWIG_IsOK(res1)) {
26383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26384 }
26385 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26386 if (obj1) {
26387 {
26388 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26389 temp2 = true;
26390 }
26391 }
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_From_int(static_cast< int >(result));
26399 {
26400 if (temp2) delete arg2;
26401 }
26402 return resultobj;
26403 fail:
26404 {
26405 if (temp2) delete arg2;
26406 }
26407 return NULL;
26408 }
26409
26410
26411 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26412 PyObject *resultobj = 0;
26413 wxDateTime *arg1 = (wxDateTime *) 0 ;
26414 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26415 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26416 int result;
26417 void *argp1 = 0 ;
26418 int res1 = 0 ;
26419 bool temp2 = false ;
26420 PyObject * obj0 = 0 ;
26421 PyObject * obj1 = 0 ;
26422 char * kwnames[] = {
26423 (char *) "self",(char *) "tz", NULL
26424 };
26425
26426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26428 if (!SWIG_IsOK(res1)) {
26429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26430 }
26431 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26432 if (obj1) {
26433 {
26434 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26435 temp2 = true;
26436 }
26437 }
26438 {
26439 PyThreadState* __tstate = wxPyBeginAllowThreads();
26440 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 resultobj = SWIG_From_int(static_cast< int >(result));
26445 {
26446 if (temp2) delete arg2;
26447 }
26448 return resultobj;
26449 fail:
26450 {
26451 if (temp2) delete arg2;
26452 }
26453 return NULL;
26454 }
26455
26456
26457 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj = 0;
26459 wxDateTime *arg1 = (wxDateTime *) 0 ;
26460 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26461 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26462 int result;
26463 void *argp1 = 0 ;
26464 int res1 = 0 ;
26465 bool temp2 = false ;
26466 PyObject * obj0 = 0 ;
26467 PyObject * obj1 = 0 ;
26468 char * kwnames[] = {
26469 (char *) "self",(char *) "tz", NULL
26470 };
26471
26472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26474 if (!SWIG_IsOK(res1)) {
26475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26476 }
26477 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26478 if (obj1) {
26479 {
26480 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26481 temp2 = true;
26482 }
26483 }
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 resultobj = SWIG_From_int(static_cast< int >(result));
26491 {
26492 if (temp2) delete arg2;
26493 }
26494 return resultobj;
26495 fail:
26496 {
26497 if (temp2) delete arg2;
26498 }
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26504 PyObject *resultobj = 0;
26505 wxDateTime *arg1 = (wxDateTime *) 0 ;
26506 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26507 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26508 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26509 int result;
26510 void *argp1 = 0 ;
26511 int res1 = 0 ;
26512 int val2 ;
26513 int ecode2 = 0 ;
26514 bool temp3 = false ;
26515 PyObject * obj0 = 0 ;
26516 PyObject * obj1 = 0 ;
26517 PyObject * obj2 = 0 ;
26518 char * kwnames[] = {
26519 (char *) "self",(char *) "flags",(char *) "tz", NULL
26520 };
26521
26522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26524 if (!SWIG_IsOK(res1)) {
26525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26526 }
26527 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26528 if (obj1) {
26529 ecode2 = SWIG_AsVal_int(obj1, &val2);
26530 if (!SWIG_IsOK(ecode2)) {
26531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26532 }
26533 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26534 }
26535 if (obj2) {
26536 {
26537 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26538 temp3 = true;
26539 }
26540 }
26541 {
26542 PyThreadState* __tstate = wxPyBeginAllowThreads();
26543 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26544 wxPyEndAllowThreads(__tstate);
26545 if (PyErr_Occurred()) SWIG_fail;
26546 }
26547 resultobj = SWIG_From_int(static_cast< int >(result));
26548 {
26549 if (temp3) delete arg3;
26550 }
26551 return resultobj;
26552 fail:
26553 {
26554 if (temp3) delete arg3;
26555 }
26556 return NULL;
26557 }
26558
26559
26560 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj = 0;
26562 wxDateTime *arg1 = (wxDateTime *) 0 ;
26563 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26564 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26565 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26566 int result;
26567 void *argp1 = 0 ;
26568 int res1 = 0 ;
26569 int val2 ;
26570 int ecode2 = 0 ;
26571 bool temp3 = false ;
26572 PyObject * obj0 = 0 ;
26573 PyObject * obj1 = 0 ;
26574 PyObject * obj2 = 0 ;
26575 char * kwnames[] = {
26576 (char *) "self",(char *) "flags",(char *) "tz", NULL
26577 };
26578
26579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) 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_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26583 }
26584 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26585 if (obj1) {
26586 ecode2 = SWIG_AsVal_int(obj1, &val2);
26587 if (!SWIG_IsOK(ecode2)) {
26588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26589 }
26590 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26591 }
26592 if (obj2) {
26593 {
26594 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26595 temp3 = true;
26596 }
26597 }
26598 {
26599 PyThreadState* __tstate = wxPyBeginAllowThreads();
26600 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26601 wxPyEndAllowThreads(__tstate);
26602 if (PyErr_Occurred()) SWIG_fail;
26603 }
26604 resultobj = SWIG_From_int(static_cast< int >(result));
26605 {
26606 if (temp3) delete arg3;
26607 }
26608 return resultobj;
26609 fail:
26610 {
26611 if (temp3) delete arg3;
26612 }
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26618 PyObject *resultobj = 0;
26619 wxDateTime *arg1 = (wxDateTime *) 0 ;
26620 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26621 bool result;
26622 void *argp1 = 0 ;
26623 int res1 = 0 ;
26624 int val2 ;
26625 int ecode2 = 0 ;
26626 PyObject * obj0 = 0 ;
26627 PyObject * obj1 = 0 ;
26628 char * kwnames[] = {
26629 (char *) "self",(char *) "country", NULL
26630 };
26631
26632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26634 if (!SWIG_IsOK(res1)) {
26635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26636 }
26637 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26638 if (obj1) {
26639 ecode2 = SWIG_AsVal_int(obj1, &val2);
26640 if (!SWIG_IsOK(ecode2)) {
26641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26642 }
26643 arg2 = static_cast< wxDateTime::Country >(val2);
26644 }
26645 {
26646 PyThreadState* __tstate = wxPyBeginAllowThreads();
26647 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26648 wxPyEndAllowThreads(__tstate);
26649 if (PyErr_Occurred()) SWIG_fail;
26650 }
26651 {
26652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26653 }
26654 return resultobj;
26655 fail:
26656 return NULL;
26657 }
26658
26659
26660 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26661 PyObject *resultobj = 0;
26662 wxDateTime *arg1 = (wxDateTime *) 0 ;
26663 wxDateTime *arg2 = 0 ;
26664 bool result;
26665 void *argp1 = 0 ;
26666 int res1 = 0 ;
26667 void *argp2 = 0 ;
26668 int res2 = 0 ;
26669 PyObject * obj0 = 0 ;
26670 PyObject * obj1 = 0 ;
26671 char * kwnames[] = {
26672 (char *) "self",(char *) "datetime", NULL
26673 };
26674
26675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26677 if (!SWIG_IsOK(res1)) {
26678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26679 }
26680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26681 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26682 if (!SWIG_IsOK(res2)) {
26683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26684 }
26685 if (!argp2) {
26686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26687 }
26688 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26689 {
26690 PyThreadState* __tstate = wxPyBeginAllowThreads();
26691 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 {
26696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26697 }
26698 return resultobj;
26699 fail:
26700 return NULL;
26701 }
26702
26703
26704 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26705 PyObject *resultobj = 0;
26706 wxDateTime *arg1 = (wxDateTime *) 0 ;
26707 wxDateTime *arg2 = 0 ;
26708 bool result;
26709 void *argp1 = 0 ;
26710 int res1 = 0 ;
26711 void *argp2 = 0 ;
26712 int res2 = 0 ;
26713 PyObject * obj0 = 0 ;
26714 PyObject * obj1 = 0 ;
26715 char * kwnames[] = {
26716 (char *) "self",(char *) "datetime", NULL
26717 };
26718
26719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26721 if (!SWIG_IsOK(res1)) {
26722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26723 }
26724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26725 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26726 if (!SWIG_IsOK(res2)) {
26727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26728 }
26729 if (!argp2) {
26730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26731 }
26732 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26733 {
26734 PyThreadState* __tstate = wxPyBeginAllowThreads();
26735 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26736 wxPyEndAllowThreads(__tstate);
26737 if (PyErr_Occurred()) SWIG_fail;
26738 }
26739 {
26740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26741 }
26742 return resultobj;
26743 fail:
26744 return NULL;
26745 }
26746
26747
26748 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26749 PyObject *resultobj = 0;
26750 wxDateTime *arg1 = (wxDateTime *) 0 ;
26751 wxDateTime *arg2 = 0 ;
26752 bool result;
26753 void *argp1 = 0 ;
26754 int res1 = 0 ;
26755 void *argp2 = 0 ;
26756 int res2 = 0 ;
26757 PyObject * obj0 = 0 ;
26758 PyObject * obj1 = 0 ;
26759 char * kwnames[] = {
26760 (char *) "self",(char *) "datetime", NULL
26761 };
26762
26763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26765 if (!SWIG_IsOK(res1)) {
26766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26767 }
26768 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26769 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26770 if (!SWIG_IsOK(res2)) {
26771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26772 }
26773 if (!argp2) {
26774 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26775 }
26776 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 {
26784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26785 }
26786 return resultobj;
26787 fail:
26788 return NULL;
26789 }
26790
26791
26792 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26793 PyObject *resultobj = 0;
26794 wxDateTime *arg1 = (wxDateTime *) 0 ;
26795 wxDateTime *arg2 = 0 ;
26796 wxDateTime *arg3 = 0 ;
26797 bool result;
26798 void *argp1 = 0 ;
26799 int res1 = 0 ;
26800 void *argp2 = 0 ;
26801 int res2 = 0 ;
26802 void *argp3 = 0 ;
26803 int res3 = 0 ;
26804 PyObject * obj0 = 0 ;
26805 PyObject * obj1 = 0 ;
26806 PyObject * obj2 = 0 ;
26807 char * kwnames[] = {
26808 (char *) "self",(char *) "t1",(char *) "t2", NULL
26809 };
26810
26811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26813 if (!SWIG_IsOK(res1)) {
26814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26815 }
26816 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26817 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26818 if (!SWIG_IsOK(res2)) {
26819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26820 }
26821 if (!argp2) {
26822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26823 }
26824 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26825 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26826 if (!SWIG_IsOK(res3)) {
26827 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26828 }
26829 if (!argp3) {
26830 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26831 }
26832 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 {
26840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26841 }
26842 return resultobj;
26843 fail:
26844 return NULL;
26845 }
26846
26847
26848 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26849 PyObject *resultobj = 0;
26850 wxDateTime *arg1 = (wxDateTime *) 0 ;
26851 wxDateTime *arg2 = 0 ;
26852 wxDateTime *arg3 = 0 ;
26853 bool result;
26854 void *argp1 = 0 ;
26855 int res1 = 0 ;
26856 void *argp2 = 0 ;
26857 int res2 = 0 ;
26858 void *argp3 = 0 ;
26859 int res3 = 0 ;
26860 PyObject * obj0 = 0 ;
26861 PyObject * obj1 = 0 ;
26862 PyObject * obj2 = 0 ;
26863 char * kwnames[] = {
26864 (char *) "self",(char *) "t1",(char *) "t2", NULL
26865 };
26866
26867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26869 if (!SWIG_IsOK(res1)) {
26870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26871 }
26872 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26874 if (!SWIG_IsOK(res2)) {
26875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26876 }
26877 if (!argp2) {
26878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26879 }
26880 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26881 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26882 if (!SWIG_IsOK(res3)) {
26883 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26884 }
26885 if (!argp3) {
26886 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26887 }
26888 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26889 {
26890 PyThreadState* __tstate = wxPyBeginAllowThreads();
26891 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 {
26896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26897 }
26898 return resultobj;
26899 fail:
26900 return NULL;
26901 }
26902
26903
26904 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26905 PyObject *resultobj = 0;
26906 wxDateTime *arg1 = (wxDateTime *) 0 ;
26907 wxDateTime *arg2 = 0 ;
26908 bool result;
26909 void *argp1 = 0 ;
26910 int res1 = 0 ;
26911 void *argp2 = 0 ;
26912 int res2 = 0 ;
26913 PyObject * obj0 = 0 ;
26914 PyObject * obj1 = 0 ;
26915 char * kwnames[] = {
26916 (char *) "self",(char *) "dt", NULL
26917 };
26918
26919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
26920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26921 if (!SWIG_IsOK(res1)) {
26922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26923 }
26924 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26925 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26926 if (!SWIG_IsOK(res2)) {
26927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26928 }
26929 if (!argp2) {
26930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26931 }
26932 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 {
26940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26941 }
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj = 0;
26950 wxDateTime *arg1 = (wxDateTime *) 0 ;
26951 wxDateTime *arg2 = 0 ;
26952 bool result;
26953 void *argp1 = 0 ;
26954 int res1 = 0 ;
26955 void *argp2 = 0 ;
26956 int res2 = 0 ;
26957 PyObject * obj0 = 0 ;
26958 PyObject * obj1 = 0 ;
26959 char * kwnames[] = {
26960 (char *) "self",(char *) "dt", NULL
26961 };
26962
26963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26965 if (!SWIG_IsOK(res1)) {
26966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26967 }
26968 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26970 if (!SWIG_IsOK(res2)) {
26971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26972 }
26973 if (!argp2) {
26974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26975 }
26976 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26977 {
26978 PyThreadState* __tstate = wxPyBeginAllowThreads();
26979 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26980 wxPyEndAllowThreads(__tstate);
26981 if (PyErr_Occurred()) SWIG_fail;
26982 }
26983 {
26984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26985 }
26986 return resultobj;
26987 fail:
26988 return NULL;
26989 }
26990
26991
26992 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj = 0;
26994 wxDateTime *arg1 = (wxDateTime *) 0 ;
26995 wxDateTime *arg2 = 0 ;
26996 wxTimeSpan *arg3 = 0 ;
26997 bool result;
26998 void *argp1 = 0 ;
26999 int res1 = 0 ;
27000 void *argp2 = 0 ;
27001 int res2 = 0 ;
27002 void *argp3 = 0 ;
27003 int res3 = 0 ;
27004 PyObject * obj0 = 0 ;
27005 PyObject * obj1 = 0 ;
27006 PyObject * obj2 = 0 ;
27007 char * kwnames[] = {
27008 (char *) "self",(char *) "dt",(char *) "ts", NULL
27009 };
27010
27011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27013 if (!SWIG_IsOK(res1)) {
27014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27015 }
27016 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27017 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27018 if (!SWIG_IsOK(res2)) {
27019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27020 }
27021 if (!argp2) {
27022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27023 }
27024 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27025 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27026 if (!SWIG_IsOK(res3)) {
27027 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27028 }
27029 if (!argp3) {
27030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27031 }
27032 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 {
27040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27041 }
27042 return resultobj;
27043 fail:
27044 return NULL;
27045 }
27046
27047
27048 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27049 PyObject *resultobj = 0;
27050 wxDateTime *arg1 = (wxDateTime *) 0 ;
27051 wxTimeSpan *arg2 = 0 ;
27052 wxDateTime *result = 0 ;
27053 void *argp1 = 0 ;
27054 int res1 = 0 ;
27055 void *argp2 = 0 ;
27056 int res2 = 0 ;
27057 PyObject * obj0 = 0 ;
27058 PyObject * obj1 = 0 ;
27059 char * kwnames[] = {
27060 (char *) "self",(char *) "diff", NULL
27061 };
27062
27063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27065 if (!SWIG_IsOK(res1)) {
27066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27067 }
27068 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27069 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27070 if (!SWIG_IsOK(res2)) {
27071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27072 }
27073 if (!argp2) {
27074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27075 }
27076 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 {
27080 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27081 result = (wxDateTime *) &_result_ref;
27082 }
27083 wxPyEndAllowThreads(__tstate);
27084 if (PyErr_Occurred()) SWIG_fail;
27085 }
27086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27087 return resultobj;
27088 fail:
27089 return NULL;
27090 }
27091
27092
27093 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj = 0;
27095 wxDateTime *arg1 = (wxDateTime *) 0 ;
27096 wxDateSpan *arg2 = 0 ;
27097 wxDateTime *result = 0 ;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 void *argp2 = 0 ;
27101 int res2 = 0 ;
27102 PyObject * obj0 = 0 ;
27103 PyObject * obj1 = 0 ;
27104 char * kwnames[] = {
27105 (char *) "self",(char *) "diff", NULL
27106 };
27107
27108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27110 if (!SWIG_IsOK(res1)) {
27111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27112 }
27113 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27115 if (!SWIG_IsOK(res2)) {
27116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27117 }
27118 if (!argp2) {
27119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27120 }
27121 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 {
27125 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27126 result = (wxDateTime *) &_result_ref;
27127 }
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj = 0;
27140 wxDateTime *arg1 = (wxDateTime *) 0 ;
27141 wxTimeSpan *arg2 = 0 ;
27142 wxDateTime *result = 0 ;
27143 void *argp1 = 0 ;
27144 int res1 = 0 ;
27145 void *argp2 = 0 ;
27146 int res2 = 0 ;
27147 PyObject * obj0 = 0 ;
27148 PyObject * obj1 = 0 ;
27149 char * kwnames[] = {
27150 (char *) "self",(char *) "diff", NULL
27151 };
27152
27153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27155 if (!SWIG_IsOK(res1)) {
27156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27157 }
27158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27160 if (!SWIG_IsOK(res2)) {
27161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27162 }
27163 if (!argp2) {
27164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27165 }
27166 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27167 {
27168 PyThreadState* __tstate = wxPyBeginAllowThreads();
27169 {
27170 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27171 result = (wxDateTime *) &_result_ref;
27172 }
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27177 return resultobj;
27178 fail:
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27184 PyObject *resultobj = 0;
27185 wxDateTime *arg1 = (wxDateTime *) 0 ;
27186 wxDateSpan *arg2 = 0 ;
27187 wxDateTime *result = 0 ;
27188 void *argp1 = 0 ;
27189 int res1 = 0 ;
27190 void *argp2 = 0 ;
27191 int res2 = 0 ;
27192 PyObject * obj0 = 0 ;
27193 PyObject * obj1 = 0 ;
27194 char * kwnames[] = {
27195 (char *) "self",(char *) "diff", NULL
27196 };
27197
27198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27200 if (!SWIG_IsOK(res1)) {
27201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27202 }
27203 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27205 if (!SWIG_IsOK(res2)) {
27206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27207 }
27208 if (!argp2) {
27209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27210 }
27211 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 {
27215 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27216 result = (wxDateTime *) &_result_ref;
27217 }
27218 wxPyEndAllowThreads(__tstate);
27219 if (PyErr_Occurred()) SWIG_fail;
27220 }
27221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27222 return resultobj;
27223 fail:
27224 return NULL;
27225 }
27226
27227
27228 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27229 PyObject *resultobj = 0;
27230 wxDateTime *arg1 = (wxDateTime *) 0 ;
27231 wxDateTime *arg2 = 0 ;
27232 wxTimeSpan result;
27233 void *argp1 = 0 ;
27234 int res1 = 0 ;
27235 void *argp2 = 0 ;
27236 int res2 = 0 ;
27237 PyObject * obj0 = 0 ;
27238 PyObject * obj1 = 0 ;
27239 char * kwnames[] = {
27240 (char *) "self",(char *) "dt", NULL
27241 };
27242
27243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27245 if (!SWIG_IsOK(res1)) {
27246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27247 }
27248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27249 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27250 if (!SWIG_IsOK(res2)) {
27251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27252 }
27253 if (!argp2) {
27254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27255 }
27256 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27260 wxPyEndAllowThreads(__tstate);
27261 if (PyErr_Occurred()) SWIG_fail;
27262 }
27263 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27264 return resultobj;
27265 fail:
27266 return NULL;
27267 }
27268
27269
27270 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27271 PyObject *resultobj = 0;
27272 wxDateTime *arg1 = (wxDateTime *) 0 ;
27273 wxTimeSpan *arg2 = 0 ;
27274 wxDateTime *result = 0 ;
27275 void *argp1 = 0 ;
27276 int res1 = 0 ;
27277 void *argp2 = 0 ;
27278 int res2 = 0 ;
27279
27280 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27282 if (!SWIG_IsOK(res1)) {
27283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27284 }
27285 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27286 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27287 if (!SWIG_IsOK(res2)) {
27288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27289 }
27290 if (!argp2) {
27291 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27292 }
27293 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27294 {
27295 PyThreadState* __tstate = wxPyBeginAllowThreads();
27296 {
27297 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27298 result = (wxDateTime *) &_result_ref;
27299 }
27300 wxPyEndAllowThreads(__tstate);
27301 if (PyErr_Occurred()) SWIG_fail;
27302 }
27303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27304 return resultobj;
27305 fail:
27306 return NULL;
27307 }
27308
27309
27310 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27311 PyObject *resultobj = 0;
27312 wxDateTime *arg1 = (wxDateTime *) 0 ;
27313 wxDateSpan *arg2 = 0 ;
27314 wxDateTime *result = 0 ;
27315 void *argp1 = 0 ;
27316 int res1 = 0 ;
27317 void *argp2 = 0 ;
27318 int res2 = 0 ;
27319
27320 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27322 if (!SWIG_IsOK(res1)) {
27323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27324 }
27325 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27326 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27327 if (!SWIG_IsOK(res2)) {
27328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27329 }
27330 if (!argp2) {
27331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27332 }
27333 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27334 {
27335 PyThreadState* __tstate = wxPyBeginAllowThreads();
27336 {
27337 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27338 result = (wxDateTime *) &_result_ref;
27339 }
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27351 int argc;
27352 PyObject *argv[3];
27353
27354 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27355 --argc;
27356 if (argc == 2) {
27357 int _v = 0;
27358 {
27359 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27360 _v = SWIG_CheckState(res);
27361 }
27362 if (!_v) goto check_1;
27363 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27364 }
27365 check_1:
27366
27367 if (argc == 2) {
27368 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27369 }
27370
27371 fail:
27372 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27373 return NULL;
27374 }
27375
27376
27377 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27378 PyObject *resultobj = 0;
27379 wxDateTime *arg1 = (wxDateTime *) 0 ;
27380 wxTimeSpan *arg2 = 0 ;
27381 wxDateTime *result = 0 ;
27382 void *argp1 = 0 ;
27383 int res1 = 0 ;
27384 void *argp2 = 0 ;
27385 int res2 = 0 ;
27386
27387 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27389 if (!SWIG_IsOK(res1)) {
27390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27391 }
27392 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27393 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27394 if (!SWIG_IsOK(res2)) {
27395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27396 }
27397 if (!argp2) {
27398 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27399 }
27400 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27401 {
27402 PyThreadState* __tstate = wxPyBeginAllowThreads();
27403 {
27404 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27405 result = (wxDateTime *) &_result_ref;
27406 }
27407 wxPyEndAllowThreads(__tstate);
27408 if (PyErr_Occurred()) SWIG_fail;
27409 }
27410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27418 PyObject *resultobj = 0;
27419 wxDateTime *arg1 = (wxDateTime *) 0 ;
27420 wxDateSpan *arg2 = 0 ;
27421 wxDateTime *result = 0 ;
27422 void *argp1 = 0 ;
27423 int res1 = 0 ;
27424 void *argp2 = 0 ;
27425 int res2 = 0 ;
27426
27427 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27429 if (!SWIG_IsOK(res1)) {
27430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27431 }
27432 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27433 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27434 if (!SWIG_IsOK(res2)) {
27435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27436 }
27437 if (!argp2) {
27438 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27439 }
27440 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 {
27444 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27445 result = (wxDateTime *) &_result_ref;
27446 }
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27451 return resultobj;
27452 fail:
27453 return NULL;
27454 }
27455
27456
27457 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27458 int argc;
27459 PyObject *argv[3];
27460
27461 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27462 --argc;
27463 if (argc == 2) {
27464 int _v = 0;
27465 {
27466 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27467 _v = SWIG_CheckState(res);
27468 }
27469 if (!_v) goto check_1;
27470 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27471 }
27472 check_1:
27473
27474 if (argc == 2) {
27475 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27476 }
27477
27478 fail:
27479 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27480 return NULL;
27481 }
27482
27483
27484 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27485 PyObject *resultobj = 0;
27486 wxDateTime *arg1 = (wxDateTime *) 0 ;
27487 wxTimeSpan *arg2 = 0 ;
27488 wxDateTime result;
27489 void *argp1 = 0 ;
27490 int res1 = 0 ;
27491 void *argp2 = 0 ;
27492 int res2 = 0 ;
27493
27494 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27496 if (!SWIG_IsOK(res1)) {
27497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27498 }
27499 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27500 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27501 if (!SWIG_IsOK(res2)) {
27502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27503 }
27504 if (!argp2) {
27505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27506 }
27507 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27508 {
27509 PyThreadState* __tstate = wxPyBeginAllowThreads();
27510 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27522 PyObject *resultobj = 0;
27523 wxDateTime *arg1 = (wxDateTime *) 0 ;
27524 wxDateSpan *arg2 = 0 ;
27525 wxDateTime result;
27526 void *argp1 = 0 ;
27527 int res1 = 0 ;
27528 void *argp2 = 0 ;
27529 int res2 = 0 ;
27530
27531 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27533 if (!SWIG_IsOK(res1)) {
27534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27535 }
27536 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27537 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27538 if (!SWIG_IsOK(res2)) {
27539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27540 }
27541 if (!argp2) {
27542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27543 }
27544 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27545 {
27546 PyThreadState* __tstate = wxPyBeginAllowThreads();
27547 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27548 wxPyEndAllowThreads(__tstate);
27549 if (PyErr_Occurred()) SWIG_fail;
27550 }
27551 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27559 int argc;
27560 PyObject *argv[3];
27561
27562 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27563 --argc;
27564 if (argc == 2) {
27565 int _v = 0;
27566 {
27567 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27568 _v = SWIG_CheckState(res);
27569 }
27570 if (!_v) goto check_1;
27571 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27572 }
27573 check_1:
27574
27575 if (argc == 2) {
27576 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27577 }
27578
27579 fail:
27580 Py_INCREF(Py_NotImplemented);
27581 return Py_NotImplemented;
27582 }
27583
27584
27585 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27586 PyObject *resultobj = 0;
27587 wxDateTime *arg1 = (wxDateTime *) 0 ;
27588 wxDateTime *arg2 = 0 ;
27589 wxTimeSpan result;
27590 void *argp1 = 0 ;
27591 int res1 = 0 ;
27592 void *argp2 = 0 ;
27593 int res2 = 0 ;
27594
27595 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27597 if (!SWIG_IsOK(res1)) {
27598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27599 }
27600 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27601 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27602 if (!SWIG_IsOK(res2)) {
27603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27604 }
27605 if (!argp2) {
27606 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27607 }
27608 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27623 PyObject *resultobj = 0;
27624 wxDateTime *arg1 = (wxDateTime *) 0 ;
27625 wxTimeSpan *arg2 = 0 ;
27626 wxDateTime result;
27627 void *argp1 = 0 ;
27628 int res1 = 0 ;
27629 void *argp2 = 0 ;
27630 int res2 = 0 ;
27631
27632 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27634 if (!SWIG_IsOK(res1)) {
27635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27636 }
27637 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27638 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27639 if (!SWIG_IsOK(res2)) {
27640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27641 }
27642 if (!argp2) {
27643 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27644 }
27645 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27646 {
27647 PyThreadState* __tstate = wxPyBeginAllowThreads();
27648 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27653 return resultobj;
27654 fail:
27655 return NULL;
27656 }
27657
27658
27659 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27660 PyObject *resultobj = 0;
27661 wxDateTime *arg1 = (wxDateTime *) 0 ;
27662 wxDateSpan *arg2 = 0 ;
27663 wxDateTime result;
27664 void *argp1 = 0 ;
27665 int res1 = 0 ;
27666 void *argp2 = 0 ;
27667 int res2 = 0 ;
27668
27669 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27671 if (!SWIG_IsOK(res1)) {
27672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27673 }
27674 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27675 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27676 if (!SWIG_IsOK(res2)) {
27677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27678 }
27679 if (!argp2) {
27680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27681 }
27682 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27697 int argc;
27698 PyObject *argv[3];
27699
27700 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27701 --argc;
27702 if (argc == 2) {
27703 int _v = 0;
27704 {
27705 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27706 _v = SWIG_CheckState(res);
27707 }
27708 if (!_v) goto check_1;
27709 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27710 }
27711 check_1:
27712
27713 if (argc == 2) {
27714 int _v = 0;
27715 {
27716 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27717 _v = SWIG_CheckState(res);
27718 }
27719 if (!_v) goto check_2;
27720 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27721 }
27722 check_2:
27723
27724 if (argc == 2) {
27725 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27726 }
27727
27728 fail:
27729 Py_INCREF(Py_NotImplemented);
27730 return Py_NotImplemented;
27731 }
27732
27733
27734 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27735 PyObject *resultobj = 0;
27736 wxDateTime *arg1 = (wxDateTime *) 0 ;
27737 wxDateTime *arg2 = (wxDateTime *) 0 ;
27738 bool result;
27739 void *argp1 = 0 ;
27740 int res1 = 0 ;
27741 void *argp2 = 0 ;
27742 int res2 = 0 ;
27743 PyObject * obj0 = 0 ;
27744 PyObject * obj1 = 0 ;
27745 char * kwnames[] = {
27746 (char *) "self",(char *) "other", NULL
27747 };
27748
27749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27751 if (!SWIG_IsOK(res1)) {
27752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27753 }
27754 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27756 if (!SWIG_IsOK(res2)) {
27757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27758 }
27759 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27763 wxPyEndAllowThreads(__tstate);
27764 if (PyErr_Occurred()) SWIG_fail;
27765 }
27766 {
27767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27768 }
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27776 PyObject *resultobj = 0;
27777 wxDateTime *arg1 = (wxDateTime *) 0 ;
27778 wxDateTime *arg2 = (wxDateTime *) 0 ;
27779 bool result;
27780 void *argp1 = 0 ;
27781 int res1 = 0 ;
27782 void *argp2 = 0 ;
27783 int res2 = 0 ;
27784 PyObject * obj0 = 0 ;
27785 PyObject * obj1 = 0 ;
27786 char * kwnames[] = {
27787 (char *) "self",(char *) "other", NULL
27788 };
27789
27790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27792 if (!SWIG_IsOK(res1)) {
27793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27794 }
27795 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27797 if (!SWIG_IsOK(res2)) {
27798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27799 }
27800 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27809 }
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27817 PyObject *resultobj = 0;
27818 wxDateTime *arg1 = (wxDateTime *) 0 ;
27819 wxDateTime *arg2 = (wxDateTime *) 0 ;
27820 bool result;
27821 void *argp1 = 0 ;
27822 int res1 = 0 ;
27823 void *argp2 = 0 ;
27824 int res2 = 0 ;
27825 PyObject * obj0 = 0 ;
27826 PyObject * obj1 = 0 ;
27827 char * kwnames[] = {
27828 (char *) "self",(char *) "other", NULL
27829 };
27830
27831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27833 if (!SWIG_IsOK(res1)) {
27834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27835 }
27836 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27838 if (!SWIG_IsOK(res2)) {
27839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27840 }
27841 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 {
27849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27850 }
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27858 PyObject *resultobj = 0;
27859 wxDateTime *arg1 = (wxDateTime *) 0 ;
27860 wxDateTime *arg2 = (wxDateTime *) 0 ;
27861 bool result;
27862 void *argp1 = 0 ;
27863 int res1 = 0 ;
27864 void *argp2 = 0 ;
27865 int res2 = 0 ;
27866 PyObject * obj0 = 0 ;
27867 PyObject * obj1 = 0 ;
27868 char * kwnames[] = {
27869 (char *) "self",(char *) "other", NULL
27870 };
27871
27872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27874 if (!SWIG_IsOK(res1)) {
27875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27876 }
27877 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27878 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27879 if (!SWIG_IsOK(res2)) {
27880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27881 }
27882 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27886 wxPyEndAllowThreads(__tstate);
27887 if (PyErr_Occurred()) SWIG_fail;
27888 }
27889 {
27890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27891 }
27892 return resultobj;
27893 fail:
27894 return NULL;
27895 }
27896
27897
27898 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27899 PyObject *resultobj = 0;
27900 wxDateTime *arg1 = (wxDateTime *) 0 ;
27901 wxDateTime *arg2 = (wxDateTime *) 0 ;
27902 bool result;
27903 void *argp1 = 0 ;
27904 int res1 = 0 ;
27905 void *argp2 = 0 ;
27906 int res2 = 0 ;
27907 PyObject * obj0 = 0 ;
27908 PyObject * obj1 = 0 ;
27909 char * kwnames[] = {
27910 (char *) "self",(char *) "other", NULL
27911 };
27912
27913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
27914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27915 if (!SWIG_IsOK(res1)) {
27916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27917 }
27918 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27919 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27920 if (!SWIG_IsOK(res2)) {
27921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27922 }
27923 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 {
27931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27932 }
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27940 PyObject *resultobj = 0;
27941 wxDateTime *arg1 = (wxDateTime *) 0 ;
27942 wxDateTime *arg2 = (wxDateTime *) 0 ;
27943 bool result;
27944 void *argp1 = 0 ;
27945 int res1 = 0 ;
27946 void *argp2 = 0 ;
27947 int res2 = 0 ;
27948 PyObject * obj0 = 0 ;
27949 PyObject * obj1 = 0 ;
27950 char * kwnames[] = {
27951 (char *) "self",(char *) "other", NULL
27952 };
27953
27954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
27955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27956 if (!SWIG_IsOK(res1)) {
27957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27958 }
27959 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27961 if (!SWIG_IsOK(res2)) {
27962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27963 }
27964 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27968 wxPyEndAllowThreads(__tstate);
27969 if (PyErr_Occurred()) SWIG_fail;
27970 }
27971 {
27972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27973 }
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27981 PyObject *resultobj = 0;
27982 wxDateTime *arg1 = (wxDateTime *) 0 ;
27983 wxString *arg2 = 0 ;
27984 int result;
27985 void *argp1 = 0 ;
27986 int res1 = 0 ;
27987 bool temp2 = false ;
27988 PyObject * obj0 = 0 ;
27989 PyObject * obj1 = 0 ;
27990 char * kwnames[] = {
27991 (char *) "self",(char *) "date", NULL
27992 };
27993
27994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27996 if (!SWIG_IsOK(res1)) {
27997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27998 }
27999 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28000 {
28001 arg2 = wxString_in_helper(obj1);
28002 if (arg2 == NULL) SWIG_fail;
28003 temp2 = true;
28004 }
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 resultobj = SWIG_From_int(static_cast< int >(result));
28012 {
28013 if (temp2)
28014 delete arg2;
28015 }
28016 return resultobj;
28017 fail:
28018 {
28019 if (temp2)
28020 delete arg2;
28021 }
28022 return NULL;
28023 }
28024
28025
28026 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28027 PyObject *resultobj = 0;
28028 wxDateTime *arg1 = (wxDateTime *) 0 ;
28029 wxString *arg2 = 0 ;
28030 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28031 wxString *arg3 = (wxString *) &arg3_defvalue ;
28032 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28033 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28034 int result;
28035 void *argp1 = 0 ;
28036 int res1 = 0 ;
28037 bool temp2 = false ;
28038 bool temp3 = false ;
28039 void *argp4 = 0 ;
28040 int res4 = 0 ;
28041 PyObject * obj0 = 0 ;
28042 PyObject * obj1 = 0 ;
28043 PyObject * obj2 = 0 ;
28044 PyObject * obj3 = 0 ;
28045 char * kwnames[] = {
28046 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28047 };
28048
28049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28051 if (!SWIG_IsOK(res1)) {
28052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28053 }
28054 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28055 {
28056 arg2 = wxString_in_helper(obj1);
28057 if (arg2 == NULL) SWIG_fail;
28058 temp2 = true;
28059 }
28060 if (obj2) {
28061 {
28062 arg3 = wxString_in_helper(obj2);
28063 if (arg3 == NULL) SWIG_fail;
28064 temp3 = true;
28065 }
28066 }
28067 if (obj3) {
28068 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28069 if (!SWIG_IsOK(res4)) {
28070 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28071 }
28072 if (!argp4) {
28073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28074 }
28075 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28076 }
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28080 wxPyEndAllowThreads(__tstate);
28081 if (PyErr_Occurred()) SWIG_fail;
28082 }
28083 resultobj = SWIG_From_int(static_cast< int >(result));
28084 {
28085 if (temp2)
28086 delete arg2;
28087 }
28088 {
28089 if (temp3)
28090 delete arg3;
28091 }
28092 return resultobj;
28093 fail:
28094 {
28095 if (temp2)
28096 delete arg2;
28097 }
28098 {
28099 if (temp3)
28100 delete arg3;
28101 }
28102 return NULL;
28103 }
28104
28105
28106 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28107 PyObject *resultobj = 0;
28108 wxDateTime *arg1 = (wxDateTime *) 0 ;
28109 wxString *arg2 = 0 ;
28110 int result;
28111 void *argp1 = 0 ;
28112 int res1 = 0 ;
28113 bool temp2 = false ;
28114 PyObject * obj0 = 0 ;
28115 PyObject * obj1 = 0 ;
28116 char * kwnames[] = {
28117 (char *) "self",(char *) "datetime", NULL
28118 };
28119
28120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28122 if (!SWIG_IsOK(res1)) {
28123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28124 }
28125 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28126 {
28127 arg2 = wxString_in_helper(obj1);
28128 if (arg2 == NULL) SWIG_fail;
28129 temp2 = true;
28130 }
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 resultobj = SWIG_From_int(static_cast< int >(result));
28138 {
28139 if (temp2)
28140 delete arg2;
28141 }
28142 return resultobj;
28143 fail:
28144 {
28145 if (temp2)
28146 delete arg2;
28147 }
28148 return NULL;
28149 }
28150
28151
28152 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28153 PyObject *resultobj = 0;
28154 wxDateTime *arg1 = (wxDateTime *) 0 ;
28155 wxString *arg2 = 0 ;
28156 int result;
28157 void *argp1 = 0 ;
28158 int res1 = 0 ;
28159 bool temp2 = false ;
28160 PyObject * obj0 = 0 ;
28161 PyObject * obj1 = 0 ;
28162 char * kwnames[] = {
28163 (char *) "self",(char *) "date", NULL
28164 };
28165
28166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28168 if (!SWIG_IsOK(res1)) {
28169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28170 }
28171 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28172 {
28173 arg2 = wxString_in_helper(obj1);
28174 if (arg2 == NULL) SWIG_fail;
28175 temp2 = true;
28176 }
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 resultobj = SWIG_From_int(static_cast< int >(result));
28184 {
28185 if (temp2)
28186 delete arg2;
28187 }
28188 return resultobj;
28189 fail:
28190 {
28191 if (temp2)
28192 delete arg2;
28193 }
28194 return NULL;
28195 }
28196
28197
28198 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj = 0;
28200 wxDateTime *arg1 = (wxDateTime *) 0 ;
28201 wxString *arg2 = 0 ;
28202 int result;
28203 void *argp1 = 0 ;
28204 int res1 = 0 ;
28205 bool temp2 = false ;
28206 PyObject * obj0 = 0 ;
28207 PyObject * obj1 = 0 ;
28208 char * kwnames[] = {
28209 (char *) "self",(char *) "time", NULL
28210 };
28211
28212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28214 if (!SWIG_IsOK(res1)) {
28215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28216 }
28217 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28218 {
28219 arg2 = wxString_in_helper(obj1);
28220 if (arg2 == NULL) SWIG_fail;
28221 temp2 = true;
28222 }
28223 {
28224 PyThreadState* __tstate = wxPyBeginAllowThreads();
28225 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 resultobj = SWIG_From_int(static_cast< int >(result));
28230 {
28231 if (temp2)
28232 delete arg2;
28233 }
28234 return resultobj;
28235 fail:
28236 {
28237 if (temp2)
28238 delete arg2;
28239 }
28240 return NULL;
28241 }
28242
28243
28244 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj = 0;
28246 wxDateTime *arg1 = (wxDateTime *) 0 ;
28247 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28248 wxString *arg2 = (wxString *) &arg2_defvalue ;
28249 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28250 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28251 wxString result;
28252 void *argp1 = 0 ;
28253 int res1 = 0 ;
28254 bool temp2 = false ;
28255 bool temp3 = false ;
28256 PyObject * obj0 = 0 ;
28257 PyObject * obj1 = 0 ;
28258 PyObject * obj2 = 0 ;
28259 char * kwnames[] = {
28260 (char *) "self",(char *) "format",(char *) "tz", NULL
28261 };
28262
28263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28265 if (!SWIG_IsOK(res1)) {
28266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28267 }
28268 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28269 if (obj1) {
28270 {
28271 arg2 = wxString_in_helper(obj1);
28272 if (arg2 == NULL) SWIG_fail;
28273 temp2 = true;
28274 }
28275 }
28276 if (obj2) {
28277 {
28278 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28279 temp3 = true;
28280 }
28281 }
28282 {
28283 PyThreadState* __tstate = wxPyBeginAllowThreads();
28284 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28285 wxPyEndAllowThreads(__tstate);
28286 if (PyErr_Occurred()) SWIG_fail;
28287 }
28288 {
28289 #if wxUSE_UNICODE
28290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28291 #else
28292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28293 #endif
28294 }
28295 {
28296 if (temp2)
28297 delete arg2;
28298 }
28299 {
28300 if (temp3) delete arg3;
28301 }
28302 return resultobj;
28303 fail:
28304 {
28305 if (temp2)
28306 delete arg2;
28307 }
28308 {
28309 if (temp3) delete arg3;
28310 }
28311 return NULL;
28312 }
28313
28314
28315 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28316 PyObject *resultobj = 0;
28317 wxDateTime *arg1 = (wxDateTime *) 0 ;
28318 wxString result;
28319 void *argp1 = 0 ;
28320 int res1 = 0 ;
28321 PyObject *swig_obj[1] ;
28322
28323 if (!args) SWIG_fail;
28324 swig_obj[0] = args;
28325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28326 if (!SWIG_IsOK(res1)) {
28327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28328 }
28329 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 result = ((wxDateTime const *)arg1)->FormatDate();
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 {
28337 #if wxUSE_UNICODE
28338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28339 #else
28340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28341 #endif
28342 }
28343 return resultobj;
28344 fail:
28345 return NULL;
28346 }
28347
28348
28349 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28350 PyObject *resultobj = 0;
28351 wxDateTime *arg1 = (wxDateTime *) 0 ;
28352 wxString result;
28353 void *argp1 = 0 ;
28354 int res1 = 0 ;
28355 PyObject *swig_obj[1] ;
28356
28357 if (!args) SWIG_fail;
28358 swig_obj[0] = args;
28359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28360 if (!SWIG_IsOK(res1)) {
28361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28362 }
28363 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 result = ((wxDateTime const *)arg1)->FormatTime();
28367 wxPyEndAllowThreads(__tstate);
28368 if (PyErr_Occurred()) SWIG_fail;
28369 }
28370 {
28371 #if wxUSE_UNICODE
28372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28373 #else
28374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28375 #endif
28376 }
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28384 PyObject *resultobj = 0;
28385 wxDateTime *arg1 = (wxDateTime *) 0 ;
28386 wxString result;
28387 void *argp1 = 0 ;
28388 int res1 = 0 ;
28389 PyObject *swig_obj[1] ;
28390
28391 if (!args) SWIG_fail;
28392 swig_obj[0] = args;
28393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28394 if (!SWIG_IsOK(res1)) {
28395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28396 }
28397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 result = ((wxDateTime const *)arg1)->FormatISODate();
28401 wxPyEndAllowThreads(__tstate);
28402 if (PyErr_Occurred()) SWIG_fail;
28403 }
28404 {
28405 #if wxUSE_UNICODE
28406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28407 #else
28408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28409 #endif
28410 }
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28418 PyObject *resultobj = 0;
28419 wxDateTime *arg1 = (wxDateTime *) 0 ;
28420 wxString result;
28421 void *argp1 = 0 ;
28422 int res1 = 0 ;
28423 PyObject *swig_obj[1] ;
28424
28425 if (!args) SWIG_fail;
28426 swig_obj[0] = args;
28427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28428 if (!SWIG_IsOK(res1)) {
28429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28430 }
28431 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28432 {
28433 PyThreadState* __tstate = wxPyBeginAllowThreads();
28434 result = ((wxDateTime const *)arg1)->FormatISOTime();
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 {
28439 #if wxUSE_UNICODE
28440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28441 #else
28442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28443 #endif
28444 }
28445 return resultobj;
28446 fail:
28447 return NULL;
28448 }
28449
28450
28451 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28452 PyObject *obj;
28453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28454 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28455 return SWIG_Py_Void();
28456 }
28457
28458 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28459 return SWIG_Python_InitShadowInstance(args);
28460 }
28461
28462 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28463 PyObject *resultobj = 0;
28464 long arg1 ;
28465 wxTimeSpan result;
28466 long val1 ;
28467 int ecode1 = 0 ;
28468 PyObject * obj0 = 0 ;
28469 char * kwnames[] = {
28470 (char *) "ms", NULL
28471 };
28472
28473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28474 ecode1 = SWIG_AsVal_long(obj0, &val1);
28475 if (!SWIG_IsOK(ecode1)) {
28476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28477 }
28478 arg1 = static_cast< long >(val1);
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 result = wxTimeSpan::Milliseconds(arg1);
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28493 PyObject *resultobj = 0;
28494 wxTimeSpan result;
28495
28496 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 result = wxTimeSpan::Millisecond();
28500 wxPyEndAllowThreads(__tstate);
28501 if (PyErr_Occurred()) SWIG_fail;
28502 }
28503 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28504 return resultobj;
28505 fail:
28506 return NULL;
28507 }
28508
28509
28510 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28511 PyObject *resultobj = 0;
28512 long arg1 ;
28513 wxTimeSpan result;
28514 long val1 ;
28515 int ecode1 = 0 ;
28516 PyObject * obj0 = 0 ;
28517 char * kwnames[] = {
28518 (char *) "sec", NULL
28519 };
28520
28521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28522 ecode1 = SWIG_AsVal_long(obj0, &val1);
28523 if (!SWIG_IsOK(ecode1)) {
28524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28525 }
28526 arg1 = static_cast< long >(val1);
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 result = wxTimeSpan::Seconds(arg1);
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28541 PyObject *resultobj = 0;
28542 wxTimeSpan result;
28543
28544 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 result = wxTimeSpan::Second();
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28559 PyObject *resultobj = 0;
28560 long arg1 ;
28561 wxTimeSpan result;
28562 long val1 ;
28563 int ecode1 = 0 ;
28564 PyObject * obj0 = 0 ;
28565 char * kwnames[] = {
28566 (char *) "min", NULL
28567 };
28568
28569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28570 ecode1 = SWIG_AsVal_long(obj0, &val1);
28571 if (!SWIG_IsOK(ecode1)) {
28572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28573 }
28574 arg1 = static_cast< long >(val1);
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = wxTimeSpan::Minutes(arg1);
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28589 PyObject *resultobj = 0;
28590 wxTimeSpan result;
28591
28592 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 result = wxTimeSpan::Minute();
28596 wxPyEndAllowThreads(__tstate);
28597 if (PyErr_Occurred()) SWIG_fail;
28598 }
28599 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28600 return resultobj;
28601 fail:
28602 return NULL;
28603 }
28604
28605
28606 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28607 PyObject *resultobj = 0;
28608 long arg1 ;
28609 wxTimeSpan result;
28610 long val1 ;
28611 int ecode1 = 0 ;
28612 PyObject * obj0 = 0 ;
28613 char * kwnames[] = {
28614 (char *) "hours", NULL
28615 };
28616
28617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28618 ecode1 = SWIG_AsVal_long(obj0, &val1);
28619 if (!SWIG_IsOK(ecode1)) {
28620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28621 }
28622 arg1 = static_cast< long >(val1);
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = wxTimeSpan::Hours(arg1);
28626 wxPyEndAllowThreads(__tstate);
28627 if (PyErr_Occurred()) SWIG_fail;
28628 }
28629 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28637 PyObject *resultobj = 0;
28638 wxTimeSpan result;
28639
28640 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28641 {
28642 PyThreadState* __tstate = wxPyBeginAllowThreads();
28643 result = wxTimeSpan::Hour();
28644 wxPyEndAllowThreads(__tstate);
28645 if (PyErr_Occurred()) SWIG_fail;
28646 }
28647 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28655 PyObject *resultobj = 0;
28656 long arg1 ;
28657 wxTimeSpan result;
28658 long val1 ;
28659 int ecode1 = 0 ;
28660 PyObject * obj0 = 0 ;
28661 char * kwnames[] = {
28662 (char *) "days", NULL
28663 };
28664
28665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28666 ecode1 = SWIG_AsVal_long(obj0, &val1);
28667 if (!SWIG_IsOK(ecode1)) {
28668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28669 }
28670 arg1 = static_cast< long >(val1);
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 result = wxTimeSpan::Days(arg1);
28674 wxPyEndAllowThreads(__tstate);
28675 if (PyErr_Occurred()) SWIG_fail;
28676 }
28677 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28685 PyObject *resultobj = 0;
28686 wxTimeSpan result;
28687
28688 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 result = wxTimeSpan::Day();
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28696 return resultobj;
28697 fail:
28698 return NULL;
28699 }
28700
28701
28702 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28703 PyObject *resultobj = 0;
28704 long arg1 ;
28705 wxTimeSpan result;
28706 long val1 ;
28707 int ecode1 = 0 ;
28708 PyObject * obj0 = 0 ;
28709 char * kwnames[] = {
28710 (char *) "days", NULL
28711 };
28712
28713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28714 ecode1 = SWIG_AsVal_long(obj0, &val1);
28715 if (!SWIG_IsOK(ecode1)) {
28716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28717 }
28718 arg1 = static_cast< long >(val1);
28719 {
28720 PyThreadState* __tstate = wxPyBeginAllowThreads();
28721 result = wxTimeSpan::Weeks(arg1);
28722 wxPyEndAllowThreads(__tstate);
28723 if (PyErr_Occurred()) SWIG_fail;
28724 }
28725 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28726 return resultobj;
28727 fail:
28728 return NULL;
28729 }
28730
28731
28732 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28733 PyObject *resultobj = 0;
28734 wxTimeSpan result;
28735
28736 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28737 {
28738 PyThreadState* __tstate = wxPyBeginAllowThreads();
28739 result = wxTimeSpan::Week();
28740 wxPyEndAllowThreads(__tstate);
28741 if (PyErr_Occurred()) SWIG_fail;
28742 }
28743 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28744 return resultobj;
28745 fail:
28746 return NULL;
28747 }
28748
28749
28750 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28751 PyObject *resultobj = 0;
28752 long arg1 = (long) 0 ;
28753 long arg2 = (long) 0 ;
28754 long arg3 = (long) 0 ;
28755 long arg4 = (long) 0 ;
28756 wxTimeSpan *result = 0 ;
28757 long val1 ;
28758 int ecode1 = 0 ;
28759 long val2 ;
28760 int ecode2 = 0 ;
28761 long val3 ;
28762 int ecode3 = 0 ;
28763 long val4 ;
28764 int ecode4 = 0 ;
28765 PyObject * obj0 = 0 ;
28766 PyObject * obj1 = 0 ;
28767 PyObject * obj2 = 0 ;
28768 PyObject * obj3 = 0 ;
28769 char * kwnames[] = {
28770 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28771 };
28772
28773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28774 if (obj0) {
28775 ecode1 = SWIG_AsVal_long(obj0, &val1);
28776 if (!SWIG_IsOK(ecode1)) {
28777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28778 }
28779 arg1 = static_cast< long >(val1);
28780 }
28781 if (obj1) {
28782 ecode2 = SWIG_AsVal_long(obj1, &val2);
28783 if (!SWIG_IsOK(ecode2)) {
28784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28785 }
28786 arg2 = static_cast< long >(val2);
28787 }
28788 if (obj2) {
28789 ecode3 = SWIG_AsVal_long(obj2, &val3);
28790 if (!SWIG_IsOK(ecode3)) {
28791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28792 }
28793 arg3 = static_cast< long >(val3);
28794 }
28795 if (obj3) {
28796 ecode4 = SWIG_AsVal_long(obj3, &val4);
28797 if (!SWIG_IsOK(ecode4)) {
28798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28799 }
28800 arg4 = static_cast< long >(val4);
28801 }
28802 {
28803 PyThreadState* __tstate = wxPyBeginAllowThreads();
28804 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28816 PyObject *resultobj = 0;
28817 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28818 void *argp1 = 0 ;
28819 int res1 = 0 ;
28820 PyObject *swig_obj[1] ;
28821
28822 if (!args) SWIG_fail;
28823 swig_obj[0] = args;
28824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28825 if (!SWIG_IsOK(res1)) {
28826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28827 }
28828 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 delete arg1;
28832
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 resultobj = SWIG_Py_Void();
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj = 0;
28845 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28846 wxTimeSpan *arg2 = 0 ;
28847 wxTimeSpan *result = 0 ;
28848 void *argp1 = 0 ;
28849 int res1 = 0 ;
28850 void *argp2 = 0 ;
28851 int res2 = 0 ;
28852 PyObject * obj0 = 0 ;
28853 PyObject * obj1 = 0 ;
28854 char * kwnames[] = {
28855 (char *) "self",(char *) "diff", NULL
28856 };
28857
28858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28860 if (!SWIG_IsOK(res1)) {
28861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28862 }
28863 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28865 if (!SWIG_IsOK(res2)) {
28866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28867 }
28868 if (!argp2) {
28869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28870 }
28871 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 {
28875 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28876 result = (wxTimeSpan *) &_result_ref;
28877 }
28878 wxPyEndAllowThreads(__tstate);
28879 if (PyErr_Occurred()) SWIG_fail;
28880 }
28881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28882 return resultobj;
28883 fail:
28884 return NULL;
28885 }
28886
28887
28888 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28889 PyObject *resultobj = 0;
28890 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28891 wxTimeSpan *arg2 = 0 ;
28892 wxTimeSpan *result = 0 ;
28893 void *argp1 = 0 ;
28894 int res1 = 0 ;
28895 void *argp2 = 0 ;
28896 int res2 = 0 ;
28897 PyObject * obj0 = 0 ;
28898 PyObject * obj1 = 0 ;
28899 char * kwnames[] = {
28900 (char *) "self",(char *) "diff", NULL
28901 };
28902
28903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
28904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28905 if (!SWIG_IsOK(res1)) {
28906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28907 }
28908 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28910 if (!SWIG_IsOK(res2)) {
28911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28912 }
28913 if (!argp2) {
28914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28915 }
28916 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 {
28920 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
28921 result = (wxTimeSpan *) &_result_ref;
28922 }
28923 wxPyEndAllowThreads(__tstate);
28924 if (PyErr_Occurred()) SWIG_fail;
28925 }
28926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28927 return resultobj;
28928 fail:
28929 return NULL;
28930 }
28931
28932
28933 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28934 PyObject *resultobj = 0;
28935 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28936 int arg2 ;
28937 wxTimeSpan *result = 0 ;
28938 void *argp1 = 0 ;
28939 int res1 = 0 ;
28940 int val2 ;
28941 int ecode2 = 0 ;
28942 PyObject * obj0 = 0 ;
28943 PyObject * obj1 = 0 ;
28944 char * kwnames[] = {
28945 (char *) "self",(char *) "n", NULL
28946 };
28947
28948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
28949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28950 if (!SWIG_IsOK(res1)) {
28951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28952 }
28953 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28954 ecode2 = SWIG_AsVal_int(obj1, &val2);
28955 if (!SWIG_IsOK(ecode2)) {
28956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
28957 }
28958 arg2 = static_cast< int >(val2);
28959 {
28960 PyThreadState* __tstate = wxPyBeginAllowThreads();
28961 {
28962 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
28963 result = (wxTimeSpan *) &_result_ref;
28964 }
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28976 PyObject *resultobj = 0;
28977 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28978 wxTimeSpan *result = 0 ;
28979 void *argp1 = 0 ;
28980 int res1 = 0 ;
28981 PyObject *swig_obj[1] ;
28982
28983 if (!args) SWIG_fail;
28984 swig_obj[0] = args;
28985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28986 if (!SWIG_IsOK(res1)) {
28987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28988 }
28989 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28990 {
28991 PyThreadState* __tstate = wxPyBeginAllowThreads();
28992 {
28993 wxTimeSpan &_result_ref = (arg1)->Neg();
28994 result = (wxTimeSpan *) &_result_ref;
28995 }
28996 wxPyEndAllowThreads(__tstate);
28997 if (PyErr_Occurred()) SWIG_fail;
28998 }
28999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29000 return resultobj;
29001 fail:
29002 return NULL;
29003 }
29004
29005
29006 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29007 PyObject *resultobj = 0;
29008 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29009 wxTimeSpan result;
29010 void *argp1 = 0 ;
29011 int res1 = 0 ;
29012 PyObject *swig_obj[1] ;
29013
29014 if (!args) SWIG_fail;
29015 swig_obj[0] = args;
29016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29017 if (!SWIG_IsOK(res1)) {
29018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29019 }
29020 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 result = ((wxTimeSpan const *)arg1)->Abs();
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj = 0;
29036 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29037 wxTimeSpan *arg2 = 0 ;
29038 wxTimeSpan *result = 0 ;
29039 void *argp1 = 0 ;
29040 int res1 = 0 ;
29041 void *argp2 = 0 ;
29042 int res2 = 0 ;
29043 PyObject * obj0 = 0 ;
29044 PyObject * obj1 = 0 ;
29045 char * kwnames[] = {
29046 (char *) "self",(char *) "diff", NULL
29047 };
29048
29049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29051 if (!SWIG_IsOK(res1)) {
29052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29053 }
29054 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29056 if (!SWIG_IsOK(res2)) {
29057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29058 }
29059 if (!argp2) {
29060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29061 }
29062 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 {
29066 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29067 result = (wxTimeSpan *) &_result_ref;
29068 }
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = 0;
29081 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29082 wxTimeSpan *arg2 = 0 ;
29083 wxTimeSpan *result = 0 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 void *argp2 = 0 ;
29087 int res2 = 0 ;
29088 PyObject * obj0 = 0 ;
29089 PyObject * obj1 = 0 ;
29090 char * kwnames[] = {
29091 (char *) "self",(char *) "diff", NULL
29092 };
29093
29094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29096 if (!SWIG_IsOK(res1)) {
29097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29098 }
29099 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29100 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29101 if (!SWIG_IsOK(res2)) {
29102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29103 }
29104 if (!argp2) {
29105 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29106 }
29107 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 {
29111 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29112 result = (wxTimeSpan *) &_result_ref;
29113 }
29114 wxPyEndAllowThreads(__tstate);
29115 if (PyErr_Occurred()) SWIG_fail;
29116 }
29117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29118 return resultobj;
29119 fail:
29120 return NULL;
29121 }
29122
29123
29124 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29125 PyObject *resultobj = 0;
29126 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29127 int arg2 ;
29128 wxTimeSpan *result = 0 ;
29129 void *argp1 = 0 ;
29130 int res1 = 0 ;
29131 int val2 ;
29132 int ecode2 = 0 ;
29133 PyObject * obj0 = 0 ;
29134 PyObject * obj1 = 0 ;
29135 char * kwnames[] = {
29136 (char *) "self",(char *) "n", NULL
29137 };
29138
29139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29141 if (!SWIG_IsOK(res1)) {
29142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29143 }
29144 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29145 ecode2 = SWIG_AsVal_int(obj1, &val2);
29146 if (!SWIG_IsOK(ecode2)) {
29147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29148 }
29149 arg2 = static_cast< int >(val2);
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 {
29153 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29154 result = (wxTimeSpan *) &_result_ref;
29155 }
29156 wxPyEndAllowThreads(__tstate);
29157 if (PyErr_Occurred()) SWIG_fail;
29158 }
29159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29160 return resultobj;
29161 fail:
29162 return NULL;
29163 }
29164
29165
29166 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29167 PyObject *resultobj = 0;
29168 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29169 wxTimeSpan *result = 0 ;
29170 void *argp1 = 0 ;
29171 int res1 = 0 ;
29172 PyObject *swig_obj[1] ;
29173
29174 if (!args) SWIG_fail;
29175 swig_obj[0] = args;
29176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29177 if (!SWIG_IsOK(res1)) {
29178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29179 }
29180 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 {
29184 wxTimeSpan &_result_ref = (arg1)->operator -();
29185 result = (wxTimeSpan *) &_result_ref;
29186 }
29187 wxPyEndAllowThreads(__tstate);
29188 if (PyErr_Occurred()) SWIG_fail;
29189 }
29190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29191 return resultobj;
29192 fail:
29193 return NULL;
29194 }
29195
29196
29197 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29198 PyObject *resultobj = 0;
29199 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29200 wxTimeSpan *arg2 = 0 ;
29201 wxTimeSpan result;
29202 void *argp1 = 0 ;
29203 int res1 = 0 ;
29204 void *argp2 = 0 ;
29205 int res2 = 0 ;
29206 PyObject * obj0 = 0 ;
29207 PyObject * obj1 = 0 ;
29208 char * kwnames[] = {
29209 (char *) "self",(char *) "other", NULL
29210 };
29211
29212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29214 if (!SWIG_IsOK(res1)) {
29215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29216 }
29217 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29218 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29219 if (!SWIG_IsOK(res2)) {
29220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29221 }
29222 if (!argp2) {
29223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29224 }
29225 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29226 {
29227 PyThreadState* __tstate = wxPyBeginAllowThreads();
29228 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29229 wxPyEndAllowThreads(__tstate);
29230 if (PyErr_Occurred()) SWIG_fail;
29231 }
29232 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29233 return resultobj;
29234 fail:
29235 return NULL;
29236 }
29237
29238
29239 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29240 PyObject *resultobj = 0;
29241 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29242 wxTimeSpan *arg2 = 0 ;
29243 wxTimeSpan result;
29244 void *argp1 = 0 ;
29245 int res1 = 0 ;
29246 void *argp2 = 0 ;
29247 int res2 = 0 ;
29248 PyObject * obj0 = 0 ;
29249 PyObject * obj1 = 0 ;
29250 char * kwnames[] = {
29251 (char *) "self",(char *) "other", NULL
29252 };
29253
29254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29256 if (!SWIG_IsOK(res1)) {
29257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29258 }
29259 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29260 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29261 if (!SWIG_IsOK(res2)) {
29262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29263 }
29264 if (!argp2) {
29265 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29266 }
29267 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29268 {
29269 PyThreadState* __tstate = wxPyBeginAllowThreads();
29270 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29271 wxPyEndAllowThreads(__tstate);
29272 if (PyErr_Occurred()) SWIG_fail;
29273 }
29274 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29275 return resultobj;
29276 fail:
29277 return NULL;
29278 }
29279
29280
29281 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29282 PyObject *resultobj = 0;
29283 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29284 int arg2 ;
29285 wxTimeSpan result;
29286 void *argp1 = 0 ;
29287 int res1 = 0 ;
29288 int val2 ;
29289 int ecode2 = 0 ;
29290 PyObject * obj0 = 0 ;
29291 PyObject * obj1 = 0 ;
29292 char * kwnames[] = {
29293 (char *) "self",(char *) "n", NULL
29294 };
29295
29296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29298 if (!SWIG_IsOK(res1)) {
29299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29300 }
29301 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29302 ecode2 = SWIG_AsVal_int(obj1, &val2);
29303 if (!SWIG_IsOK(ecode2)) {
29304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29305 }
29306 arg2 = static_cast< int >(val2);
29307 {
29308 PyThreadState* __tstate = wxPyBeginAllowThreads();
29309 result = wxTimeSpan___mul__(arg1,arg2);
29310 wxPyEndAllowThreads(__tstate);
29311 if (PyErr_Occurred()) SWIG_fail;
29312 }
29313 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29314 return resultobj;
29315 fail:
29316 return NULL;
29317 }
29318
29319
29320 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29321 PyObject *resultobj = 0;
29322 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29323 int arg2 ;
29324 wxTimeSpan result;
29325 void *argp1 = 0 ;
29326 int res1 = 0 ;
29327 int val2 ;
29328 int ecode2 = 0 ;
29329 PyObject * obj0 = 0 ;
29330 PyObject * obj1 = 0 ;
29331 char * kwnames[] = {
29332 (char *) "self",(char *) "n", NULL
29333 };
29334
29335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29337 if (!SWIG_IsOK(res1)) {
29338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29339 }
29340 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29341 ecode2 = SWIG_AsVal_int(obj1, &val2);
29342 if (!SWIG_IsOK(ecode2)) {
29343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29344 }
29345 arg2 = static_cast< int >(val2);
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 result = wxTimeSpan___rmul__(arg1,arg2);
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj = 0;
29361 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29362 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29363 bool result;
29364 void *argp1 = 0 ;
29365 int res1 = 0 ;
29366 void *argp2 = 0 ;
29367 int res2 = 0 ;
29368 PyObject * obj0 = 0 ;
29369 PyObject * obj1 = 0 ;
29370 char * kwnames[] = {
29371 (char *) "self",(char *) "other", NULL
29372 };
29373
29374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29376 if (!SWIG_IsOK(res1)) {
29377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29378 }
29379 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29381 if (!SWIG_IsOK(res2)) {
29382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29383 }
29384 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29388 wxPyEndAllowThreads(__tstate);
29389 if (PyErr_Occurred()) SWIG_fail;
29390 }
29391 {
29392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29393 }
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29401 PyObject *resultobj = 0;
29402 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29403 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29404 bool result;
29405 void *argp1 = 0 ;
29406 int res1 = 0 ;
29407 void *argp2 = 0 ;
29408 int res2 = 0 ;
29409 PyObject * obj0 = 0 ;
29410 PyObject * obj1 = 0 ;
29411 char * kwnames[] = {
29412 (char *) "self",(char *) "other", NULL
29413 };
29414
29415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29417 if (!SWIG_IsOK(res1)) {
29418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29419 }
29420 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29422 if (!SWIG_IsOK(res2)) {
29423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29424 }
29425 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29426 {
29427 PyThreadState* __tstate = wxPyBeginAllowThreads();
29428 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 {
29433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29434 }
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29442 PyObject *resultobj = 0;
29443 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29444 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29445 bool result;
29446 void *argp1 = 0 ;
29447 int res1 = 0 ;
29448 void *argp2 = 0 ;
29449 int res2 = 0 ;
29450 PyObject * obj0 = 0 ;
29451 PyObject * obj1 = 0 ;
29452 char * kwnames[] = {
29453 (char *) "self",(char *) "other", NULL
29454 };
29455
29456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29458 if (!SWIG_IsOK(res1)) {
29459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29460 }
29461 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29463 if (!SWIG_IsOK(res2)) {
29464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29465 }
29466 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29467 {
29468 PyThreadState* __tstate = wxPyBeginAllowThreads();
29469 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 {
29474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29475 }
29476 return resultobj;
29477 fail:
29478 return NULL;
29479 }
29480
29481
29482 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29483 PyObject *resultobj = 0;
29484 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29485 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29486 bool result;
29487 void *argp1 = 0 ;
29488 int res1 = 0 ;
29489 void *argp2 = 0 ;
29490 int res2 = 0 ;
29491 PyObject * obj0 = 0 ;
29492 PyObject * obj1 = 0 ;
29493 char * kwnames[] = {
29494 (char *) "self",(char *) "other", NULL
29495 };
29496
29497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29499 if (!SWIG_IsOK(res1)) {
29500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29501 }
29502 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29504 if (!SWIG_IsOK(res2)) {
29505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29506 }
29507 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29508 {
29509 PyThreadState* __tstate = wxPyBeginAllowThreads();
29510 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29511 wxPyEndAllowThreads(__tstate);
29512 if (PyErr_Occurred()) SWIG_fail;
29513 }
29514 {
29515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29516 }
29517 return resultobj;
29518 fail:
29519 return NULL;
29520 }
29521
29522
29523 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29524 PyObject *resultobj = 0;
29525 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29526 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29527 bool result;
29528 void *argp1 = 0 ;
29529 int res1 = 0 ;
29530 void *argp2 = 0 ;
29531 int res2 = 0 ;
29532 PyObject * obj0 = 0 ;
29533 PyObject * obj1 = 0 ;
29534 char * kwnames[] = {
29535 (char *) "self",(char *) "other", NULL
29536 };
29537
29538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29540 if (!SWIG_IsOK(res1)) {
29541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29542 }
29543 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29544 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29545 if (!SWIG_IsOK(res2)) {
29546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29547 }
29548 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29549 {
29550 PyThreadState* __tstate = wxPyBeginAllowThreads();
29551 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 {
29556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29557 }
29558 return resultobj;
29559 fail:
29560 return NULL;
29561 }
29562
29563
29564 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29565 PyObject *resultobj = 0;
29566 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29567 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29568 bool result;
29569 void *argp1 = 0 ;
29570 int res1 = 0 ;
29571 void *argp2 = 0 ;
29572 int res2 = 0 ;
29573 PyObject * obj0 = 0 ;
29574 PyObject * obj1 = 0 ;
29575 char * kwnames[] = {
29576 (char *) "self",(char *) "other", NULL
29577 };
29578
29579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29581 if (!SWIG_IsOK(res1)) {
29582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29583 }
29584 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29586 if (!SWIG_IsOK(res2)) {
29587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29588 }
29589 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29590 {
29591 PyThreadState* __tstate = wxPyBeginAllowThreads();
29592 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29593 wxPyEndAllowThreads(__tstate);
29594 if (PyErr_Occurred()) SWIG_fail;
29595 }
29596 {
29597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29598 }
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29606 PyObject *resultobj = 0;
29607 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29608 bool result;
29609 void *argp1 = 0 ;
29610 int res1 = 0 ;
29611 PyObject *swig_obj[1] ;
29612
29613 if (!args) SWIG_fail;
29614 swig_obj[0] = args;
29615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29616 if (!SWIG_IsOK(res1)) {
29617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29618 }
29619 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 {
29627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29628 }
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29636 PyObject *resultobj = 0;
29637 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29638 bool result;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 PyObject *swig_obj[1] ;
29642
29643 if (!args) SWIG_fail;
29644 swig_obj[0] = args;
29645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29648 }
29649 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 {
29657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29658 }
29659 return resultobj;
29660 fail:
29661 return NULL;
29662 }
29663
29664
29665 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29666 PyObject *resultobj = 0;
29667 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29668 bool result;
29669 void *argp1 = 0 ;
29670 int res1 = 0 ;
29671 PyObject *swig_obj[1] ;
29672
29673 if (!args) SWIG_fail;
29674 swig_obj[0] = args;
29675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29676 if (!SWIG_IsOK(res1)) {
29677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29678 }
29679 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29680 {
29681 PyThreadState* __tstate = wxPyBeginAllowThreads();
29682 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29683 wxPyEndAllowThreads(__tstate);
29684 if (PyErr_Occurred()) SWIG_fail;
29685 }
29686 {
29687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29688 }
29689 return resultobj;
29690 fail:
29691 return NULL;
29692 }
29693
29694
29695 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29696 PyObject *resultobj = 0;
29697 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29698 wxTimeSpan *arg2 = 0 ;
29699 bool result;
29700 void *argp1 = 0 ;
29701 int res1 = 0 ;
29702 void *argp2 = 0 ;
29703 int res2 = 0 ;
29704 PyObject * obj0 = 0 ;
29705 PyObject * obj1 = 0 ;
29706 char * kwnames[] = {
29707 (char *) "self",(char *) "ts", NULL
29708 };
29709
29710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29712 if (!SWIG_IsOK(res1)) {
29713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29714 }
29715 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29716 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29717 if (!SWIG_IsOK(res2)) {
29718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29719 }
29720 if (!argp2) {
29721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29722 }
29723 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29724 {
29725 PyThreadState* __tstate = wxPyBeginAllowThreads();
29726 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29727 wxPyEndAllowThreads(__tstate);
29728 if (PyErr_Occurred()) SWIG_fail;
29729 }
29730 {
29731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29732 }
29733 return resultobj;
29734 fail:
29735 return NULL;
29736 }
29737
29738
29739 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29740 PyObject *resultobj = 0;
29741 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29742 wxTimeSpan *arg2 = 0 ;
29743 bool result;
29744 void *argp1 = 0 ;
29745 int res1 = 0 ;
29746 void *argp2 = 0 ;
29747 int res2 = 0 ;
29748 PyObject * obj0 = 0 ;
29749 PyObject * obj1 = 0 ;
29750 char * kwnames[] = {
29751 (char *) "self",(char *) "ts", NULL
29752 };
29753
29754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29756 if (!SWIG_IsOK(res1)) {
29757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29758 }
29759 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29761 if (!SWIG_IsOK(res2)) {
29762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29763 }
29764 if (!argp2) {
29765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29766 }
29767 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29768 {
29769 PyThreadState* __tstate = wxPyBeginAllowThreads();
29770 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29771 wxPyEndAllowThreads(__tstate);
29772 if (PyErr_Occurred()) SWIG_fail;
29773 }
29774 {
29775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29776 }
29777 return resultobj;
29778 fail:
29779 return NULL;
29780 }
29781
29782
29783 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29784 PyObject *resultobj = 0;
29785 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29786 wxTimeSpan *arg2 = 0 ;
29787 bool result;
29788 void *argp1 = 0 ;
29789 int res1 = 0 ;
29790 void *argp2 = 0 ;
29791 int res2 = 0 ;
29792 PyObject * obj0 = 0 ;
29793 PyObject * obj1 = 0 ;
29794 char * kwnames[] = {
29795 (char *) "self",(char *) "t", NULL
29796 };
29797
29798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29800 if (!SWIG_IsOK(res1)) {
29801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29802 }
29803 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29804 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29805 if (!SWIG_IsOK(res2)) {
29806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29807 }
29808 if (!argp2) {
29809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29810 }
29811 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 {
29819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29820 }
29821 return resultobj;
29822 fail:
29823 return NULL;
29824 }
29825
29826
29827 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29828 PyObject *resultobj = 0;
29829 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29830 int result;
29831 void *argp1 = 0 ;
29832 int res1 = 0 ;
29833 PyObject *swig_obj[1] ;
29834
29835 if (!args) SWIG_fail;
29836 swig_obj[0] = args;
29837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29838 if (!SWIG_IsOK(res1)) {
29839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29840 }
29841 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29842 {
29843 PyThreadState* __tstate = wxPyBeginAllowThreads();
29844 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29845 wxPyEndAllowThreads(__tstate);
29846 if (PyErr_Occurred()) SWIG_fail;
29847 }
29848 resultobj = SWIG_From_int(static_cast< int >(result));
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29856 PyObject *resultobj = 0;
29857 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29858 int result;
29859 void *argp1 = 0 ;
29860 int res1 = 0 ;
29861 PyObject *swig_obj[1] ;
29862
29863 if (!args) SWIG_fail;
29864 swig_obj[0] = args;
29865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29866 if (!SWIG_IsOK(res1)) {
29867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29868 }
29869 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29870 {
29871 PyThreadState* __tstate = wxPyBeginAllowThreads();
29872 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 resultobj = SWIG_From_int(static_cast< int >(result));
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29884 PyObject *resultobj = 0;
29885 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29886 int result;
29887 void *argp1 = 0 ;
29888 int res1 = 0 ;
29889 PyObject *swig_obj[1] ;
29890
29891 if (!args) SWIG_fail;
29892 swig_obj[0] = args;
29893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29894 if (!SWIG_IsOK(res1)) {
29895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29896 }
29897 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 result = (int)((wxTimeSpan const *)arg1)->GetHours();
29901 wxPyEndAllowThreads(__tstate);
29902 if (PyErr_Occurred()) SWIG_fail;
29903 }
29904 resultobj = SWIG_From_int(static_cast< int >(result));
29905 return resultobj;
29906 fail:
29907 return NULL;
29908 }
29909
29910
29911 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29912 PyObject *resultobj = 0;
29913 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29914 int result;
29915 void *argp1 = 0 ;
29916 int res1 = 0 ;
29917 PyObject *swig_obj[1] ;
29918
29919 if (!args) SWIG_fail;
29920 swig_obj[0] = args;
29921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29922 if (!SWIG_IsOK(res1)) {
29923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29924 }
29925 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29926 {
29927 PyThreadState* __tstate = wxPyBeginAllowThreads();
29928 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
29929 wxPyEndAllowThreads(__tstate);
29930 if (PyErr_Occurred()) SWIG_fail;
29931 }
29932 resultobj = SWIG_From_int(static_cast< int >(result));
29933 return resultobj;
29934 fail:
29935 return NULL;
29936 }
29937
29938
29939 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29940 PyObject *resultobj = 0;
29941 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29942 wxLongLong result;
29943 void *argp1 = 0 ;
29944 int res1 = 0 ;
29945 PyObject *swig_obj[1] ;
29946
29947 if (!args) SWIG_fail;
29948 swig_obj[0] = args;
29949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29950 if (!SWIG_IsOK(res1)) {
29951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29952 }
29953 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29954 {
29955 PyThreadState* __tstate = wxPyBeginAllowThreads();
29956 result = ((wxTimeSpan const *)arg1)->GetSeconds();
29957 wxPyEndAllowThreads(__tstate);
29958 if (PyErr_Occurred()) SWIG_fail;
29959 }
29960 {
29961 PyObject *hi, *lo, *shifter, *shifted;
29962 hi = PyLong_FromLong( (&result)->GetHi() );
29963 lo = PyLong_FromLong( (&result)->GetLo() );
29964 shifter = PyLong_FromLong(32);
29965 shifted = PyNumber_Lshift(hi, shifter);
29966 resultobj = PyNumber_Or(shifted, lo);
29967 Py_DECREF(hi);
29968 Py_DECREF(lo);
29969 Py_DECREF(shifter);
29970 Py_DECREF(shifted);
29971 }
29972 return resultobj;
29973 fail:
29974 return NULL;
29975 }
29976
29977
29978 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29979 PyObject *resultobj = 0;
29980 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29981 wxLongLong result;
29982 void *argp1 = 0 ;
29983 int res1 = 0 ;
29984 PyObject *swig_obj[1] ;
29985
29986 if (!args) SWIG_fail;
29987 swig_obj[0] = args;
29988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29989 if (!SWIG_IsOK(res1)) {
29990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29991 }
29992 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 {
30000 PyObject *hi, *lo, *shifter, *shifted;
30001 hi = PyLong_FromLong( (&result)->GetHi() );
30002 lo = PyLong_FromLong( (&result)->GetLo() );
30003 shifter = PyLong_FromLong(32);
30004 shifted = PyNumber_Lshift(hi, shifter);
30005 resultobj = PyNumber_Or(shifted, lo);
30006 Py_DECREF(hi);
30007 Py_DECREF(lo);
30008 Py_DECREF(shifter);
30009 Py_DECREF(shifted);
30010 }
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30018 PyObject *resultobj = 0;
30019 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30020 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30021 wxString *arg2 = (wxString *) &arg2_defvalue ;
30022 wxString result;
30023 void *argp1 = 0 ;
30024 int res1 = 0 ;
30025 bool temp2 = false ;
30026 PyObject * obj0 = 0 ;
30027 PyObject * obj1 = 0 ;
30028 char * kwnames[] = {
30029 (char *) "self",(char *) "format", NULL
30030 };
30031
30032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30034 if (!SWIG_IsOK(res1)) {
30035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30036 }
30037 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30038 if (obj1) {
30039 {
30040 arg2 = wxString_in_helper(obj1);
30041 if (arg2 == NULL) SWIG_fail;
30042 temp2 = true;
30043 }
30044 }
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 {
30052 #if wxUSE_UNICODE
30053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30054 #else
30055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30056 #endif
30057 }
30058 {
30059 if (temp2)
30060 delete arg2;
30061 }
30062 return resultobj;
30063 fail:
30064 {
30065 if (temp2)
30066 delete arg2;
30067 }
30068 return NULL;
30069 }
30070
30071
30072 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30073 PyObject *obj;
30074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30075 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30076 return SWIG_Py_Void();
30077 }
30078
30079 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30080 return SWIG_Python_InitShadowInstance(args);
30081 }
30082
30083 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30084 PyObject *resultobj = 0;
30085 int arg1 = (int) 0 ;
30086 int arg2 = (int) 0 ;
30087 int arg3 = (int) 0 ;
30088 int arg4 = (int) 0 ;
30089 wxDateSpan *result = 0 ;
30090 int val1 ;
30091 int ecode1 = 0 ;
30092 int val2 ;
30093 int ecode2 = 0 ;
30094 int val3 ;
30095 int ecode3 = 0 ;
30096 int val4 ;
30097 int ecode4 = 0 ;
30098 PyObject * obj0 = 0 ;
30099 PyObject * obj1 = 0 ;
30100 PyObject * obj2 = 0 ;
30101 PyObject * obj3 = 0 ;
30102 char * kwnames[] = {
30103 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30104 };
30105
30106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30107 if (obj0) {
30108 ecode1 = SWIG_AsVal_int(obj0, &val1);
30109 if (!SWIG_IsOK(ecode1)) {
30110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30111 }
30112 arg1 = static_cast< int >(val1);
30113 }
30114 if (obj1) {
30115 ecode2 = SWIG_AsVal_int(obj1, &val2);
30116 if (!SWIG_IsOK(ecode2)) {
30117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30118 }
30119 arg2 = static_cast< int >(val2);
30120 }
30121 if (obj2) {
30122 ecode3 = SWIG_AsVal_int(obj2, &val3);
30123 if (!SWIG_IsOK(ecode3)) {
30124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30125 }
30126 arg3 = static_cast< int >(val3);
30127 }
30128 if (obj3) {
30129 ecode4 = SWIG_AsVal_int(obj3, &val4);
30130 if (!SWIG_IsOK(ecode4)) {
30131 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30132 }
30133 arg4 = static_cast< int >(val4);
30134 }
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30142 return resultobj;
30143 fail:
30144 return NULL;
30145 }
30146
30147
30148 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30149 PyObject *resultobj = 0;
30150 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30151 void *argp1 = 0 ;
30152 int res1 = 0 ;
30153 PyObject *swig_obj[1] ;
30154
30155 if (!args) SWIG_fail;
30156 swig_obj[0] = args;
30157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30158 if (!SWIG_IsOK(res1)) {
30159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30160 }
30161 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 delete arg1;
30165
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 resultobj = SWIG_Py_Void();
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj = 0;
30178 int arg1 ;
30179 wxDateSpan result;
30180 int val1 ;
30181 int ecode1 = 0 ;
30182 PyObject * obj0 = 0 ;
30183 char * kwnames[] = {
30184 (char *) "days", NULL
30185 };
30186
30187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30188 ecode1 = SWIG_AsVal_int(obj0, &val1);
30189 if (!SWIG_IsOK(ecode1)) {
30190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30191 }
30192 arg1 = static_cast< int >(val1);
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = wxDateSpan::Days(arg1);
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30207 PyObject *resultobj = 0;
30208 wxDateSpan result;
30209
30210 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30211 {
30212 PyThreadState* __tstate = wxPyBeginAllowThreads();
30213 result = wxDateSpan::Day();
30214 wxPyEndAllowThreads(__tstate);
30215 if (PyErr_Occurred()) SWIG_fail;
30216 }
30217 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30218 return resultobj;
30219 fail:
30220 return NULL;
30221 }
30222
30223
30224 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30225 PyObject *resultobj = 0;
30226 int arg1 ;
30227 wxDateSpan result;
30228 int val1 ;
30229 int ecode1 = 0 ;
30230 PyObject * obj0 = 0 ;
30231 char * kwnames[] = {
30232 (char *) "weeks", NULL
30233 };
30234
30235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30236 ecode1 = SWIG_AsVal_int(obj0, &val1);
30237 if (!SWIG_IsOK(ecode1)) {
30238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30239 }
30240 arg1 = static_cast< int >(val1);
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = wxDateSpan::Weeks(arg1);
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30248 return resultobj;
30249 fail:
30250 return NULL;
30251 }
30252
30253
30254 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30255 PyObject *resultobj = 0;
30256 wxDateSpan result;
30257
30258 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 result = wxDateSpan::Week();
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30273 PyObject *resultobj = 0;
30274 int arg1 ;
30275 wxDateSpan result;
30276 int val1 ;
30277 int ecode1 = 0 ;
30278 PyObject * obj0 = 0 ;
30279 char * kwnames[] = {
30280 (char *) "mon", NULL
30281 };
30282
30283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30284 ecode1 = SWIG_AsVal_int(obj0, &val1);
30285 if (!SWIG_IsOK(ecode1)) {
30286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30287 }
30288 arg1 = static_cast< int >(val1);
30289 {
30290 PyThreadState* __tstate = wxPyBeginAllowThreads();
30291 result = wxDateSpan::Months(arg1);
30292 wxPyEndAllowThreads(__tstate);
30293 if (PyErr_Occurred()) SWIG_fail;
30294 }
30295 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30296 return resultobj;
30297 fail:
30298 return NULL;
30299 }
30300
30301
30302 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30303 PyObject *resultobj = 0;
30304 wxDateSpan result;
30305
30306 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 result = wxDateSpan::Month();
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj = 0;
30322 int arg1 ;
30323 wxDateSpan result;
30324 int val1 ;
30325 int ecode1 = 0 ;
30326 PyObject * obj0 = 0 ;
30327 char * kwnames[] = {
30328 (char *) "years", NULL
30329 };
30330
30331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30332 ecode1 = SWIG_AsVal_int(obj0, &val1);
30333 if (!SWIG_IsOK(ecode1)) {
30334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30335 }
30336 arg1 = static_cast< int >(val1);
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = wxDateSpan::Years(arg1);
30340 wxPyEndAllowThreads(__tstate);
30341 if (PyErr_Occurred()) SWIG_fail;
30342 }
30343 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30344 return resultobj;
30345 fail:
30346 return NULL;
30347 }
30348
30349
30350 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30351 PyObject *resultobj = 0;
30352 wxDateSpan result;
30353
30354 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30355 {
30356 PyThreadState* __tstate = wxPyBeginAllowThreads();
30357 result = wxDateSpan::Year();
30358 wxPyEndAllowThreads(__tstate);
30359 if (PyErr_Occurred()) SWIG_fail;
30360 }
30361 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30362 return resultobj;
30363 fail:
30364 return NULL;
30365 }
30366
30367
30368 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30369 PyObject *resultobj = 0;
30370 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30371 int arg2 ;
30372 wxDateSpan *result = 0 ;
30373 void *argp1 = 0 ;
30374 int res1 = 0 ;
30375 int val2 ;
30376 int ecode2 = 0 ;
30377 PyObject * obj0 = 0 ;
30378 PyObject * obj1 = 0 ;
30379 char * kwnames[] = {
30380 (char *) "self",(char *) "n", NULL
30381 };
30382
30383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30385 if (!SWIG_IsOK(res1)) {
30386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30387 }
30388 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30389 ecode2 = SWIG_AsVal_int(obj1, &val2);
30390 if (!SWIG_IsOK(ecode2)) {
30391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30392 }
30393 arg2 = static_cast< int >(val2);
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 {
30397 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30398 result = (wxDateSpan *) &_result_ref;
30399 }
30400 wxPyEndAllowThreads(__tstate);
30401 if (PyErr_Occurred()) SWIG_fail;
30402 }
30403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30404 return resultobj;
30405 fail:
30406 return NULL;
30407 }
30408
30409
30410 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30411 PyObject *resultobj = 0;
30412 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30413 int arg2 ;
30414 wxDateSpan *result = 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 int val2 ;
30418 int ecode2 = 0 ;
30419 PyObject * obj0 = 0 ;
30420 PyObject * obj1 = 0 ;
30421 char * kwnames[] = {
30422 (char *) "self",(char *) "n", NULL
30423 };
30424
30425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30427 if (!SWIG_IsOK(res1)) {
30428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30429 }
30430 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30431 ecode2 = SWIG_AsVal_int(obj1, &val2);
30432 if (!SWIG_IsOK(ecode2)) {
30433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30434 }
30435 arg2 = static_cast< int >(val2);
30436 {
30437 PyThreadState* __tstate = wxPyBeginAllowThreads();
30438 {
30439 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30440 result = (wxDateSpan *) &_result_ref;
30441 }
30442 wxPyEndAllowThreads(__tstate);
30443 if (PyErr_Occurred()) SWIG_fail;
30444 }
30445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30446 return resultobj;
30447 fail:
30448 return NULL;
30449 }
30450
30451
30452 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30453 PyObject *resultobj = 0;
30454 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30455 int arg2 ;
30456 wxDateSpan *result = 0 ;
30457 void *argp1 = 0 ;
30458 int res1 = 0 ;
30459 int val2 ;
30460 int ecode2 = 0 ;
30461 PyObject * obj0 = 0 ;
30462 PyObject * obj1 = 0 ;
30463 char * kwnames[] = {
30464 (char *) "self",(char *) "n", NULL
30465 };
30466
30467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30469 if (!SWIG_IsOK(res1)) {
30470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30471 }
30472 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30473 ecode2 = SWIG_AsVal_int(obj1, &val2);
30474 if (!SWIG_IsOK(ecode2)) {
30475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30476 }
30477 arg2 = static_cast< int >(val2);
30478 {
30479 PyThreadState* __tstate = wxPyBeginAllowThreads();
30480 {
30481 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30482 result = (wxDateSpan *) &_result_ref;
30483 }
30484 wxPyEndAllowThreads(__tstate);
30485 if (PyErr_Occurred()) SWIG_fail;
30486 }
30487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30488 return resultobj;
30489 fail:
30490 return NULL;
30491 }
30492
30493
30494 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30495 PyObject *resultobj = 0;
30496 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30497 int arg2 ;
30498 wxDateSpan *result = 0 ;
30499 void *argp1 = 0 ;
30500 int res1 = 0 ;
30501 int val2 ;
30502 int ecode2 = 0 ;
30503 PyObject * obj0 = 0 ;
30504 PyObject * obj1 = 0 ;
30505 char * kwnames[] = {
30506 (char *) "self",(char *) "n", NULL
30507 };
30508
30509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30511 if (!SWIG_IsOK(res1)) {
30512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30513 }
30514 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30515 ecode2 = SWIG_AsVal_int(obj1, &val2);
30516 if (!SWIG_IsOK(ecode2)) {
30517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30518 }
30519 arg2 = static_cast< int >(val2);
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 {
30523 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30524 result = (wxDateSpan *) &_result_ref;
30525 }
30526 wxPyEndAllowThreads(__tstate);
30527 if (PyErr_Occurred()) SWIG_fail;
30528 }
30529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30537 PyObject *resultobj = 0;
30538 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30539 int result;
30540 void *argp1 = 0 ;
30541 int res1 = 0 ;
30542 PyObject *swig_obj[1] ;
30543
30544 if (!args) SWIG_fail;
30545 swig_obj[0] = args;
30546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30547 if (!SWIG_IsOK(res1)) {
30548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30549 }
30550 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30551 {
30552 PyThreadState* __tstate = wxPyBeginAllowThreads();
30553 result = (int)((wxDateSpan const *)arg1)->GetYears();
30554 wxPyEndAllowThreads(__tstate);
30555 if (PyErr_Occurred()) SWIG_fail;
30556 }
30557 resultobj = SWIG_From_int(static_cast< int >(result));
30558 return resultobj;
30559 fail:
30560 return NULL;
30561 }
30562
30563
30564 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30565 PyObject *resultobj = 0;
30566 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30567 int result;
30568 void *argp1 = 0 ;
30569 int res1 = 0 ;
30570 PyObject *swig_obj[1] ;
30571
30572 if (!args) SWIG_fail;
30573 swig_obj[0] = args;
30574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30575 if (!SWIG_IsOK(res1)) {
30576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30577 }
30578 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30579 {
30580 PyThreadState* __tstate = wxPyBeginAllowThreads();
30581 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30582 wxPyEndAllowThreads(__tstate);
30583 if (PyErr_Occurred()) SWIG_fail;
30584 }
30585 resultobj = SWIG_From_int(static_cast< int >(result));
30586 return resultobj;
30587 fail:
30588 return NULL;
30589 }
30590
30591
30592 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30593 PyObject *resultobj = 0;
30594 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30595 int result;
30596 void *argp1 = 0 ;
30597 int res1 = 0 ;
30598 PyObject *swig_obj[1] ;
30599
30600 if (!args) SWIG_fail;
30601 swig_obj[0] = args;
30602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30603 if (!SWIG_IsOK(res1)) {
30604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30605 }
30606 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30607 {
30608 PyThreadState* __tstate = wxPyBeginAllowThreads();
30609 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30610 wxPyEndAllowThreads(__tstate);
30611 if (PyErr_Occurred()) SWIG_fail;
30612 }
30613 resultobj = SWIG_From_int(static_cast< int >(result));
30614 return resultobj;
30615 fail:
30616 return NULL;
30617 }
30618
30619
30620 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30621 PyObject *resultobj = 0;
30622 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30623 int result;
30624 void *argp1 = 0 ;
30625 int res1 = 0 ;
30626 PyObject *swig_obj[1] ;
30627
30628 if (!args) SWIG_fail;
30629 swig_obj[0] = args;
30630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30631 if (!SWIG_IsOK(res1)) {
30632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30633 }
30634 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 result = (int)((wxDateSpan const *)arg1)->GetDays();
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 resultobj = SWIG_From_int(static_cast< int >(result));
30642 return resultobj;
30643 fail:
30644 return NULL;
30645 }
30646
30647
30648 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30649 PyObject *resultobj = 0;
30650 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30651 int result;
30652 void *argp1 = 0 ;
30653 int res1 = 0 ;
30654 PyObject *swig_obj[1] ;
30655
30656 if (!args) SWIG_fail;
30657 swig_obj[0] = args;
30658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30659 if (!SWIG_IsOK(res1)) {
30660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30661 }
30662 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 resultobj = SWIG_From_int(static_cast< int >(result));
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj = 0;
30678 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30679 wxDateSpan *arg2 = 0 ;
30680 wxDateSpan *result = 0 ;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 void *argp2 = 0 ;
30684 int res2 = 0 ;
30685 PyObject * obj0 = 0 ;
30686 PyObject * obj1 = 0 ;
30687 char * kwnames[] = {
30688 (char *) "self",(char *) "other", NULL
30689 };
30690
30691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30693 if (!SWIG_IsOK(res1)) {
30694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30695 }
30696 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30698 if (!SWIG_IsOK(res2)) {
30699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30700 }
30701 if (!argp2) {
30702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30703 }
30704 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 {
30708 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30709 result = (wxDateSpan *) &_result_ref;
30710 }
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30715 return resultobj;
30716 fail:
30717 return NULL;
30718 }
30719
30720
30721 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30722 PyObject *resultobj = 0;
30723 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30724 wxDateSpan *arg2 = 0 ;
30725 wxDateSpan *result = 0 ;
30726 void *argp1 = 0 ;
30727 int res1 = 0 ;
30728 void *argp2 = 0 ;
30729 int res2 = 0 ;
30730 PyObject * obj0 = 0 ;
30731 PyObject * obj1 = 0 ;
30732 char * kwnames[] = {
30733 (char *) "self",(char *) "other", NULL
30734 };
30735
30736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30738 if (!SWIG_IsOK(res1)) {
30739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30740 }
30741 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30743 if (!SWIG_IsOK(res2)) {
30744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30745 }
30746 if (!argp2) {
30747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30748 }
30749 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 {
30753 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30754 result = (wxDateSpan *) &_result_ref;
30755 }
30756 wxPyEndAllowThreads(__tstate);
30757 if (PyErr_Occurred()) SWIG_fail;
30758 }
30759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30767 PyObject *resultobj = 0;
30768 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30769 wxDateSpan *result = 0 ;
30770 void *argp1 = 0 ;
30771 int res1 = 0 ;
30772 PyObject *swig_obj[1] ;
30773
30774 if (!args) SWIG_fail;
30775 swig_obj[0] = args;
30776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30777 if (!SWIG_IsOK(res1)) {
30778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30779 }
30780 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30781 {
30782 PyThreadState* __tstate = wxPyBeginAllowThreads();
30783 {
30784 wxDateSpan &_result_ref = (arg1)->Neg();
30785 result = (wxDateSpan *) &_result_ref;
30786 }
30787 wxPyEndAllowThreads(__tstate);
30788 if (PyErr_Occurred()) SWIG_fail;
30789 }
30790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30791 return resultobj;
30792 fail:
30793 return NULL;
30794 }
30795
30796
30797 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30798 PyObject *resultobj = 0;
30799 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30800 int arg2 ;
30801 wxDateSpan *result = 0 ;
30802 void *argp1 = 0 ;
30803 int res1 = 0 ;
30804 int val2 ;
30805 int ecode2 = 0 ;
30806 PyObject * obj0 = 0 ;
30807 PyObject * obj1 = 0 ;
30808 char * kwnames[] = {
30809 (char *) "self",(char *) "factor", NULL
30810 };
30811
30812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30814 if (!SWIG_IsOK(res1)) {
30815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30816 }
30817 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30818 ecode2 = SWIG_AsVal_int(obj1, &val2);
30819 if (!SWIG_IsOK(ecode2)) {
30820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30821 }
30822 arg2 = static_cast< int >(val2);
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 {
30826 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30827 result = (wxDateSpan *) &_result_ref;
30828 }
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30840 PyObject *resultobj = 0;
30841 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30842 wxDateSpan *arg2 = 0 ;
30843 wxDateSpan *result = 0 ;
30844 void *argp1 = 0 ;
30845 int res1 = 0 ;
30846 void *argp2 = 0 ;
30847 int res2 = 0 ;
30848 PyObject * obj0 = 0 ;
30849 PyObject * obj1 = 0 ;
30850 char * kwnames[] = {
30851 (char *) "self",(char *) "other", NULL
30852 };
30853
30854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30856 if (!SWIG_IsOK(res1)) {
30857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30858 }
30859 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30861 if (!SWIG_IsOK(res2)) {
30862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30863 }
30864 if (!argp2) {
30865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30866 }
30867 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 {
30871 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30872 result = (wxDateSpan *) &_result_ref;
30873 }
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30885 PyObject *resultobj = 0;
30886 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30887 wxDateSpan *arg2 = 0 ;
30888 wxDateSpan *result = 0 ;
30889 void *argp1 = 0 ;
30890 int res1 = 0 ;
30891 void *argp2 = 0 ;
30892 int res2 = 0 ;
30893 PyObject * obj0 = 0 ;
30894 PyObject * obj1 = 0 ;
30895 char * kwnames[] = {
30896 (char *) "self",(char *) "other", NULL
30897 };
30898
30899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
30900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30901 if (!SWIG_IsOK(res1)) {
30902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30903 }
30904 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30905 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30906 if (!SWIG_IsOK(res2)) {
30907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30908 }
30909 if (!argp2) {
30910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30911 }
30912 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 {
30916 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
30917 result = (wxDateSpan *) &_result_ref;
30918 }
30919 wxPyEndAllowThreads(__tstate);
30920 if (PyErr_Occurred()) SWIG_fail;
30921 }
30922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30923 return resultobj;
30924 fail:
30925 return NULL;
30926 }
30927
30928
30929 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30930 PyObject *resultobj = 0;
30931 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30932 wxDateSpan *result = 0 ;
30933 void *argp1 = 0 ;
30934 int res1 = 0 ;
30935 PyObject *swig_obj[1] ;
30936
30937 if (!args) SWIG_fail;
30938 swig_obj[0] = args;
30939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30940 if (!SWIG_IsOK(res1)) {
30941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30942 }
30943 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30944 {
30945 PyThreadState* __tstate = wxPyBeginAllowThreads();
30946 {
30947 wxDateSpan &_result_ref = (arg1)->operator -();
30948 result = (wxDateSpan *) &_result_ref;
30949 }
30950 wxPyEndAllowThreads(__tstate);
30951 if (PyErr_Occurred()) SWIG_fail;
30952 }
30953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30954 return resultobj;
30955 fail:
30956 return NULL;
30957 }
30958
30959
30960 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30961 PyObject *resultobj = 0;
30962 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30963 int arg2 ;
30964 wxDateSpan *result = 0 ;
30965 void *argp1 = 0 ;
30966 int res1 = 0 ;
30967 int val2 ;
30968 int ecode2 = 0 ;
30969 PyObject * obj0 = 0 ;
30970 PyObject * obj1 = 0 ;
30971 char * kwnames[] = {
30972 (char *) "self",(char *) "factor", NULL
30973 };
30974
30975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30977 if (!SWIG_IsOK(res1)) {
30978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30979 }
30980 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30981 ecode2 = SWIG_AsVal_int(obj1, &val2);
30982 if (!SWIG_IsOK(ecode2)) {
30983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30984 }
30985 arg2 = static_cast< int >(val2);
30986 {
30987 PyThreadState* __tstate = wxPyBeginAllowThreads();
30988 {
30989 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30990 result = (wxDateSpan *) &_result_ref;
30991 }
30992 wxPyEndAllowThreads(__tstate);
30993 if (PyErr_Occurred()) SWIG_fail;
30994 }
30995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31003 PyObject *resultobj = 0;
31004 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31005 wxDateSpan *arg2 = 0 ;
31006 wxDateSpan result;
31007 void *argp1 = 0 ;
31008 int res1 = 0 ;
31009 void *argp2 = 0 ;
31010 int res2 = 0 ;
31011 PyObject * obj0 = 0 ;
31012 PyObject * obj1 = 0 ;
31013 char * kwnames[] = {
31014 (char *) "self",(char *) "other", NULL
31015 };
31016
31017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31019 if (!SWIG_IsOK(res1)) {
31020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31021 }
31022 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31023 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31024 if (!SWIG_IsOK(res2)) {
31025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31026 }
31027 if (!argp2) {
31028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31029 }
31030 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31031 {
31032 PyThreadState* __tstate = wxPyBeginAllowThreads();
31033 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31038 return resultobj;
31039 fail:
31040 return NULL;
31041 }
31042
31043
31044 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31045 PyObject *resultobj = 0;
31046 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31047 wxDateSpan *arg2 = 0 ;
31048 wxDateSpan result;
31049 void *argp1 = 0 ;
31050 int res1 = 0 ;
31051 void *argp2 = 0 ;
31052 int res2 = 0 ;
31053 PyObject * obj0 = 0 ;
31054 PyObject * obj1 = 0 ;
31055 char * kwnames[] = {
31056 (char *) "self",(char *) "other", NULL
31057 };
31058
31059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31061 if (!SWIG_IsOK(res1)) {
31062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31063 }
31064 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31065 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31066 if (!SWIG_IsOK(res2)) {
31067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31068 }
31069 if (!argp2) {
31070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31071 }
31072 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31073 {
31074 PyThreadState* __tstate = wxPyBeginAllowThreads();
31075 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj = 0;
31088 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31089 int arg2 ;
31090 wxDateSpan result;
31091 void *argp1 = 0 ;
31092 int res1 = 0 ;
31093 int val2 ;
31094 int ecode2 = 0 ;
31095 PyObject * obj0 = 0 ;
31096 PyObject * obj1 = 0 ;
31097 char * kwnames[] = {
31098 (char *) "self",(char *) "n", NULL
31099 };
31100
31101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31103 if (!SWIG_IsOK(res1)) {
31104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31105 }
31106 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31107 ecode2 = SWIG_AsVal_int(obj1, &val2);
31108 if (!SWIG_IsOK(ecode2)) {
31109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31110 }
31111 arg2 = static_cast< int >(val2);
31112 {
31113 PyThreadState* __tstate = wxPyBeginAllowThreads();
31114 result = wxDateSpan___mul__(arg1,arg2);
31115 wxPyEndAllowThreads(__tstate);
31116 if (PyErr_Occurred()) SWIG_fail;
31117 }
31118 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31119 return resultobj;
31120 fail:
31121 return NULL;
31122 }
31123
31124
31125 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31126 PyObject *resultobj = 0;
31127 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31128 int arg2 ;
31129 wxDateSpan result;
31130 void *argp1 = 0 ;
31131 int res1 = 0 ;
31132 int val2 ;
31133 int ecode2 = 0 ;
31134 PyObject * obj0 = 0 ;
31135 PyObject * obj1 = 0 ;
31136 char * kwnames[] = {
31137 (char *) "self",(char *) "n", NULL
31138 };
31139
31140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31142 if (!SWIG_IsOK(res1)) {
31143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31144 }
31145 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31146 ecode2 = SWIG_AsVal_int(obj1, &val2);
31147 if (!SWIG_IsOK(ecode2)) {
31148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31149 }
31150 arg2 = static_cast< int >(val2);
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = wxDateSpan___rmul__(arg1,arg2);
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj = 0;
31166 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31167 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31168 bool result;
31169 void *argp1 = 0 ;
31170 int res1 = 0 ;
31171 void *argp2 = 0 ;
31172 int res2 = 0 ;
31173 PyObject * obj0 = 0 ;
31174 PyObject * obj1 = 0 ;
31175 char * kwnames[] = {
31176 (char *) "self",(char *) "other", NULL
31177 };
31178
31179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31181 if (!SWIG_IsOK(res1)) {
31182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31183 }
31184 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31186 if (!SWIG_IsOK(res2)) {
31187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31188 }
31189 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31190 {
31191 PyThreadState* __tstate = wxPyBeginAllowThreads();
31192 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 {
31197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31198 }
31199 return resultobj;
31200 fail:
31201 return NULL;
31202 }
31203
31204
31205 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31206 PyObject *resultobj = 0;
31207 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31208 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31209 bool result;
31210 void *argp1 = 0 ;
31211 int res1 = 0 ;
31212 void *argp2 = 0 ;
31213 int res2 = 0 ;
31214 PyObject * obj0 = 0 ;
31215 PyObject * obj1 = 0 ;
31216 char * kwnames[] = {
31217 (char *) "self",(char *) "other", NULL
31218 };
31219
31220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31222 if (!SWIG_IsOK(res1)) {
31223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31224 }
31225 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31226 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31227 if (!SWIG_IsOK(res2)) {
31228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31229 }
31230 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31231 {
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31234 wxPyEndAllowThreads(__tstate);
31235 if (PyErr_Occurred()) SWIG_fail;
31236 }
31237 {
31238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31239 }
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31247 PyObject *obj;
31248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31249 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31250 return SWIG_Py_Void();
31251 }
31252
31253 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31254 return SWIG_Python_InitShadowInstance(args);
31255 }
31256
31257 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31258 PyObject *resultobj = 0;
31259 long result;
31260
31261 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 result = (long)wxGetLocalTime();
31265 wxPyEndAllowThreads(__tstate);
31266 if (PyErr_Occurred()) SWIG_fail;
31267 }
31268 resultobj = SWIG_From_long(static_cast< long >(result));
31269 return resultobj;
31270 fail:
31271 return NULL;
31272 }
31273
31274
31275 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31276 PyObject *resultobj = 0;
31277 long result;
31278
31279 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31280 {
31281 PyThreadState* __tstate = wxPyBeginAllowThreads();
31282 result = (long)wxGetUTCTime();
31283 wxPyEndAllowThreads(__tstate);
31284 if (PyErr_Occurred()) SWIG_fail;
31285 }
31286 resultobj = SWIG_From_long(static_cast< long >(result));
31287 return resultobj;
31288 fail:
31289 return NULL;
31290 }
31291
31292
31293 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31294 PyObject *resultobj = 0;
31295 long result;
31296
31297 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31298 {
31299 PyThreadState* __tstate = wxPyBeginAllowThreads();
31300 result = (long)wxGetCurrentTime();
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 resultobj = SWIG_From_long(static_cast< long >(result));
31305 return resultobj;
31306 fail:
31307 return NULL;
31308 }
31309
31310
31311 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31312 PyObject *resultobj = 0;
31313 wxLongLong result;
31314
31315 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 result = wxGetLocalTimeMillis();
31319 wxPyEndAllowThreads(__tstate);
31320 if (PyErr_Occurred()) SWIG_fail;
31321 }
31322 {
31323 PyObject *hi, *lo, *shifter, *shifted;
31324 hi = PyLong_FromLong( (&result)->GetHi() );
31325 lo = PyLong_FromLong( (&result)->GetLo() );
31326 shifter = PyLong_FromLong(32);
31327 shifted = PyNumber_Lshift(hi, shifter);
31328 resultobj = PyNumber_Or(shifted, lo);
31329 Py_DECREF(hi);
31330 Py_DECREF(lo);
31331 Py_DECREF(shifter);
31332 Py_DECREF(shifted);
31333 }
31334 return resultobj;
31335 fail:
31336 return NULL;
31337 }
31338
31339
31340 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31341 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31342 return 1;
31343 }
31344
31345
31346 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31347 PyObject *pyobj = 0;
31348
31349 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31350 return pyobj;
31351 }
31352
31353
31354 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31355 PyObject *resultobj = 0;
31356 wxDataFormatId arg1 ;
31357 wxDataFormat *result = 0 ;
31358 int val1 ;
31359 int ecode1 = 0 ;
31360 PyObject * obj0 = 0 ;
31361 char * kwnames[] = {
31362 (char *) "type", NULL
31363 };
31364
31365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31366 ecode1 = SWIG_AsVal_int(obj0, &val1);
31367 if (!SWIG_IsOK(ecode1)) {
31368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31369 }
31370 arg1 = static_cast< wxDataFormatId >(val1);
31371 {
31372 PyThreadState* __tstate = wxPyBeginAllowThreads();
31373 result = (wxDataFormat *)new wxDataFormat(arg1);
31374 wxPyEndAllowThreads(__tstate);
31375 if (PyErr_Occurred()) SWIG_fail;
31376 }
31377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31378 return resultobj;
31379 fail:
31380 return NULL;
31381 }
31382
31383
31384 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31385 PyObject *resultobj = 0;
31386 wxString *arg1 = 0 ;
31387 wxDataFormat *result = 0 ;
31388 bool temp1 = false ;
31389 PyObject * obj0 = 0 ;
31390 char * kwnames[] = {
31391 (char *) "format", NULL
31392 };
31393
31394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31395 {
31396 arg1 = wxString_in_helper(obj0);
31397 if (arg1 == NULL) SWIG_fail;
31398 temp1 = true;
31399 }
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31403 wxPyEndAllowThreads(__tstate);
31404 if (PyErr_Occurred()) SWIG_fail;
31405 }
31406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31407 {
31408 if (temp1)
31409 delete arg1;
31410 }
31411 return resultobj;
31412 fail:
31413 {
31414 if (temp1)
31415 delete arg1;
31416 }
31417 return NULL;
31418 }
31419
31420
31421 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31422 PyObject *resultobj = 0;
31423 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31424 void *argp1 = 0 ;
31425 int res1 = 0 ;
31426 PyObject *swig_obj[1] ;
31427
31428 if (!args) SWIG_fail;
31429 swig_obj[0] = args;
31430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31431 if (!SWIG_IsOK(res1)) {
31432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31433 }
31434 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31435 {
31436 PyThreadState* __tstate = wxPyBeginAllowThreads();
31437 delete arg1;
31438
31439 wxPyEndAllowThreads(__tstate);
31440 if (PyErr_Occurred()) SWIG_fail;
31441 }
31442 resultobj = SWIG_Py_Void();
31443 return resultobj;
31444 fail:
31445 return NULL;
31446 }
31447
31448
31449 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31450 PyObject *resultobj = 0;
31451 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31452 wxDataFormatId arg2 ;
31453 bool result;
31454 void *argp1 = 0 ;
31455 int res1 = 0 ;
31456 int val2 ;
31457 int ecode2 = 0 ;
31458
31459 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31461 if (!SWIG_IsOK(res1)) {
31462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31463 }
31464 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31465 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31466 if (!SWIG_IsOK(ecode2)) {
31467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31468 }
31469 arg2 = static_cast< wxDataFormatId >(val2);
31470 {
31471 PyThreadState* __tstate = wxPyBeginAllowThreads();
31472 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31473 wxPyEndAllowThreads(__tstate);
31474 if (PyErr_Occurred()) SWIG_fail;
31475 }
31476 {
31477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31478 }
31479 return resultobj;
31480 fail:
31481 return NULL;
31482 }
31483
31484
31485 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31486 PyObject *resultobj = 0;
31487 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31488 wxDataFormatId arg2 ;
31489 bool result;
31490 void *argp1 = 0 ;
31491 int res1 = 0 ;
31492 int val2 ;
31493 int ecode2 = 0 ;
31494
31495 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31497 if (!SWIG_IsOK(res1)) {
31498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31499 }
31500 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31501 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31502 if (!SWIG_IsOK(ecode2)) {
31503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31504 }
31505 arg2 = static_cast< wxDataFormatId >(val2);
31506 {
31507 PyThreadState* __tstate = wxPyBeginAllowThreads();
31508 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31509 wxPyEndAllowThreads(__tstate);
31510 if (PyErr_Occurred()) SWIG_fail;
31511 }
31512 {
31513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31514 }
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31522 PyObject *resultobj = 0;
31523 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31524 wxDataFormat *arg2 = 0 ;
31525 bool result;
31526 void *argp1 = 0 ;
31527 int res1 = 0 ;
31528 void *argp2 = 0 ;
31529 int res2 = 0 ;
31530
31531 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31533 if (!SWIG_IsOK(res1)) {
31534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31535 }
31536 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31537 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31538 if (!SWIG_IsOK(res2)) {
31539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31540 }
31541 if (!argp2) {
31542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31543 }
31544 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31545 {
31546 PyThreadState* __tstate = wxPyBeginAllowThreads();
31547 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31548 wxPyEndAllowThreads(__tstate);
31549 if (PyErr_Occurred()) SWIG_fail;
31550 }
31551 {
31552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31553 }
31554 return resultobj;
31555 fail:
31556 return NULL;
31557 }
31558
31559
31560 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31561 int argc;
31562 PyObject *argv[3];
31563
31564 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31565 --argc;
31566 if (argc == 2) {
31567 int _v = 0;
31568 {
31569 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31570 _v = SWIG_CheckState(res);
31571 }
31572 if (!_v) goto check_1;
31573 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31574 }
31575 check_1:
31576
31577 if (argc == 2) {
31578 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31579 }
31580
31581 fail:
31582 Py_INCREF(Py_NotImplemented);
31583 return Py_NotImplemented;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31588 PyObject *resultobj = 0;
31589 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31590 wxDataFormat *arg2 = 0 ;
31591 bool result;
31592 void *argp1 = 0 ;
31593 int res1 = 0 ;
31594 void *argp2 = 0 ;
31595 int res2 = 0 ;
31596
31597 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31599 if (!SWIG_IsOK(res1)) {
31600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31601 }
31602 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31603 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31604 if (!SWIG_IsOK(res2)) {
31605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31606 }
31607 if (!argp2) {
31608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31609 }
31610 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31611 {
31612 PyThreadState* __tstate = wxPyBeginAllowThreads();
31613 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31614 wxPyEndAllowThreads(__tstate);
31615 if (PyErr_Occurred()) SWIG_fail;
31616 }
31617 {
31618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31619 }
31620 return resultobj;
31621 fail:
31622 return NULL;
31623 }
31624
31625
31626 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31627 int argc;
31628 PyObject *argv[3];
31629
31630 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31631 --argc;
31632 if (argc == 2) {
31633 int _v = 0;
31634 {
31635 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31636 _v = SWIG_CheckState(res);
31637 }
31638 if (!_v) goto check_1;
31639 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31640 }
31641 check_1:
31642
31643 if (argc == 2) {
31644 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31645 }
31646
31647 fail:
31648 Py_INCREF(Py_NotImplemented);
31649 return Py_NotImplemented;
31650 }
31651
31652
31653 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31654 PyObject *resultobj = 0;
31655 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31656 wxDataFormatId arg2 ;
31657 void *argp1 = 0 ;
31658 int res1 = 0 ;
31659 int val2 ;
31660 int ecode2 = 0 ;
31661 PyObject * obj0 = 0 ;
31662 PyObject * obj1 = 0 ;
31663 char * kwnames[] = {
31664 (char *) "self",(char *) "format", NULL
31665 };
31666
31667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31669 if (!SWIG_IsOK(res1)) {
31670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31671 }
31672 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31673 ecode2 = SWIG_AsVal_int(obj1, &val2);
31674 if (!SWIG_IsOK(ecode2)) {
31675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31676 }
31677 arg2 = static_cast< wxDataFormatId >(val2);
31678 {
31679 PyThreadState* __tstate = wxPyBeginAllowThreads();
31680 (arg1)->SetType(arg2);
31681 wxPyEndAllowThreads(__tstate);
31682 if (PyErr_Occurred()) SWIG_fail;
31683 }
31684 resultobj = SWIG_Py_Void();
31685 return resultobj;
31686 fail:
31687 return NULL;
31688 }
31689
31690
31691 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31692 PyObject *resultobj = 0;
31693 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31694 wxDataFormatId result;
31695 void *argp1 = 0 ;
31696 int res1 = 0 ;
31697 PyObject *swig_obj[1] ;
31698
31699 if (!args) SWIG_fail;
31700 swig_obj[0] = args;
31701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31702 if (!SWIG_IsOK(res1)) {
31703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31704 }
31705 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 resultobj = SWIG_From_int(static_cast< int >(result));
31713 return resultobj;
31714 fail:
31715 return NULL;
31716 }
31717
31718
31719 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31720 PyObject *resultobj = 0;
31721 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31722 wxString result;
31723 void *argp1 = 0 ;
31724 int res1 = 0 ;
31725 PyObject *swig_obj[1] ;
31726
31727 if (!args) SWIG_fail;
31728 swig_obj[0] = args;
31729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31730 if (!SWIG_IsOK(res1)) {
31731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31732 }
31733 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31734 {
31735 PyThreadState* __tstate = wxPyBeginAllowThreads();
31736 result = ((wxDataFormat const *)arg1)->GetId();
31737 wxPyEndAllowThreads(__tstate);
31738 if (PyErr_Occurred()) SWIG_fail;
31739 }
31740 {
31741 #if wxUSE_UNICODE
31742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31743 #else
31744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31745 #endif
31746 }
31747 return resultobj;
31748 fail:
31749 return NULL;
31750 }
31751
31752
31753 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31754 PyObject *resultobj = 0;
31755 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31756 wxString *arg2 = 0 ;
31757 void *argp1 = 0 ;
31758 int res1 = 0 ;
31759 bool temp2 = false ;
31760 PyObject * obj0 = 0 ;
31761 PyObject * obj1 = 0 ;
31762 char * kwnames[] = {
31763 (char *) "self",(char *) "format", NULL
31764 };
31765
31766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31768 if (!SWIG_IsOK(res1)) {
31769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31770 }
31771 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31772 {
31773 arg2 = wxString_in_helper(obj1);
31774 if (arg2 == NULL) SWIG_fail;
31775 temp2 = true;
31776 }
31777 {
31778 PyThreadState* __tstate = wxPyBeginAllowThreads();
31779 (arg1)->SetId((wxString const &)*arg2);
31780 wxPyEndAllowThreads(__tstate);
31781 if (PyErr_Occurred()) SWIG_fail;
31782 }
31783 resultobj = SWIG_Py_Void();
31784 {
31785 if (temp2)
31786 delete arg2;
31787 }
31788 return resultobj;
31789 fail:
31790 {
31791 if (temp2)
31792 delete arg2;
31793 }
31794 return NULL;
31795 }
31796
31797
31798 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31799 PyObject *obj;
31800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31801 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31802 return SWIG_Py_Void();
31803 }
31804
31805 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31806 return SWIG_Python_InitShadowInstance(args);
31807 }
31808
31809 SWIGINTERN int FormatInvalid_set(PyObject *) {
31810 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31811 return 1;
31812 }
31813
31814
31815 SWIGINTERN PyObject *FormatInvalid_get(void) {
31816 PyObject *pyobj = 0;
31817
31818 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31819 return pyobj;
31820 }
31821
31822
31823 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31824 PyObject *resultobj = 0;
31825 wxDataObject *arg1 = (wxDataObject *) 0 ;
31826 void *argp1 = 0 ;
31827 int res1 = 0 ;
31828 PyObject *swig_obj[1] ;
31829
31830 if (!args) SWIG_fail;
31831 swig_obj[0] = args;
31832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31833 if (!SWIG_IsOK(res1)) {
31834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31835 }
31836 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31837 {
31838 PyThreadState* __tstate = wxPyBeginAllowThreads();
31839 delete arg1;
31840
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 resultobj = SWIG_Py_Void();
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31852 PyObject *resultobj = 0;
31853 wxDataObject *arg1 = (wxDataObject *) 0 ;
31854 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31855 SwigValueWrapper<wxDataFormat > result;
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 *) "dir", NULL
31864 };
31865
31866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31868 if (!SWIG_IsOK(res1)) {
31869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31870 }
31871 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31872 if (obj1) {
31873 ecode2 = SWIG_AsVal_int(obj1, &val2);
31874 if (!SWIG_IsOK(ecode2)) {
31875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31876 }
31877 arg2 = static_cast< wxDataObject::Direction >(val2);
31878 }
31879 {
31880 PyThreadState* __tstate = wxPyBeginAllowThreads();
31881 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31882 wxPyEndAllowThreads(__tstate);
31883 if (PyErr_Occurred()) SWIG_fail;
31884 }
31885 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31886 return resultobj;
31887 fail:
31888 return NULL;
31889 }
31890
31891
31892 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31893 PyObject *resultobj = 0;
31894 wxDataObject *arg1 = (wxDataObject *) 0 ;
31895 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31896 size_t result;
31897 void *argp1 = 0 ;
31898 int res1 = 0 ;
31899 int val2 ;
31900 int ecode2 = 0 ;
31901 PyObject * obj0 = 0 ;
31902 PyObject * obj1 = 0 ;
31903 char * kwnames[] = {
31904 (char *) "self",(char *) "dir", NULL
31905 };
31906
31907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
31908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31909 if (!SWIG_IsOK(res1)) {
31910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31911 }
31912 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31913 if (obj1) {
31914 ecode2 = SWIG_AsVal_int(obj1, &val2);
31915 if (!SWIG_IsOK(ecode2)) {
31916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31917 }
31918 arg2 = static_cast< wxDataObject::Direction >(val2);
31919 }
31920 {
31921 PyThreadState* __tstate = wxPyBeginAllowThreads();
31922 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
31923 wxPyEndAllowThreads(__tstate);
31924 if (PyErr_Occurred()) SWIG_fail;
31925 }
31926 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31927 return resultobj;
31928 fail:
31929 return NULL;
31930 }
31931
31932
31933 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31934 PyObject *resultobj = 0;
31935 wxDataObject *arg1 = (wxDataObject *) 0 ;
31936 wxDataFormat *arg2 = 0 ;
31937 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
31938 bool result;
31939 void *argp1 = 0 ;
31940 int res1 = 0 ;
31941 void *argp2 = 0 ;
31942 int res2 = 0 ;
31943 int val3 ;
31944 int ecode3 = 0 ;
31945 PyObject * obj0 = 0 ;
31946 PyObject * obj1 = 0 ;
31947 PyObject * obj2 = 0 ;
31948 char * kwnames[] = {
31949 (char *) "self",(char *) "format",(char *) "dir", NULL
31950 };
31951
31952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31954 if (!SWIG_IsOK(res1)) {
31955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31956 }
31957 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31958 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31959 if (!SWIG_IsOK(res2)) {
31960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31961 }
31962 if (!argp2) {
31963 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31964 }
31965 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31966 if (obj2) {
31967 ecode3 = SWIG_AsVal_int(obj2, &val3);
31968 if (!SWIG_IsOK(ecode3)) {
31969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31970 }
31971 arg3 = static_cast< wxDataObject::Direction >(val3);
31972 }
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31976 wxPyEndAllowThreads(__tstate);
31977 if (PyErr_Occurred()) SWIG_fail;
31978 }
31979 {
31980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31981 }
31982 return resultobj;
31983 fail:
31984 return NULL;
31985 }
31986
31987
31988 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31989 PyObject *resultobj = 0;
31990 wxDataObject *arg1 = (wxDataObject *) 0 ;
31991 wxDataFormat *arg2 = 0 ;
31992 size_t result;
31993 void *argp1 = 0 ;
31994 int res1 = 0 ;
31995 void *argp2 = 0 ;
31996 int res2 = 0 ;
31997 PyObject * obj0 = 0 ;
31998 PyObject * obj1 = 0 ;
31999 char * kwnames[] = {
32000 (char *) "self",(char *) "format", NULL
32001 };
32002
32003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32005 if (!SWIG_IsOK(res1)) {
32006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32007 }
32008 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32009 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32010 if (!SWIG_IsOK(res2)) {
32011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32012 }
32013 if (!argp2) {
32014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32015 }
32016 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32031 PyObject *resultobj = 0;
32032 wxDataObject *arg1 = (wxDataObject *) 0 ;
32033 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32034 PyObject *result = 0 ;
32035 void *argp1 = 0 ;
32036 int res1 = 0 ;
32037 int val2 ;
32038 int ecode2 = 0 ;
32039 PyObject * obj0 = 0 ;
32040 PyObject * obj1 = 0 ;
32041 char * kwnames[] = {
32042 (char *) "self",(char *) "dir", NULL
32043 };
32044
32045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32047 if (!SWIG_IsOK(res1)) {
32048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32049 }
32050 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32051 if (obj1) {
32052 ecode2 = SWIG_AsVal_int(obj1, &val2);
32053 if (!SWIG_IsOK(ecode2)) {
32054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32055 }
32056 arg2 = static_cast< wxDataObject::Direction >(val2);
32057 }
32058 {
32059 PyThreadState* __tstate = wxPyBeginAllowThreads();
32060 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32061 wxPyEndAllowThreads(__tstate);
32062 if (PyErr_Occurred()) SWIG_fail;
32063 }
32064 resultobj = result;
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32072 PyObject *resultobj = 0;
32073 wxDataObject *arg1 = (wxDataObject *) 0 ;
32074 wxDataFormat *arg2 = 0 ;
32075 PyObject *result = 0 ;
32076 void *argp1 = 0 ;
32077 int res1 = 0 ;
32078 void *argp2 = 0 ;
32079 int res2 = 0 ;
32080 PyObject * obj0 = 0 ;
32081 PyObject * obj1 = 0 ;
32082 char * kwnames[] = {
32083 (char *) "self",(char *) "format", NULL
32084 };
32085
32086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32088 if (!SWIG_IsOK(res1)) {
32089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32090 }
32091 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32092 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32093 if (!SWIG_IsOK(res2)) {
32094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32095 }
32096 if (!argp2) {
32097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32098 }
32099 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32100 {
32101 PyThreadState* __tstate = wxPyBeginAllowThreads();
32102 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32103 wxPyEndAllowThreads(__tstate);
32104 if (PyErr_Occurred()) SWIG_fail;
32105 }
32106 resultobj = result;
32107 return resultobj;
32108 fail:
32109 return NULL;
32110 }
32111
32112
32113 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32114 PyObject *resultobj = 0;
32115 wxDataObject *arg1 = (wxDataObject *) 0 ;
32116 wxDataFormat *arg2 = 0 ;
32117 PyObject *arg3 = (PyObject *) 0 ;
32118 bool result;
32119 void *argp1 = 0 ;
32120 int res1 = 0 ;
32121 void *argp2 = 0 ;
32122 int res2 = 0 ;
32123 PyObject * obj0 = 0 ;
32124 PyObject * obj1 = 0 ;
32125 PyObject * obj2 = 0 ;
32126 char * kwnames[] = {
32127 (char *) "self",(char *) "format",(char *) "data", NULL
32128 };
32129
32130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32132 if (!SWIG_IsOK(res1)) {
32133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32134 }
32135 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32136 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32137 if (!SWIG_IsOK(res2)) {
32138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32139 }
32140 if (!argp2) {
32141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32142 }
32143 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32144 arg3 = obj2;
32145 {
32146 PyThreadState* __tstate = wxPyBeginAllowThreads();
32147 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32148 wxPyEndAllowThreads(__tstate);
32149 if (PyErr_Occurred()) SWIG_fail;
32150 }
32151 {
32152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32153 }
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *obj;
32162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32163 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32164 return SWIG_Py_Void();
32165 }
32166
32167 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32168 PyObject *resultobj = 0;
32169 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32170 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32171 wxDataObjectSimple *result = 0 ;
32172 void *argp1 = 0 ;
32173 int res1 = 0 ;
32174 PyObject * obj0 = 0 ;
32175 char * kwnames[] = {
32176 (char *) "format", NULL
32177 };
32178
32179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32180 if (obj0) {
32181 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32182 if (!SWIG_IsOK(res1)) {
32183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32184 }
32185 if (!argp1) {
32186 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32187 }
32188 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32189 }
32190 {
32191 PyThreadState* __tstate = wxPyBeginAllowThreads();
32192 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32193 wxPyEndAllowThreads(__tstate);
32194 if (PyErr_Occurred()) SWIG_fail;
32195 }
32196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32197 return resultobj;
32198 fail:
32199 return NULL;
32200 }
32201
32202
32203 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32204 PyObject *resultobj = 0;
32205 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32206 wxDataFormat *result = 0 ;
32207 void *argp1 = 0 ;
32208 int res1 = 0 ;
32209 PyObject *swig_obj[1] ;
32210
32211 if (!args) SWIG_fail;
32212 swig_obj[0] = args;
32213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32214 if (!SWIG_IsOK(res1)) {
32215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32216 }
32217 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32218 {
32219 PyThreadState* __tstate = wxPyBeginAllowThreads();
32220 {
32221 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32222 result = (wxDataFormat *) &_result_ref;
32223 }
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32237 wxDataFormat *arg2 = 0 ;
32238 void *argp1 = 0 ;
32239 int res1 = 0 ;
32240 void *argp2 = 0 ;
32241 int res2 = 0 ;
32242 PyObject * obj0 = 0 ;
32243 PyObject * obj1 = 0 ;
32244 char * kwnames[] = {
32245 (char *) "self",(char *) "format", NULL
32246 };
32247
32248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32250 if (!SWIG_IsOK(res1)) {
32251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32252 }
32253 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32254 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32255 if (!SWIG_IsOK(res2)) {
32256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32257 }
32258 if (!argp2) {
32259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32260 }
32261 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32262 {
32263 PyThreadState* __tstate = wxPyBeginAllowThreads();
32264 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32265 wxPyEndAllowThreads(__tstate);
32266 if (PyErr_Occurred()) SWIG_fail;
32267 }
32268 resultobj = SWIG_Py_Void();
32269 return resultobj;
32270 fail:
32271 return NULL;
32272 }
32273
32274
32275 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32276 PyObject *resultobj = 0;
32277 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32278 size_t result;
32279 void *argp1 = 0 ;
32280 int res1 = 0 ;
32281 PyObject *swig_obj[1] ;
32282
32283 if (!args) SWIG_fail;
32284 swig_obj[0] = args;
32285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32286 if (!SWIG_IsOK(res1)) {
32287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32288 }
32289 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32304 PyObject *resultobj = 0;
32305 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32306 PyObject *result = 0 ;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 PyObject *swig_obj[1] ;
32310
32311 if (!args) SWIG_fail;
32312 swig_obj[0] = args;
32313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32314 if (!SWIG_IsOK(res1)) {
32315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32316 }
32317 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 resultobj = result;
32325 return resultobj;
32326 fail:
32327 return NULL;
32328 }
32329
32330
32331 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32332 PyObject *resultobj = 0;
32333 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32334 PyObject *arg2 = (PyObject *) 0 ;
32335 bool result;
32336 void *argp1 = 0 ;
32337 int res1 = 0 ;
32338 PyObject * obj0 = 0 ;
32339 PyObject * obj1 = 0 ;
32340 char * kwnames[] = {
32341 (char *) "self",(char *) "data", NULL
32342 };
32343
32344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32346 if (!SWIG_IsOK(res1)) {
32347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32348 }
32349 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32350 arg2 = obj1;
32351 {
32352 PyThreadState* __tstate = wxPyBeginAllowThreads();
32353 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32354 wxPyEndAllowThreads(__tstate);
32355 if (PyErr_Occurred()) SWIG_fail;
32356 }
32357 {
32358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32359 }
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32367 PyObject *obj;
32368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32369 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32370 return SWIG_Py_Void();
32371 }
32372
32373 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32374 return SWIG_Python_InitShadowInstance(args);
32375 }
32376
32377 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32378 PyObject *resultobj = 0;
32379 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32380 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32381 wxPyDataObjectSimple *result = 0 ;
32382 void *argp1 = 0 ;
32383 int res1 = 0 ;
32384 PyObject * obj0 = 0 ;
32385 char * kwnames[] = {
32386 (char *) "format", NULL
32387 };
32388
32389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32390 if (obj0) {
32391 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32392 if (!SWIG_IsOK(res1)) {
32393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32394 }
32395 if (!argp1) {
32396 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32397 }
32398 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32399 }
32400 {
32401 PyThreadState* __tstate = wxPyBeginAllowThreads();
32402 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj = 0;
32415 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32416 PyObject *arg2 = (PyObject *) 0 ;
32417 PyObject *arg3 = (PyObject *) 0 ;
32418 void *argp1 = 0 ;
32419 int res1 = 0 ;
32420 PyObject * obj0 = 0 ;
32421 PyObject * obj1 = 0 ;
32422 PyObject * obj2 = 0 ;
32423 char * kwnames[] = {
32424 (char *) "self",(char *) "self",(char *) "_class", NULL
32425 };
32426
32427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32429 if (!SWIG_IsOK(res1)) {
32430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32431 }
32432 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32433 arg2 = obj1;
32434 arg3 = obj2;
32435 {
32436 PyThreadState* __tstate = wxPyBeginAllowThreads();
32437 (arg1)->_setCallbackInfo(arg2,arg3);
32438 wxPyEndAllowThreads(__tstate);
32439 if (PyErr_Occurred()) SWIG_fail;
32440 }
32441 resultobj = SWIG_Py_Void();
32442 return resultobj;
32443 fail:
32444 return NULL;
32445 }
32446
32447
32448 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32449 PyObject *obj;
32450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32451 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32452 return SWIG_Py_Void();
32453 }
32454
32455 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 return SWIG_Python_InitShadowInstance(args);
32457 }
32458
32459 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32460 PyObject *resultobj = 0;
32461 wxDataObjectComposite *result = 0 ;
32462
32463 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32464 {
32465 PyThreadState* __tstate = wxPyBeginAllowThreads();
32466 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32467 wxPyEndAllowThreads(__tstate);
32468 if (PyErr_Occurred()) SWIG_fail;
32469 }
32470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32471 return resultobj;
32472 fail:
32473 return NULL;
32474 }
32475
32476
32477 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32478 PyObject *resultobj = 0;
32479 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32480 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32481 bool arg3 = (bool) false ;
32482 void *argp1 = 0 ;
32483 int res1 = 0 ;
32484 int res2 = 0 ;
32485 bool val3 ;
32486 int ecode3 = 0 ;
32487 PyObject * obj0 = 0 ;
32488 PyObject * obj1 = 0 ;
32489 PyObject * obj2 = 0 ;
32490 char * kwnames[] = {
32491 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32492 };
32493
32494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32496 if (!SWIG_IsOK(res1)) {
32497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32498 }
32499 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32500 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32501 if (!SWIG_IsOK(res2)) {
32502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32503 }
32504 if (obj2) {
32505 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32506 if (!SWIG_IsOK(ecode3)) {
32507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32508 }
32509 arg3 = static_cast< bool >(val3);
32510 }
32511 {
32512 PyThreadState* __tstate = wxPyBeginAllowThreads();
32513 (arg1)->Add(arg2,arg3);
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 resultobj = SWIG_Py_Void();
32518 return resultobj;
32519 fail:
32520 return NULL;
32521 }
32522
32523
32524 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32525 PyObject *resultobj = 0;
32526 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32527 SwigValueWrapper<wxDataFormat > result;
32528 void *argp1 = 0 ;
32529 int res1 = 0 ;
32530 PyObject *swig_obj[1] ;
32531
32532 if (!args) SWIG_fail;
32533 swig_obj[0] = args;
32534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32535 if (!SWIG_IsOK(res1)) {
32536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32537 }
32538 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32546 return resultobj;
32547 fail:
32548 return NULL;
32549 }
32550
32551
32552 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32553 PyObject *obj;
32554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32555 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32556 return SWIG_Py_Void();
32557 }
32558
32559 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32560 return SWIG_Python_InitShadowInstance(args);
32561 }
32562
32563 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32564 PyObject *resultobj = 0;
32565 wxString const &arg1_defvalue = wxPyEmptyString ;
32566 wxString *arg1 = (wxString *) &arg1_defvalue ;
32567 wxTextDataObject *result = 0 ;
32568 bool temp1 = false ;
32569 PyObject * obj0 = 0 ;
32570 char * kwnames[] = {
32571 (char *) "text", NULL
32572 };
32573
32574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32575 if (obj0) {
32576 {
32577 arg1 = wxString_in_helper(obj0);
32578 if (arg1 == NULL) SWIG_fail;
32579 temp1 = true;
32580 }
32581 }
32582 {
32583 PyThreadState* __tstate = wxPyBeginAllowThreads();
32584 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32585 wxPyEndAllowThreads(__tstate);
32586 if (PyErr_Occurred()) SWIG_fail;
32587 }
32588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32589 {
32590 if (temp1)
32591 delete arg1;
32592 }
32593 return resultobj;
32594 fail:
32595 {
32596 if (temp1)
32597 delete arg1;
32598 }
32599 return NULL;
32600 }
32601
32602
32603 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32604 PyObject *resultobj = 0;
32605 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32606 size_t result;
32607 void *argp1 = 0 ;
32608 int res1 = 0 ;
32609 PyObject *swig_obj[1] ;
32610
32611 if (!args) SWIG_fail;
32612 swig_obj[0] = args;
32613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32614 if (!SWIG_IsOK(res1)) {
32615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32616 }
32617 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32618 {
32619 PyThreadState* __tstate = wxPyBeginAllowThreads();
32620 result = (size_t)(arg1)->GetTextLength();
32621 wxPyEndAllowThreads(__tstate);
32622 if (PyErr_Occurred()) SWIG_fail;
32623 }
32624 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32625 return resultobj;
32626 fail:
32627 return NULL;
32628 }
32629
32630
32631 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32632 PyObject *resultobj = 0;
32633 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32634 wxString result;
32635 void *argp1 = 0 ;
32636 int res1 = 0 ;
32637 PyObject *swig_obj[1] ;
32638
32639 if (!args) SWIG_fail;
32640 swig_obj[0] = args;
32641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32642 if (!SWIG_IsOK(res1)) {
32643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32644 }
32645 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 result = (arg1)->GetText();
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 {
32653 #if wxUSE_UNICODE
32654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32655 #else
32656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32657 #endif
32658 }
32659 return resultobj;
32660 fail:
32661 return NULL;
32662 }
32663
32664
32665 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32666 PyObject *resultobj = 0;
32667 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32668 wxString *arg2 = 0 ;
32669 void *argp1 = 0 ;
32670 int res1 = 0 ;
32671 bool temp2 = false ;
32672 PyObject * obj0 = 0 ;
32673 PyObject * obj1 = 0 ;
32674 char * kwnames[] = {
32675 (char *) "self",(char *) "text", NULL
32676 };
32677
32678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32680 if (!SWIG_IsOK(res1)) {
32681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32682 }
32683 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32684 {
32685 arg2 = wxString_in_helper(obj1);
32686 if (arg2 == NULL) SWIG_fail;
32687 temp2 = true;
32688 }
32689 {
32690 PyThreadState* __tstate = wxPyBeginAllowThreads();
32691 (arg1)->SetText((wxString const &)*arg2);
32692 wxPyEndAllowThreads(__tstate);
32693 if (PyErr_Occurred()) SWIG_fail;
32694 }
32695 resultobj = SWIG_Py_Void();
32696 {
32697 if (temp2)
32698 delete arg2;
32699 }
32700 return resultobj;
32701 fail:
32702 {
32703 if (temp2)
32704 delete arg2;
32705 }
32706 return NULL;
32707 }
32708
32709
32710 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32711 PyObject *obj;
32712 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32713 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32714 return SWIG_Py_Void();
32715 }
32716
32717 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32718 return SWIG_Python_InitShadowInstance(args);
32719 }
32720
32721 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32722 PyObject *resultobj = 0;
32723 wxString const &arg1_defvalue = wxPyEmptyString ;
32724 wxString *arg1 = (wxString *) &arg1_defvalue ;
32725 wxPyTextDataObject *result = 0 ;
32726 bool temp1 = false ;
32727 PyObject * obj0 = 0 ;
32728 char * kwnames[] = {
32729 (char *) "text", NULL
32730 };
32731
32732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32733 if (obj0) {
32734 {
32735 arg1 = wxString_in_helper(obj0);
32736 if (arg1 == NULL) SWIG_fail;
32737 temp1 = true;
32738 }
32739 }
32740 {
32741 PyThreadState* __tstate = wxPyBeginAllowThreads();
32742 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32743 wxPyEndAllowThreads(__tstate);
32744 if (PyErr_Occurred()) SWIG_fail;
32745 }
32746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32747 {
32748 if (temp1)
32749 delete arg1;
32750 }
32751 return resultobj;
32752 fail:
32753 {
32754 if (temp1)
32755 delete arg1;
32756 }
32757 return NULL;
32758 }
32759
32760
32761 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32762 PyObject *resultobj = 0;
32763 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32764 PyObject *arg2 = (PyObject *) 0 ;
32765 PyObject *arg3 = (PyObject *) 0 ;
32766 void *argp1 = 0 ;
32767 int res1 = 0 ;
32768 PyObject * obj0 = 0 ;
32769 PyObject * obj1 = 0 ;
32770 PyObject * obj2 = 0 ;
32771 char * kwnames[] = {
32772 (char *) "self",(char *) "self",(char *) "_class", NULL
32773 };
32774
32775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32777 if (!SWIG_IsOK(res1)) {
32778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32779 }
32780 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32781 arg2 = obj1;
32782 arg3 = obj2;
32783 {
32784 PyThreadState* __tstate = wxPyBeginAllowThreads();
32785 (arg1)->_setCallbackInfo(arg2,arg3);
32786 wxPyEndAllowThreads(__tstate);
32787 if (PyErr_Occurred()) SWIG_fail;
32788 }
32789 resultobj = SWIG_Py_Void();
32790 return resultobj;
32791 fail:
32792 return NULL;
32793 }
32794
32795
32796 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32797 PyObject *obj;
32798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32799 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32800 return SWIG_Py_Void();
32801 }
32802
32803 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32804 return SWIG_Python_InitShadowInstance(args);
32805 }
32806
32807 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32808 PyObject *resultobj = 0;
32809 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32810 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32811 wxBitmapDataObject *result = 0 ;
32812 void *argp1 = 0 ;
32813 int res1 = 0 ;
32814 PyObject * obj0 = 0 ;
32815 char * kwnames[] = {
32816 (char *) "bitmap", NULL
32817 };
32818
32819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32820 if (obj0) {
32821 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32822 if (!SWIG_IsOK(res1)) {
32823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32824 }
32825 if (!argp1) {
32826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32827 }
32828 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32829 }
32830 {
32831 PyThreadState* __tstate = wxPyBeginAllowThreads();
32832 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32833 wxPyEndAllowThreads(__tstate);
32834 if (PyErr_Occurred()) SWIG_fail;
32835 }
32836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32837 return resultobj;
32838 fail:
32839 return NULL;
32840 }
32841
32842
32843 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32844 PyObject *resultobj = 0;
32845 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32846 wxBitmap result;
32847 void *argp1 = 0 ;
32848 int res1 = 0 ;
32849 PyObject *swig_obj[1] ;
32850
32851 if (!args) SWIG_fail;
32852 swig_obj[0] = args;
32853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32854 if (!SWIG_IsOK(res1)) {
32855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32856 }
32857 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32858 {
32859 PyThreadState* __tstate = wxPyBeginAllowThreads();
32860 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32861 wxPyEndAllowThreads(__tstate);
32862 if (PyErr_Occurred()) SWIG_fail;
32863 }
32864 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32865 return resultobj;
32866 fail:
32867 return NULL;
32868 }
32869
32870
32871 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32872 PyObject *resultobj = 0;
32873 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32874 wxBitmap *arg2 = 0 ;
32875 void *argp1 = 0 ;
32876 int res1 = 0 ;
32877 void *argp2 = 0 ;
32878 int res2 = 0 ;
32879 PyObject * obj0 = 0 ;
32880 PyObject * obj1 = 0 ;
32881 char * kwnames[] = {
32882 (char *) "self",(char *) "bitmap", NULL
32883 };
32884
32885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32889 }
32890 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32891 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32892 if (!SWIG_IsOK(res2)) {
32893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32894 }
32895 if (!argp2) {
32896 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32897 }
32898 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32899 {
32900 PyThreadState* __tstate = wxPyBeginAllowThreads();
32901 (arg1)->SetBitmap((wxBitmap const &)*arg2);
32902 wxPyEndAllowThreads(__tstate);
32903 if (PyErr_Occurred()) SWIG_fail;
32904 }
32905 resultobj = SWIG_Py_Void();
32906 return resultobj;
32907 fail:
32908 return NULL;
32909 }
32910
32911
32912 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32913 PyObject *obj;
32914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32915 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
32916 return SWIG_Py_Void();
32917 }
32918
32919 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32920 return SWIG_Python_InitShadowInstance(args);
32921 }
32922
32923 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32924 PyObject *resultobj = 0;
32925 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32926 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32927 wxPyBitmapDataObject *result = 0 ;
32928 void *argp1 = 0 ;
32929 int res1 = 0 ;
32930 PyObject * obj0 = 0 ;
32931 char * kwnames[] = {
32932 (char *) "bitmap", NULL
32933 };
32934
32935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
32936 if (obj0) {
32937 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32938 if (!SWIG_IsOK(res1)) {
32939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32940 }
32941 if (!argp1) {
32942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32943 }
32944 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32945 }
32946 {
32947 PyThreadState* __tstate = wxPyBeginAllowThreads();
32948 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
32949 wxPyEndAllowThreads(__tstate);
32950 if (PyErr_Occurred()) SWIG_fail;
32951 }
32952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
32953 return resultobj;
32954 fail:
32955 return NULL;
32956 }
32957
32958
32959 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32960 PyObject *resultobj = 0;
32961 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
32962 PyObject *arg2 = (PyObject *) 0 ;
32963 PyObject *arg3 = (PyObject *) 0 ;
32964 void *argp1 = 0 ;
32965 int res1 = 0 ;
32966 PyObject * obj0 = 0 ;
32967 PyObject * obj1 = 0 ;
32968 PyObject * obj2 = 0 ;
32969 char * kwnames[] = {
32970 (char *) "self",(char *) "self",(char *) "_class", NULL
32971 };
32972
32973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32975 if (!SWIG_IsOK(res1)) {
32976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32977 }
32978 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32979 arg2 = obj1;
32980 arg3 = obj2;
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 (arg1)->_setCallbackInfo(arg2,arg3);
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 resultobj = SWIG_Py_Void();
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32995 PyObject *obj;
32996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32997 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32998 return SWIG_Py_Void();
32999 }
33000
33001 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33002 return SWIG_Python_InitShadowInstance(args);
33003 }
33004
33005 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33006 PyObject *resultobj = 0;
33007 wxFileDataObject *result = 0 ;
33008
33009 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 result = (wxFileDataObject *)new wxFileDataObject();
33013 wxPyEndAllowThreads(__tstate);
33014 if (PyErr_Occurred()) SWIG_fail;
33015 }
33016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33017 return resultobj;
33018 fail:
33019 return NULL;
33020 }
33021
33022
33023 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33024 PyObject *resultobj = 0;
33025 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33026 wxArrayString *result = 0 ;
33027 void *argp1 = 0 ;
33028 int res1 = 0 ;
33029 PyObject *swig_obj[1] ;
33030
33031 if (!args) SWIG_fail;
33032 swig_obj[0] = args;
33033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33034 if (!SWIG_IsOK(res1)) {
33035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33036 }
33037 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33038 {
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 {
33041 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33042 result = (wxArrayString *) &_result_ref;
33043 }
33044 wxPyEndAllowThreads(__tstate);
33045 if (PyErr_Occurred()) SWIG_fail;
33046 }
33047 {
33048 resultobj = wxArrayString2PyList_helper(*result);
33049 }
33050 return resultobj;
33051 fail:
33052 return NULL;
33053 }
33054
33055
33056 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33057 PyObject *resultobj = 0;
33058 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33059 wxString *arg2 = 0 ;
33060 void *argp1 = 0 ;
33061 int res1 = 0 ;
33062 bool temp2 = false ;
33063 PyObject * obj0 = 0 ;
33064 PyObject * obj1 = 0 ;
33065 char * kwnames[] = {
33066 (char *) "self",(char *) "filename", NULL
33067 };
33068
33069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33071 if (!SWIG_IsOK(res1)) {
33072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33073 }
33074 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33075 {
33076 arg2 = wxString_in_helper(obj1);
33077 if (arg2 == NULL) SWIG_fail;
33078 temp2 = true;
33079 }
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 (arg1)->AddFile((wxString const &)*arg2);
33083 wxPyEndAllowThreads(__tstate);
33084 if (PyErr_Occurred()) SWIG_fail;
33085 }
33086 resultobj = SWIG_Py_Void();
33087 {
33088 if (temp2)
33089 delete arg2;
33090 }
33091 return resultobj;
33092 fail:
33093 {
33094 if (temp2)
33095 delete arg2;
33096 }
33097 return NULL;
33098 }
33099
33100
33101 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33102 PyObject *obj;
33103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33104 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33105 return SWIG_Py_Void();
33106 }
33107
33108 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33109 return SWIG_Python_InitShadowInstance(args);
33110 }
33111
33112 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33113 PyObject *resultobj = 0;
33114 wxDataFormat *arg1 = 0 ;
33115 wxCustomDataObject *result = 0 ;
33116 void *argp1 = 0 ;
33117 int res1 = 0 ;
33118
33119 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33123 }
33124 if (!argp1) {
33125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33126 }
33127 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33128 {
33129 PyThreadState* __tstate = wxPyBeginAllowThreads();
33130 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33131 wxPyEndAllowThreads(__tstate);
33132 if (PyErr_Occurred()) SWIG_fail;
33133 }
33134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33135 return resultobj;
33136 fail:
33137 return NULL;
33138 }
33139
33140
33141 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33142 PyObject *resultobj = 0;
33143 wxString *arg1 = 0 ;
33144 wxCustomDataObject *result = 0 ;
33145 bool temp1 = false ;
33146
33147 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33148 {
33149 arg1 = wxString_in_helper(swig_obj[0]);
33150 if (arg1 == NULL) SWIG_fail;
33151 temp1 = true;
33152 }
33153 {
33154 PyThreadState* __tstate = wxPyBeginAllowThreads();
33155 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33156 wxPyEndAllowThreads(__tstate);
33157 if (PyErr_Occurred()) SWIG_fail;
33158 }
33159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33160 {
33161 if (temp1)
33162 delete arg1;
33163 }
33164 return resultobj;
33165 fail:
33166 {
33167 if (temp1)
33168 delete arg1;
33169 }
33170 return NULL;
33171 }
33172
33173
33174 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33175 PyObject *resultobj = 0;
33176 wxCustomDataObject *result = 0 ;
33177
33178 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33179 {
33180 PyThreadState* __tstate = wxPyBeginAllowThreads();
33181 result = (wxCustomDataObject *)new wxCustomDataObject();
33182 wxPyEndAllowThreads(__tstate);
33183 if (PyErr_Occurred()) SWIG_fail;
33184 }
33185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33186 return resultobj;
33187 fail:
33188 return NULL;
33189 }
33190
33191
33192 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33193 int argc;
33194 PyObject *argv[2];
33195
33196 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33197 --argc;
33198 if (argc == 0) {
33199 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33200 }
33201 if (argc == 1) {
33202 int _v = 0;
33203 {
33204 {
33205 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33206 }
33207 }
33208 if (!_v) goto check_2;
33209 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33210 }
33211 check_2:
33212
33213 if (argc == 1) {
33214 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33215 }
33216
33217 fail:
33218 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33219 return NULL;
33220 }
33221
33222
33223 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33224 PyObject *resultobj = 0;
33225 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33226 PyObject *arg2 = (PyObject *) 0 ;
33227 bool result;
33228 void *argp1 = 0 ;
33229 int res1 = 0 ;
33230 PyObject * obj0 = 0 ;
33231 PyObject * obj1 = 0 ;
33232 char * kwnames[] = {
33233 (char *) "self",(char *) "data", NULL
33234 };
33235
33236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33238 if (!SWIG_IsOK(res1)) {
33239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33240 }
33241 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33242 arg2 = obj1;
33243 {
33244 PyThreadState* __tstate = wxPyBeginAllowThreads();
33245 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 {
33250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33251 }
33252 return resultobj;
33253 fail:
33254 return NULL;
33255 }
33256
33257
33258 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33259 PyObject *resultobj = 0;
33260 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33261 size_t result;
33262 void *argp1 = 0 ;
33263 int res1 = 0 ;
33264 PyObject *swig_obj[1] ;
33265
33266 if (!args) SWIG_fail;
33267 swig_obj[0] = args;
33268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33269 if (!SWIG_IsOK(res1)) {
33270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33271 }
33272 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33273 {
33274 PyThreadState* __tstate = wxPyBeginAllowThreads();
33275 result = (size_t)(arg1)->GetSize();
33276 wxPyEndAllowThreads(__tstate);
33277 if (PyErr_Occurred()) SWIG_fail;
33278 }
33279 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33280 return resultobj;
33281 fail:
33282 return NULL;
33283 }
33284
33285
33286 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33287 PyObject *resultobj = 0;
33288 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33289 PyObject *result = 0 ;
33290 void *argp1 = 0 ;
33291 int res1 = 0 ;
33292 PyObject *swig_obj[1] ;
33293
33294 if (!args) SWIG_fail;
33295 swig_obj[0] = args;
33296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33297 if (!SWIG_IsOK(res1)) {
33298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33299 }
33300 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33301 {
33302 PyThreadState* __tstate = wxPyBeginAllowThreads();
33303 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33304 wxPyEndAllowThreads(__tstate);
33305 if (PyErr_Occurred()) SWIG_fail;
33306 }
33307 resultobj = result;
33308 return resultobj;
33309 fail:
33310 return NULL;
33311 }
33312
33313
33314 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33315 PyObject *obj;
33316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33317 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33318 return SWIG_Py_Void();
33319 }
33320
33321 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33322 return SWIG_Python_InitShadowInstance(args);
33323 }
33324
33325 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33326 PyObject *resultobj = 0;
33327 wxString const &arg1_defvalue = wxPyEmptyString ;
33328 wxString *arg1 = (wxString *) &arg1_defvalue ;
33329 wxURLDataObject *result = 0 ;
33330 bool temp1 = false ;
33331 PyObject * obj0 = 0 ;
33332 char * kwnames[] = {
33333 (char *) "url", NULL
33334 };
33335
33336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33337 if (obj0) {
33338 {
33339 arg1 = wxString_in_helper(obj0);
33340 if (arg1 == NULL) SWIG_fail;
33341 temp1 = true;
33342 }
33343 }
33344 {
33345 PyThreadState* __tstate = wxPyBeginAllowThreads();
33346 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33347 wxPyEndAllowThreads(__tstate);
33348 if (PyErr_Occurred()) SWIG_fail;
33349 }
33350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33351 {
33352 if (temp1)
33353 delete arg1;
33354 }
33355 return resultobj;
33356 fail:
33357 {
33358 if (temp1)
33359 delete arg1;
33360 }
33361 return NULL;
33362 }
33363
33364
33365 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33366 PyObject *resultobj = 0;
33367 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33368 wxString result;
33369 void *argp1 = 0 ;
33370 int res1 = 0 ;
33371 PyObject *swig_obj[1] ;
33372
33373 if (!args) SWIG_fail;
33374 swig_obj[0] = args;
33375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33376 if (!SWIG_IsOK(res1)) {
33377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33378 }
33379 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33380 {
33381 PyThreadState* __tstate = wxPyBeginAllowThreads();
33382 result = (arg1)->GetURL();
33383 wxPyEndAllowThreads(__tstate);
33384 if (PyErr_Occurred()) SWIG_fail;
33385 }
33386 {
33387 #if wxUSE_UNICODE
33388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33389 #else
33390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33391 #endif
33392 }
33393 return resultobj;
33394 fail:
33395 return NULL;
33396 }
33397
33398
33399 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33400 PyObject *resultobj = 0;
33401 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33402 wxString *arg2 = 0 ;
33403 void *argp1 = 0 ;
33404 int res1 = 0 ;
33405 bool temp2 = false ;
33406 PyObject * obj0 = 0 ;
33407 PyObject * obj1 = 0 ;
33408 char * kwnames[] = {
33409 (char *) "self",(char *) "url", NULL
33410 };
33411
33412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33414 if (!SWIG_IsOK(res1)) {
33415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33416 }
33417 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33418 {
33419 arg2 = wxString_in_helper(obj1);
33420 if (arg2 == NULL) SWIG_fail;
33421 temp2 = true;
33422 }
33423 {
33424 PyThreadState* __tstate = wxPyBeginAllowThreads();
33425 (arg1)->SetURL((wxString const &)*arg2);
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 resultobj = SWIG_Py_Void();
33430 {
33431 if (temp2)
33432 delete arg2;
33433 }
33434 return resultobj;
33435 fail:
33436 {
33437 if (temp2)
33438 delete arg2;
33439 }
33440 return NULL;
33441 }
33442
33443
33444 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33445 PyObject *obj;
33446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33447 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33448 return SWIG_Py_Void();
33449 }
33450
33451 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33452 return SWIG_Python_InitShadowInstance(args);
33453 }
33454
33455 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33456 PyObject *resultobj = 0;
33457 wxMetafileDataObject *result = 0 ;
33458
33459 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33460 {
33461 PyThreadState* __tstate = wxPyBeginAllowThreads();
33462 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33463 wxPyEndAllowThreads(__tstate);
33464 if (PyErr_Occurred()) SWIG_fail;
33465 }
33466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33467 return resultobj;
33468 fail:
33469 return NULL;
33470 }
33471
33472
33473 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33474 PyObject *obj;
33475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33476 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33477 return SWIG_Py_Void();
33478 }
33479
33480 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33481 return SWIG_Python_InitShadowInstance(args);
33482 }
33483
33484 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33485 PyObject *resultobj = 0;
33486 wxDragResult arg1 ;
33487 bool result;
33488 int val1 ;
33489 int ecode1 = 0 ;
33490 PyObject * obj0 = 0 ;
33491 char * kwnames[] = {
33492 (char *) "res", NULL
33493 };
33494
33495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33496 ecode1 = SWIG_AsVal_int(obj0, &val1);
33497 if (!SWIG_IsOK(ecode1)) {
33498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33499 }
33500 arg1 = static_cast< wxDragResult >(val1);
33501 {
33502 PyThreadState* __tstate = wxPyBeginAllowThreads();
33503 result = (bool)wxIsDragResultOk(arg1);
33504 wxPyEndAllowThreads(__tstate);
33505 if (PyErr_Occurred()) SWIG_fail;
33506 }
33507 {
33508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33509 }
33510 return resultobj;
33511 fail:
33512 return NULL;
33513 }
33514
33515
33516 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33517 PyObject *resultobj = 0;
33518 wxWindow *arg1 = (wxWindow *) 0 ;
33519 wxIcon const &arg2_defvalue = wxNullIcon ;
33520 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33521 wxIcon const &arg3_defvalue = wxNullIcon ;
33522 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33523 wxIcon const &arg4_defvalue = wxNullIcon ;
33524 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33525 wxPyDropSource *result = 0 ;
33526 void *argp1 = 0 ;
33527 int res1 = 0 ;
33528 void *argp2 = 0 ;
33529 int res2 = 0 ;
33530 void *argp3 = 0 ;
33531 int res3 = 0 ;
33532 void *argp4 = 0 ;
33533 int res4 = 0 ;
33534 PyObject * obj0 = 0 ;
33535 PyObject * obj1 = 0 ;
33536 PyObject * obj2 = 0 ;
33537 PyObject * obj3 = 0 ;
33538 char * kwnames[] = {
33539 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33540 };
33541
33542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33544 if (!SWIG_IsOK(res1)) {
33545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33546 }
33547 arg1 = reinterpret_cast< wxWindow * >(argp1);
33548 if (obj1) {
33549 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33550 if (!SWIG_IsOK(res2)) {
33551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33552 }
33553 if (!argp2) {
33554 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33555 }
33556 arg2 = reinterpret_cast< wxIcon * >(argp2);
33557 }
33558 if (obj2) {
33559 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33560 if (!SWIG_IsOK(res3)) {
33561 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33562 }
33563 if (!argp3) {
33564 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33565 }
33566 arg3 = reinterpret_cast< wxIcon * >(argp3);
33567 }
33568 if (obj3) {
33569 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33570 if (!SWIG_IsOK(res4)) {
33571 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33572 }
33573 if (!argp4) {
33574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33575 }
33576 arg4 = reinterpret_cast< wxIcon * >(argp4);
33577 }
33578 {
33579 PyThreadState* __tstate = wxPyBeginAllowThreads();
33580 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33581 wxPyEndAllowThreads(__tstate);
33582 if (PyErr_Occurred()) SWIG_fail;
33583 }
33584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33585 return resultobj;
33586 fail:
33587 return NULL;
33588 }
33589
33590
33591 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33592 PyObject *resultobj = 0;
33593 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33594 PyObject *arg2 = (PyObject *) 0 ;
33595 PyObject *arg3 = (PyObject *) 0 ;
33596 int arg4 ;
33597 void *argp1 = 0 ;
33598 int res1 = 0 ;
33599 int val4 ;
33600 int ecode4 = 0 ;
33601 PyObject * obj0 = 0 ;
33602 PyObject * obj1 = 0 ;
33603 PyObject * obj2 = 0 ;
33604 PyObject * obj3 = 0 ;
33605 char * kwnames[] = {
33606 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33607 };
33608
33609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33611 if (!SWIG_IsOK(res1)) {
33612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33613 }
33614 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33615 arg2 = obj1;
33616 arg3 = obj2;
33617 ecode4 = SWIG_AsVal_int(obj3, &val4);
33618 if (!SWIG_IsOK(ecode4)) {
33619 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33620 }
33621 arg4 = static_cast< int >(val4);
33622 {
33623 PyThreadState* __tstate = wxPyBeginAllowThreads();
33624 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 resultobj = SWIG_Py_Void();
33629 return resultobj;
33630 fail:
33631 return NULL;
33632 }
33633
33634
33635 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33636 PyObject *resultobj = 0;
33637 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33638 void *argp1 = 0 ;
33639 int res1 = 0 ;
33640 PyObject *swig_obj[1] ;
33641
33642 if (!args) SWIG_fail;
33643 swig_obj[0] = args;
33644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33645 if (!SWIG_IsOK(res1)) {
33646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33647 }
33648 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33649 {
33650 PyThreadState* __tstate = wxPyBeginAllowThreads();
33651 delete arg1;
33652
33653 wxPyEndAllowThreads(__tstate);
33654 if (PyErr_Occurred()) SWIG_fail;
33655 }
33656 resultobj = SWIG_Py_Void();
33657 return resultobj;
33658 fail:
33659 return NULL;
33660 }
33661
33662
33663 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33664 PyObject *resultobj = 0;
33665 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33666 wxDataObject *arg2 = 0 ;
33667 void *argp1 = 0 ;
33668 int res1 = 0 ;
33669 void *argp2 = 0 ;
33670 int res2 = 0 ;
33671 PyObject * obj0 = 0 ;
33672 PyObject * obj1 = 0 ;
33673 char * kwnames[] = {
33674 (char *) "self",(char *) "data", NULL
33675 };
33676
33677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33679 if (!SWIG_IsOK(res1)) {
33680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33681 }
33682 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33683 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33684 if (!SWIG_IsOK(res2)) {
33685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33686 }
33687 if (!argp2) {
33688 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33689 }
33690 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33691 {
33692 PyThreadState* __tstate = wxPyBeginAllowThreads();
33693 (arg1)->SetData(*arg2);
33694 wxPyEndAllowThreads(__tstate);
33695 if (PyErr_Occurred()) SWIG_fail;
33696 }
33697 resultobj = SWIG_Py_Void();
33698 return resultobj;
33699 fail:
33700 return NULL;
33701 }
33702
33703
33704 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33705 PyObject *resultobj = 0;
33706 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33707 wxDataObject *result = 0 ;
33708 void *argp1 = 0 ;
33709 int res1 = 0 ;
33710 PyObject *swig_obj[1] ;
33711
33712 if (!args) SWIG_fail;
33713 swig_obj[0] = args;
33714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33715 if (!SWIG_IsOK(res1)) {
33716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33717 }
33718 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33719 {
33720 PyThreadState* __tstate = wxPyBeginAllowThreads();
33721 result = (wxDataObject *)(arg1)->GetDataObject();
33722 wxPyEndAllowThreads(__tstate);
33723 if (PyErr_Occurred()) SWIG_fail;
33724 }
33725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33726 return resultobj;
33727 fail:
33728 return NULL;
33729 }
33730
33731
33732 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33733 PyObject *resultobj = 0;
33734 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33735 wxDragResult arg2 ;
33736 wxCursor *arg3 = 0 ;
33737 void *argp1 = 0 ;
33738 int res1 = 0 ;
33739 int val2 ;
33740 int ecode2 = 0 ;
33741 void *argp3 = 0 ;
33742 int res3 = 0 ;
33743 PyObject * obj0 = 0 ;
33744 PyObject * obj1 = 0 ;
33745 PyObject * obj2 = 0 ;
33746 char * kwnames[] = {
33747 (char *) "self",(char *) "res",(char *) "cursor", NULL
33748 };
33749
33750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33752 if (!SWIG_IsOK(res1)) {
33753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33754 }
33755 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33756 ecode2 = SWIG_AsVal_int(obj1, &val2);
33757 if (!SWIG_IsOK(ecode2)) {
33758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33759 }
33760 arg2 = static_cast< wxDragResult >(val2);
33761 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33762 if (!SWIG_IsOK(res3)) {
33763 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33764 }
33765 if (!argp3) {
33766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33767 }
33768 arg3 = reinterpret_cast< wxCursor * >(argp3);
33769 {
33770 PyThreadState* __tstate = wxPyBeginAllowThreads();
33771 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33772 wxPyEndAllowThreads(__tstate);
33773 if (PyErr_Occurred()) SWIG_fail;
33774 }
33775 resultobj = SWIG_Py_Void();
33776 return resultobj;
33777 fail:
33778 return NULL;
33779 }
33780
33781
33782 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33783 PyObject *resultobj = 0;
33784 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33785 int arg2 = (int) wxDrag_CopyOnly ;
33786 wxDragResult result;
33787 void *argp1 = 0 ;
33788 int res1 = 0 ;
33789 int val2 ;
33790 int ecode2 = 0 ;
33791 PyObject * obj0 = 0 ;
33792 PyObject * obj1 = 0 ;
33793 char * kwnames[] = {
33794 (char *) "self",(char *) "flags", NULL
33795 };
33796
33797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33801 }
33802 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33803 if (obj1) {
33804 ecode2 = SWIG_AsVal_int(obj1, &val2);
33805 if (!SWIG_IsOK(ecode2)) {
33806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33807 }
33808 arg2 = static_cast< int >(val2);
33809 }
33810 {
33811 PyThreadState* __tstate = wxPyBeginAllowThreads();
33812 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33813 wxPyEndAllowThreads(__tstate);
33814 if (PyErr_Occurred()) SWIG_fail;
33815 }
33816 resultobj = SWIG_From_int(static_cast< int >(result));
33817 return resultobj;
33818 fail:
33819 return NULL;
33820 }
33821
33822
33823 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33824 PyObject *resultobj = 0;
33825 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33826 wxDragResult arg2 ;
33827 bool result;
33828 void *argp1 = 0 ;
33829 int res1 = 0 ;
33830 int val2 ;
33831 int ecode2 = 0 ;
33832 PyObject * obj0 = 0 ;
33833 PyObject * obj1 = 0 ;
33834 char * kwnames[] = {
33835 (char *) "self",(char *) "effect", NULL
33836 };
33837
33838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
33839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33840 if (!SWIG_IsOK(res1)) {
33841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33842 }
33843 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33844 ecode2 = SWIG_AsVal_int(obj1, &val2);
33845 if (!SWIG_IsOK(ecode2)) {
33846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
33847 }
33848 arg2 = static_cast< wxDragResult >(val2);
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 result = (bool)(arg1)->GiveFeedback(arg2);
33852 wxPyEndAllowThreads(__tstate);
33853 if (PyErr_Occurred()) SWIG_fail;
33854 }
33855 {
33856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33857 }
33858 return resultobj;
33859 fail:
33860 return NULL;
33861 }
33862
33863
33864 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33865 PyObject *obj;
33866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33867 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
33868 return SWIG_Py_Void();
33869 }
33870
33871 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33872 return SWIG_Python_InitShadowInstance(args);
33873 }
33874
33875 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33876 PyObject *resultobj = 0;
33877 wxDataObject *arg1 = (wxDataObject *) NULL ;
33878 wxPyDropTarget *result = 0 ;
33879 int res1 = 0 ;
33880 PyObject * obj0 = 0 ;
33881 char * kwnames[] = {
33882 (char *) "dataObject", NULL
33883 };
33884
33885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
33886 if (obj0) {
33887 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33888 if (!SWIG_IsOK(res1)) {
33889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
33890 }
33891 }
33892 {
33893 PyThreadState* __tstate = wxPyBeginAllowThreads();
33894 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
33895 wxPyEndAllowThreads(__tstate);
33896 if (PyErr_Occurred()) SWIG_fail;
33897 }
33898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
33899 return resultobj;
33900 fail:
33901 return NULL;
33902 }
33903
33904
33905 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33906 PyObject *resultobj = 0;
33907 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33908 PyObject *arg2 = (PyObject *) 0 ;
33909 PyObject *arg3 = (PyObject *) 0 ;
33910 void *argp1 = 0 ;
33911 int res1 = 0 ;
33912 PyObject * obj0 = 0 ;
33913 PyObject * obj1 = 0 ;
33914 PyObject * obj2 = 0 ;
33915 char * kwnames[] = {
33916 (char *) "self",(char *) "self",(char *) "_class", NULL
33917 };
33918
33919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33921 if (!SWIG_IsOK(res1)) {
33922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33923 }
33924 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33925 arg2 = obj1;
33926 arg3 = obj2;
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 (arg1)->_setCallbackInfo(arg2,arg3);
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 resultobj = SWIG_Py_Void();
33934 return resultobj;
33935 fail:
33936 return NULL;
33937 }
33938
33939
33940 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33941 PyObject *resultobj = 0;
33942 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33943 void *argp1 = 0 ;
33944 int res1 = 0 ;
33945 PyObject *swig_obj[1] ;
33946
33947 if (!args) SWIG_fail;
33948 swig_obj[0] = args;
33949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
33950 if (!SWIG_IsOK(res1)) {
33951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33952 }
33953 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33954 {
33955 PyThreadState* __tstate = wxPyBeginAllowThreads();
33956 delete arg1;
33957
33958 wxPyEndAllowThreads(__tstate);
33959 if (PyErr_Occurred()) SWIG_fail;
33960 }
33961 resultobj = SWIG_Py_Void();
33962 return resultobj;
33963 fail:
33964 return NULL;
33965 }
33966
33967
33968 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33969 PyObject *resultobj = 0;
33970 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33971 wxDataObject *result = 0 ;
33972 void *argp1 = 0 ;
33973 int res1 = 0 ;
33974 PyObject *swig_obj[1] ;
33975
33976 if (!args) SWIG_fail;
33977 swig_obj[0] = args;
33978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33979 if (!SWIG_IsOK(res1)) {
33980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33981 }
33982 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 result = (wxDataObject *)(arg1)->GetDataObject();
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj = 0;
33998 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33999 wxDataObject *arg2 = (wxDataObject *) 0 ;
34000 void *argp1 = 0 ;
34001 int res1 = 0 ;
34002 int res2 = 0 ;
34003 PyObject * obj0 = 0 ;
34004 PyObject * obj1 = 0 ;
34005 char * kwnames[] = {
34006 (char *) "self",(char *) "dataObject", NULL
34007 };
34008
34009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34011 if (!SWIG_IsOK(res1)) {
34012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34013 }
34014 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34015 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34016 if (!SWIG_IsOK(res2)) {
34017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34018 }
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 (arg1)->SetDataObject(arg2);
34022 wxPyEndAllowThreads(__tstate);
34023 if (PyErr_Occurred()) SWIG_fail;
34024 }
34025 resultobj = SWIG_Py_Void();
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34033 PyObject *resultobj = 0;
34034 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34035 int arg2 ;
34036 int arg3 ;
34037 wxDragResult arg4 ;
34038 wxDragResult result;
34039 void *argp1 = 0 ;
34040 int res1 = 0 ;
34041 int val2 ;
34042 int ecode2 = 0 ;
34043 int val3 ;
34044 int ecode3 = 0 ;
34045 int val4 ;
34046 int ecode4 = 0 ;
34047 PyObject * obj0 = 0 ;
34048 PyObject * obj1 = 0 ;
34049 PyObject * obj2 = 0 ;
34050 PyObject * obj3 = 0 ;
34051 char * kwnames[] = {
34052 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34053 };
34054
34055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34057 if (!SWIG_IsOK(res1)) {
34058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34059 }
34060 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34061 ecode2 = SWIG_AsVal_int(obj1, &val2);
34062 if (!SWIG_IsOK(ecode2)) {
34063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34064 }
34065 arg2 = static_cast< int >(val2);
34066 ecode3 = SWIG_AsVal_int(obj2, &val3);
34067 if (!SWIG_IsOK(ecode3)) {
34068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34069 }
34070 arg3 = static_cast< int >(val3);
34071 ecode4 = SWIG_AsVal_int(obj3, &val4);
34072 if (!SWIG_IsOK(ecode4)) {
34073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34074 }
34075 arg4 = static_cast< wxDragResult >(val4);
34076 {
34077 PyThreadState* __tstate = wxPyBeginAllowThreads();
34078 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 resultobj = SWIG_From_int(static_cast< int >(result));
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj = 0;
34091 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34092 int arg2 ;
34093 int arg3 ;
34094 wxDragResult arg4 ;
34095 wxDragResult result;
34096 void *argp1 = 0 ;
34097 int res1 = 0 ;
34098 int val2 ;
34099 int ecode2 = 0 ;
34100 int val3 ;
34101 int ecode3 = 0 ;
34102 int val4 ;
34103 int ecode4 = 0 ;
34104 PyObject * obj0 = 0 ;
34105 PyObject * obj1 = 0 ;
34106 PyObject * obj2 = 0 ;
34107 PyObject * obj3 = 0 ;
34108 char * kwnames[] = {
34109 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34110 };
34111
34112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34114 if (!SWIG_IsOK(res1)) {
34115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34116 }
34117 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34118 ecode2 = SWIG_AsVal_int(obj1, &val2);
34119 if (!SWIG_IsOK(ecode2)) {
34120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34121 }
34122 arg2 = static_cast< int >(val2);
34123 ecode3 = SWIG_AsVal_int(obj2, &val3);
34124 if (!SWIG_IsOK(ecode3)) {
34125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34126 }
34127 arg3 = static_cast< int >(val3);
34128 ecode4 = SWIG_AsVal_int(obj3, &val4);
34129 if (!SWIG_IsOK(ecode4)) {
34130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34131 }
34132 arg4 = static_cast< wxDragResult >(val4);
34133 {
34134 PyThreadState* __tstate = wxPyBeginAllowThreads();
34135 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34136 wxPyEndAllowThreads(__tstate);
34137 if (PyErr_Occurred()) SWIG_fail;
34138 }
34139 resultobj = SWIG_From_int(static_cast< int >(result));
34140 return resultobj;
34141 fail:
34142 return NULL;
34143 }
34144
34145
34146 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34147 PyObject *resultobj = 0;
34148 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34149 void *argp1 = 0 ;
34150 int res1 = 0 ;
34151 PyObject *swig_obj[1] ;
34152
34153 if (!args) SWIG_fail;
34154 swig_obj[0] = args;
34155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34156 if (!SWIG_IsOK(res1)) {
34157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34158 }
34159 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34160 {
34161 PyThreadState* __tstate = wxPyBeginAllowThreads();
34162 (arg1)->OnLeave();
34163 wxPyEndAllowThreads(__tstate);
34164 if (PyErr_Occurred()) SWIG_fail;
34165 }
34166 resultobj = SWIG_Py_Void();
34167 return resultobj;
34168 fail:
34169 return NULL;
34170 }
34171
34172
34173 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34174 PyObject *resultobj = 0;
34175 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34176 int arg2 ;
34177 int arg3 ;
34178 bool result;
34179 void *argp1 = 0 ;
34180 int res1 = 0 ;
34181 int val2 ;
34182 int ecode2 = 0 ;
34183 int val3 ;
34184 int ecode3 = 0 ;
34185 PyObject * obj0 = 0 ;
34186 PyObject * obj1 = 0 ;
34187 PyObject * obj2 = 0 ;
34188 char * kwnames[] = {
34189 (char *) "self",(char *) "x",(char *) "y", NULL
34190 };
34191
34192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34194 if (!SWIG_IsOK(res1)) {
34195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34196 }
34197 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34198 ecode2 = SWIG_AsVal_int(obj1, &val2);
34199 if (!SWIG_IsOK(ecode2)) {
34200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34201 }
34202 arg2 = static_cast< int >(val2);
34203 ecode3 = SWIG_AsVal_int(obj2, &val3);
34204 if (!SWIG_IsOK(ecode3)) {
34205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34206 }
34207 arg3 = static_cast< int >(val3);
34208 {
34209 PyThreadState* __tstate = wxPyBeginAllowThreads();
34210 result = (bool)(arg1)->OnDrop(arg2,arg3);
34211 wxPyEndAllowThreads(__tstate);
34212 if (PyErr_Occurred()) SWIG_fail;
34213 }
34214 {
34215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34216 }
34217 return resultobj;
34218 fail:
34219 return NULL;
34220 }
34221
34222
34223 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34224 PyObject *resultobj = 0;
34225 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34226 bool result;
34227 void *argp1 = 0 ;
34228 int res1 = 0 ;
34229 PyObject *swig_obj[1] ;
34230
34231 if (!args) SWIG_fail;
34232 swig_obj[0] = args;
34233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34234 if (!SWIG_IsOK(res1)) {
34235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34236 }
34237 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 result = (bool)(arg1)->GetData();
34241 wxPyEndAllowThreads(__tstate);
34242 if (PyErr_Occurred()) SWIG_fail;
34243 }
34244 {
34245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34246 }
34247 return resultobj;
34248 fail:
34249 return NULL;
34250 }
34251
34252
34253 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34254 PyObject *resultobj = 0;
34255 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34256 wxDragResult arg2 ;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 int val2 ;
34260 int ecode2 = 0 ;
34261 PyObject * obj0 = 0 ;
34262 PyObject * obj1 = 0 ;
34263 char * kwnames[] = {
34264 (char *) "self",(char *) "action", NULL
34265 };
34266
34267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34269 if (!SWIG_IsOK(res1)) {
34270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34271 }
34272 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34273 ecode2 = SWIG_AsVal_int(obj1, &val2);
34274 if (!SWIG_IsOK(ecode2)) {
34275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34276 }
34277 arg2 = static_cast< wxDragResult >(val2);
34278 {
34279 PyThreadState* __tstate = wxPyBeginAllowThreads();
34280 (arg1)->SetDefaultAction(arg2);
34281 wxPyEndAllowThreads(__tstate);
34282 if (PyErr_Occurred()) SWIG_fail;
34283 }
34284 resultobj = SWIG_Py_Void();
34285 return resultobj;
34286 fail:
34287 return NULL;
34288 }
34289
34290
34291 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34292 PyObject *resultobj = 0;
34293 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34294 wxDragResult result;
34295 void *argp1 = 0 ;
34296 int res1 = 0 ;
34297 PyObject *swig_obj[1] ;
34298
34299 if (!args) SWIG_fail;
34300 swig_obj[0] = args;
34301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34302 if (!SWIG_IsOK(res1)) {
34303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34304 }
34305 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34306 {
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 result = (wxDragResult)(arg1)->GetDefaultAction();
34309 wxPyEndAllowThreads(__tstate);
34310 if (PyErr_Occurred()) SWIG_fail;
34311 }
34312 resultobj = SWIG_From_int(static_cast< int >(result));
34313 return resultobj;
34314 fail:
34315 return NULL;
34316 }
34317
34318
34319 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34320 PyObject *obj;
34321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34322 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34323 return SWIG_Py_Void();
34324 }
34325
34326 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34327 return SWIG_Python_InitShadowInstance(args);
34328 }
34329
34330 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34331 PyObject *resultobj = 0;
34332 wxPyTextDropTarget *result = 0 ;
34333
34334 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34338 wxPyEndAllowThreads(__tstate);
34339 if (PyErr_Occurred()) SWIG_fail;
34340 }
34341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34342 return resultobj;
34343 fail:
34344 return NULL;
34345 }
34346
34347
34348 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34349 PyObject *resultobj = 0;
34350 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34351 PyObject *arg2 = (PyObject *) 0 ;
34352 PyObject *arg3 = (PyObject *) 0 ;
34353 void *argp1 = 0 ;
34354 int res1 = 0 ;
34355 PyObject * obj0 = 0 ;
34356 PyObject * obj1 = 0 ;
34357 PyObject * obj2 = 0 ;
34358 char * kwnames[] = {
34359 (char *) "self",(char *) "self",(char *) "_class", NULL
34360 };
34361
34362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34364 if (!SWIG_IsOK(res1)) {
34365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34366 }
34367 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34368 arg2 = obj1;
34369 arg3 = obj2;
34370 {
34371 PyThreadState* __tstate = wxPyBeginAllowThreads();
34372 (arg1)->_setCallbackInfo(arg2,arg3);
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 resultobj = SWIG_Py_Void();
34377 return resultobj;
34378 fail:
34379 return NULL;
34380 }
34381
34382
34383 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34384 PyObject *resultobj = 0;
34385 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34386 int arg2 ;
34387 int arg3 ;
34388 wxString *arg4 = 0 ;
34389 bool result;
34390 void *argp1 = 0 ;
34391 int res1 = 0 ;
34392 int val2 ;
34393 int ecode2 = 0 ;
34394 int val3 ;
34395 int ecode3 = 0 ;
34396 bool temp4 = false ;
34397 PyObject * obj0 = 0 ;
34398 PyObject * obj1 = 0 ;
34399 PyObject * obj2 = 0 ;
34400 PyObject * obj3 = 0 ;
34401 char * kwnames[] = {
34402 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34403 };
34404
34405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34407 if (!SWIG_IsOK(res1)) {
34408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34409 }
34410 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34411 ecode2 = SWIG_AsVal_int(obj1, &val2);
34412 if (!SWIG_IsOK(ecode2)) {
34413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34414 }
34415 arg2 = static_cast< int >(val2);
34416 ecode3 = SWIG_AsVal_int(obj2, &val3);
34417 if (!SWIG_IsOK(ecode3)) {
34418 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34419 }
34420 arg3 = static_cast< int >(val3);
34421 {
34422 arg4 = wxString_in_helper(obj3);
34423 if (arg4 == NULL) SWIG_fail;
34424 temp4 = true;
34425 }
34426 {
34427 PyThreadState* __tstate = wxPyBeginAllowThreads();
34428 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34429 wxPyEndAllowThreads(__tstate);
34430 if (PyErr_Occurred()) SWIG_fail;
34431 }
34432 {
34433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34434 }
34435 {
34436 if (temp4)
34437 delete arg4;
34438 }
34439 return resultobj;
34440 fail:
34441 {
34442 if (temp4)
34443 delete arg4;
34444 }
34445 return NULL;
34446 }
34447
34448
34449 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34450 PyObject *resultobj = 0;
34451 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34452 int arg2 ;
34453 int arg3 ;
34454 wxDragResult arg4 ;
34455 wxDragResult result;
34456 void *argp1 = 0 ;
34457 int res1 = 0 ;
34458 int val2 ;
34459 int ecode2 = 0 ;
34460 int val3 ;
34461 int ecode3 = 0 ;
34462 int val4 ;
34463 int ecode4 = 0 ;
34464 PyObject * obj0 = 0 ;
34465 PyObject * obj1 = 0 ;
34466 PyObject * obj2 = 0 ;
34467 PyObject * obj3 = 0 ;
34468 char * kwnames[] = {
34469 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34470 };
34471
34472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34474 if (!SWIG_IsOK(res1)) {
34475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34476 }
34477 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34478 ecode2 = SWIG_AsVal_int(obj1, &val2);
34479 if (!SWIG_IsOK(ecode2)) {
34480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34481 }
34482 arg2 = static_cast< int >(val2);
34483 ecode3 = SWIG_AsVal_int(obj2, &val3);
34484 if (!SWIG_IsOK(ecode3)) {
34485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34486 }
34487 arg3 = static_cast< int >(val3);
34488 ecode4 = SWIG_AsVal_int(obj3, &val4);
34489 if (!SWIG_IsOK(ecode4)) {
34490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34491 }
34492 arg4 = static_cast< wxDragResult >(val4);
34493 {
34494 PyThreadState* __tstate = wxPyBeginAllowThreads();
34495 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 resultobj = SWIG_From_int(static_cast< int >(result));
34500 return resultobj;
34501 fail:
34502 return NULL;
34503 }
34504
34505
34506 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34507 PyObject *resultobj = 0;
34508 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34509 int arg2 ;
34510 int arg3 ;
34511 wxDragResult arg4 ;
34512 wxDragResult result;
34513 void *argp1 = 0 ;
34514 int res1 = 0 ;
34515 int val2 ;
34516 int ecode2 = 0 ;
34517 int val3 ;
34518 int ecode3 = 0 ;
34519 int val4 ;
34520 int ecode4 = 0 ;
34521 PyObject * obj0 = 0 ;
34522 PyObject * obj1 = 0 ;
34523 PyObject * obj2 = 0 ;
34524 PyObject * obj3 = 0 ;
34525 char * kwnames[] = {
34526 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34527 };
34528
34529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34531 if (!SWIG_IsOK(res1)) {
34532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34533 }
34534 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34535 ecode2 = SWIG_AsVal_int(obj1, &val2);
34536 if (!SWIG_IsOK(ecode2)) {
34537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34538 }
34539 arg2 = static_cast< int >(val2);
34540 ecode3 = SWIG_AsVal_int(obj2, &val3);
34541 if (!SWIG_IsOK(ecode3)) {
34542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34543 }
34544 arg3 = static_cast< int >(val3);
34545 ecode4 = SWIG_AsVal_int(obj3, &val4);
34546 if (!SWIG_IsOK(ecode4)) {
34547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34548 }
34549 arg4 = static_cast< wxDragResult >(val4);
34550 {
34551 PyThreadState* __tstate = wxPyBeginAllowThreads();
34552 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34553 wxPyEndAllowThreads(__tstate);
34554 if (PyErr_Occurred()) SWIG_fail;
34555 }
34556 resultobj = SWIG_From_int(static_cast< int >(result));
34557 return resultobj;
34558 fail:
34559 return NULL;
34560 }
34561
34562
34563 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34564 PyObject *resultobj = 0;
34565 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34566 void *argp1 = 0 ;
34567 int res1 = 0 ;
34568 PyObject *swig_obj[1] ;
34569
34570 if (!args) SWIG_fail;
34571 swig_obj[0] = args;
34572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34573 if (!SWIG_IsOK(res1)) {
34574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34575 }
34576 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34577 {
34578 PyThreadState* __tstate = wxPyBeginAllowThreads();
34579 (arg1)->OnLeave();
34580 wxPyEndAllowThreads(__tstate);
34581 if (PyErr_Occurred()) SWIG_fail;
34582 }
34583 resultobj = SWIG_Py_Void();
34584 return resultobj;
34585 fail:
34586 return NULL;
34587 }
34588
34589
34590 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34591 PyObject *resultobj = 0;
34592 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34593 int arg2 ;
34594 int arg3 ;
34595 bool result;
34596 void *argp1 = 0 ;
34597 int res1 = 0 ;
34598 int val2 ;
34599 int ecode2 = 0 ;
34600 int val3 ;
34601 int ecode3 = 0 ;
34602 PyObject * obj0 = 0 ;
34603 PyObject * obj1 = 0 ;
34604 PyObject * obj2 = 0 ;
34605 char * kwnames[] = {
34606 (char *) "self",(char *) "x",(char *) "y", NULL
34607 };
34608
34609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34611 if (!SWIG_IsOK(res1)) {
34612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34613 }
34614 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34615 ecode2 = SWIG_AsVal_int(obj1, &val2);
34616 if (!SWIG_IsOK(ecode2)) {
34617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34618 }
34619 arg2 = static_cast< int >(val2);
34620 ecode3 = SWIG_AsVal_int(obj2, &val3);
34621 if (!SWIG_IsOK(ecode3)) {
34622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34623 }
34624 arg3 = static_cast< int >(val3);
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = (bool)(arg1)->OnDrop(arg2,arg3);
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 {
34632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34633 }
34634 return resultobj;
34635 fail:
34636 return NULL;
34637 }
34638
34639
34640 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34641 PyObject *resultobj = 0;
34642 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34643 int arg2 ;
34644 int arg3 ;
34645 wxDragResult arg4 ;
34646 wxDragResult result;
34647 void *argp1 = 0 ;
34648 int res1 = 0 ;
34649 int val2 ;
34650 int ecode2 = 0 ;
34651 int val3 ;
34652 int ecode3 = 0 ;
34653 int val4 ;
34654 int ecode4 = 0 ;
34655 PyObject * obj0 = 0 ;
34656 PyObject * obj1 = 0 ;
34657 PyObject * obj2 = 0 ;
34658 PyObject * obj3 = 0 ;
34659 char * kwnames[] = {
34660 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34661 };
34662
34663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34665 if (!SWIG_IsOK(res1)) {
34666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34667 }
34668 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34669 ecode2 = SWIG_AsVal_int(obj1, &val2);
34670 if (!SWIG_IsOK(ecode2)) {
34671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34672 }
34673 arg2 = static_cast< int >(val2);
34674 ecode3 = SWIG_AsVal_int(obj2, &val3);
34675 if (!SWIG_IsOK(ecode3)) {
34676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34677 }
34678 arg3 = static_cast< int >(val3);
34679 ecode4 = SWIG_AsVal_int(obj3, &val4);
34680 if (!SWIG_IsOK(ecode4)) {
34681 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34682 }
34683 arg4 = static_cast< wxDragResult >(val4);
34684 {
34685 PyThreadState* __tstate = wxPyBeginAllowThreads();
34686 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34687 wxPyEndAllowThreads(__tstate);
34688 if (PyErr_Occurred()) SWIG_fail;
34689 }
34690 resultobj = SWIG_From_int(static_cast< int >(result));
34691 return resultobj;
34692 fail:
34693 return NULL;
34694 }
34695
34696
34697 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34698 PyObject *obj;
34699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34700 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34701 return SWIG_Py_Void();
34702 }
34703
34704 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34705 return SWIG_Python_InitShadowInstance(args);
34706 }
34707
34708 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34709 PyObject *resultobj = 0;
34710 wxPyFileDropTarget *result = 0 ;
34711
34712 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34727 PyObject *resultobj = 0;
34728 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34729 PyObject *arg2 = (PyObject *) 0 ;
34730 PyObject *arg3 = (PyObject *) 0 ;
34731 void *argp1 = 0 ;
34732 int res1 = 0 ;
34733 PyObject * obj0 = 0 ;
34734 PyObject * obj1 = 0 ;
34735 PyObject * obj2 = 0 ;
34736 char * kwnames[] = {
34737 (char *) "self",(char *) "self",(char *) "_class", NULL
34738 };
34739
34740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34742 if (!SWIG_IsOK(res1)) {
34743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34744 }
34745 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34746 arg2 = obj1;
34747 arg3 = obj2;
34748 {
34749 PyThreadState* __tstate = wxPyBeginAllowThreads();
34750 (arg1)->_setCallbackInfo(arg2,arg3);
34751 wxPyEndAllowThreads(__tstate);
34752 if (PyErr_Occurred()) SWIG_fail;
34753 }
34754 resultobj = SWIG_Py_Void();
34755 return resultobj;
34756 fail:
34757 return NULL;
34758 }
34759
34760
34761 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34762 PyObject *resultobj = 0;
34763 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34764 int arg2 ;
34765 int arg3 ;
34766 wxArrayString *arg4 = 0 ;
34767 bool result;
34768 void *argp1 = 0 ;
34769 int res1 = 0 ;
34770 int val2 ;
34771 int ecode2 = 0 ;
34772 int val3 ;
34773 int ecode3 = 0 ;
34774 bool temp4 = false ;
34775 PyObject * obj0 = 0 ;
34776 PyObject * obj1 = 0 ;
34777 PyObject * obj2 = 0 ;
34778 PyObject * obj3 = 0 ;
34779 char * kwnames[] = {
34780 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34781 };
34782
34783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34785 if (!SWIG_IsOK(res1)) {
34786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34787 }
34788 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34789 ecode2 = SWIG_AsVal_int(obj1, &val2);
34790 if (!SWIG_IsOK(ecode2)) {
34791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34792 }
34793 arg2 = static_cast< int >(val2);
34794 ecode3 = SWIG_AsVal_int(obj2, &val3);
34795 if (!SWIG_IsOK(ecode3)) {
34796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34797 }
34798 arg3 = static_cast< int >(val3);
34799 {
34800 if (! PySequence_Check(obj3)) {
34801 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34802 SWIG_fail;
34803 }
34804 arg4 = new wxArrayString;
34805 temp4 = true;
34806 int i, len=PySequence_Length(obj3);
34807 for (i=0; i<len; i++) {
34808 PyObject* item = PySequence_GetItem(obj3, i);
34809 wxString* s = wxString_in_helper(item);
34810 if (PyErr_Occurred()) SWIG_fail;
34811 arg4->Add(*s);
34812 delete s;
34813 Py_DECREF(item);
34814 }
34815 }
34816 {
34817 PyThreadState* __tstate = wxPyBeginAllowThreads();
34818 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34819 wxPyEndAllowThreads(__tstate);
34820 if (PyErr_Occurred()) SWIG_fail;
34821 }
34822 {
34823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34824 }
34825 {
34826 if (temp4) delete arg4;
34827 }
34828 return resultobj;
34829 fail:
34830 {
34831 if (temp4) delete arg4;
34832 }
34833 return NULL;
34834 }
34835
34836
34837 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34838 PyObject *resultobj = 0;
34839 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34840 int arg2 ;
34841 int arg3 ;
34842 wxDragResult arg4 ;
34843 wxDragResult result;
34844 void *argp1 = 0 ;
34845 int res1 = 0 ;
34846 int val2 ;
34847 int ecode2 = 0 ;
34848 int val3 ;
34849 int ecode3 = 0 ;
34850 int val4 ;
34851 int ecode4 = 0 ;
34852 PyObject * obj0 = 0 ;
34853 PyObject * obj1 = 0 ;
34854 PyObject * obj2 = 0 ;
34855 PyObject * obj3 = 0 ;
34856 char * kwnames[] = {
34857 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34858 };
34859
34860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34862 if (!SWIG_IsOK(res1)) {
34863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34864 }
34865 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34866 ecode2 = SWIG_AsVal_int(obj1, &val2);
34867 if (!SWIG_IsOK(ecode2)) {
34868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34869 }
34870 arg2 = static_cast< int >(val2);
34871 ecode3 = SWIG_AsVal_int(obj2, &val3);
34872 if (!SWIG_IsOK(ecode3)) {
34873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34874 }
34875 arg3 = static_cast< int >(val3);
34876 ecode4 = SWIG_AsVal_int(obj3, &val4);
34877 if (!SWIG_IsOK(ecode4)) {
34878 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34879 }
34880 arg4 = static_cast< wxDragResult >(val4);
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34884 wxPyEndAllowThreads(__tstate);
34885 if (PyErr_Occurred()) SWIG_fail;
34886 }
34887 resultobj = SWIG_From_int(static_cast< int >(result));
34888 return resultobj;
34889 fail:
34890 return NULL;
34891 }
34892
34893
34894 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34895 PyObject *resultobj = 0;
34896 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34897 int arg2 ;
34898 int arg3 ;
34899 wxDragResult arg4 ;
34900 wxDragResult result;
34901 void *argp1 = 0 ;
34902 int res1 = 0 ;
34903 int val2 ;
34904 int ecode2 = 0 ;
34905 int val3 ;
34906 int ecode3 = 0 ;
34907 int val4 ;
34908 int ecode4 = 0 ;
34909 PyObject * obj0 = 0 ;
34910 PyObject * obj1 = 0 ;
34911 PyObject * obj2 = 0 ;
34912 PyObject * obj3 = 0 ;
34913 char * kwnames[] = {
34914 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34915 };
34916
34917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34919 if (!SWIG_IsOK(res1)) {
34920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34921 }
34922 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34923 ecode2 = SWIG_AsVal_int(obj1, &val2);
34924 if (!SWIG_IsOK(ecode2)) {
34925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34926 }
34927 arg2 = static_cast< int >(val2);
34928 ecode3 = SWIG_AsVal_int(obj2, &val3);
34929 if (!SWIG_IsOK(ecode3)) {
34930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34931 }
34932 arg3 = static_cast< int >(val3);
34933 ecode4 = SWIG_AsVal_int(obj3, &val4);
34934 if (!SWIG_IsOK(ecode4)) {
34935 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34936 }
34937 arg4 = static_cast< wxDragResult >(val4);
34938 {
34939 PyThreadState* __tstate = wxPyBeginAllowThreads();
34940 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34941 wxPyEndAllowThreads(__tstate);
34942 if (PyErr_Occurred()) SWIG_fail;
34943 }
34944 resultobj = SWIG_From_int(static_cast< int >(result));
34945 return resultobj;
34946 fail:
34947 return NULL;
34948 }
34949
34950
34951 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34952 PyObject *resultobj = 0;
34953 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34954 void *argp1 = 0 ;
34955 int res1 = 0 ;
34956 PyObject *swig_obj[1] ;
34957
34958 if (!args) SWIG_fail;
34959 swig_obj[0] = args;
34960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34961 if (!SWIG_IsOK(res1)) {
34962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34963 }
34964 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34965 {
34966 PyThreadState* __tstate = wxPyBeginAllowThreads();
34967 (arg1)->OnLeave();
34968 wxPyEndAllowThreads(__tstate);
34969 if (PyErr_Occurred()) SWIG_fail;
34970 }
34971 resultobj = SWIG_Py_Void();
34972 return resultobj;
34973 fail:
34974 return NULL;
34975 }
34976
34977
34978 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34979 PyObject *resultobj = 0;
34980 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34981 int arg2 ;
34982 int arg3 ;
34983 bool result;
34984 void *argp1 = 0 ;
34985 int res1 = 0 ;
34986 int val2 ;
34987 int ecode2 = 0 ;
34988 int val3 ;
34989 int ecode3 = 0 ;
34990 PyObject * obj0 = 0 ;
34991 PyObject * obj1 = 0 ;
34992 PyObject * obj2 = 0 ;
34993 char * kwnames[] = {
34994 (char *) "self",(char *) "x",(char *) "y", NULL
34995 };
34996
34997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34999 if (!SWIG_IsOK(res1)) {
35000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35001 }
35002 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35003 ecode2 = SWIG_AsVal_int(obj1, &val2);
35004 if (!SWIG_IsOK(ecode2)) {
35005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35006 }
35007 arg2 = static_cast< int >(val2);
35008 ecode3 = SWIG_AsVal_int(obj2, &val3);
35009 if (!SWIG_IsOK(ecode3)) {
35010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35011 }
35012 arg3 = static_cast< int >(val3);
35013 {
35014 PyThreadState* __tstate = wxPyBeginAllowThreads();
35015 result = (bool)(arg1)->OnDrop(arg2,arg3);
35016 wxPyEndAllowThreads(__tstate);
35017 if (PyErr_Occurred()) SWIG_fail;
35018 }
35019 {
35020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35021 }
35022 return resultobj;
35023 fail:
35024 return NULL;
35025 }
35026
35027
35028 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35029 PyObject *resultobj = 0;
35030 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35031 int arg2 ;
35032 int arg3 ;
35033 wxDragResult arg4 ;
35034 wxDragResult result;
35035 void *argp1 = 0 ;
35036 int res1 = 0 ;
35037 int val2 ;
35038 int ecode2 = 0 ;
35039 int val3 ;
35040 int ecode3 = 0 ;
35041 int val4 ;
35042 int ecode4 = 0 ;
35043 PyObject * obj0 = 0 ;
35044 PyObject * obj1 = 0 ;
35045 PyObject * obj2 = 0 ;
35046 PyObject * obj3 = 0 ;
35047 char * kwnames[] = {
35048 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35049 };
35050
35051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35053 if (!SWIG_IsOK(res1)) {
35054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35055 }
35056 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35057 ecode2 = SWIG_AsVal_int(obj1, &val2);
35058 if (!SWIG_IsOK(ecode2)) {
35059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35060 }
35061 arg2 = static_cast< int >(val2);
35062 ecode3 = SWIG_AsVal_int(obj2, &val3);
35063 if (!SWIG_IsOK(ecode3)) {
35064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35065 }
35066 arg3 = static_cast< int >(val3);
35067 ecode4 = SWIG_AsVal_int(obj3, &val4);
35068 if (!SWIG_IsOK(ecode4)) {
35069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35070 }
35071 arg4 = static_cast< wxDragResult >(val4);
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 resultobj = SWIG_From_int(static_cast< int >(result));
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35086 PyObject *obj;
35087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35088 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35089 return SWIG_Py_Void();
35090 }
35091
35092 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35093 return SWIG_Python_InitShadowInstance(args);
35094 }
35095
35096 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35097 PyObject *resultobj = 0;
35098 wxClipboard *result = 0 ;
35099
35100 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35101 {
35102 PyThreadState* __tstate = wxPyBeginAllowThreads();
35103 result = (wxClipboard *)new wxClipboard();
35104 wxPyEndAllowThreads(__tstate);
35105 if (PyErr_Occurred()) SWIG_fail;
35106 }
35107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35108 return resultobj;
35109 fail:
35110 return NULL;
35111 }
35112
35113
35114 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35115 PyObject *resultobj = 0;
35116 wxClipboard *arg1 = (wxClipboard *) 0 ;
35117 void *argp1 = 0 ;
35118 int res1 = 0 ;
35119 PyObject *swig_obj[1] ;
35120
35121 if (!args) SWIG_fail;
35122 swig_obj[0] = args;
35123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35124 if (!SWIG_IsOK(res1)) {
35125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35126 }
35127 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35128 {
35129 PyThreadState* __tstate = wxPyBeginAllowThreads();
35130 delete arg1;
35131
35132 wxPyEndAllowThreads(__tstate);
35133 if (PyErr_Occurred()) SWIG_fail;
35134 }
35135 resultobj = SWIG_Py_Void();
35136 return resultobj;
35137 fail:
35138 return NULL;
35139 }
35140
35141
35142 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35143 PyObject *resultobj = 0;
35144 wxClipboard *arg1 = (wxClipboard *) 0 ;
35145 bool result;
35146 void *argp1 = 0 ;
35147 int res1 = 0 ;
35148 PyObject *swig_obj[1] ;
35149
35150 if (!args) SWIG_fail;
35151 swig_obj[0] = args;
35152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35153 if (!SWIG_IsOK(res1)) {
35154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35155 }
35156 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35157 {
35158 PyThreadState* __tstate = wxPyBeginAllowThreads();
35159 result = (bool)(arg1)->Open();
35160 wxPyEndAllowThreads(__tstate);
35161 if (PyErr_Occurred()) SWIG_fail;
35162 }
35163 {
35164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35165 }
35166 return resultobj;
35167 fail:
35168 return NULL;
35169 }
35170
35171
35172 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35173 PyObject *resultobj = 0;
35174 wxClipboard *arg1 = (wxClipboard *) 0 ;
35175 void *argp1 = 0 ;
35176 int res1 = 0 ;
35177 PyObject *swig_obj[1] ;
35178
35179 if (!args) SWIG_fail;
35180 swig_obj[0] = args;
35181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35182 if (!SWIG_IsOK(res1)) {
35183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35184 }
35185 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 (arg1)->Close();
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 resultobj = SWIG_Py_Void();
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35200 PyObject *resultobj = 0;
35201 wxClipboard *arg1 = (wxClipboard *) 0 ;
35202 bool result;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 PyObject *swig_obj[1] ;
35206
35207 if (!args) SWIG_fail;
35208 swig_obj[0] = args;
35209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35210 if (!SWIG_IsOK(res1)) {
35211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35212 }
35213 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 {
35221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35222 }
35223 return resultobj;
35224 fail:
35225 return NULL;
35226 }
35227
35228
35229 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35230 PyObject *resultobj = 0;
35231 wxClipboard *arg1 = (wxClipboard *) 0 ;
35232 wxDataObject *arg2 = (wxDataObject *) 0 ;
35233 bool result;
35234 void *argp1 = 0 ;
35235 int res1 = 0 ;
35236 int res2 = 0 ;
35237 PyObject * obj0 = 0 ;
35238 PyObject * obj1 = 0 ;
35239 char * kwnames[] = {
35240 (char *) "self",(char *) "data", NULL
35241 };
35242
35243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35245 if (!SWIG_IsOK(res1)) {
35246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35247 }
35248 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35249 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35250 if (!SWIG_IsOK(res2)) {
35251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35252 }
35253 {
35254 PyThreadState* __tstate = wxPyBeginAllowThreads();
35255 result = (bool)(arg1)->AddData(arg2);
35256 wxPyEndAllowThreads(__tstate);
35257 if (PyErr_Occurred()) SWIG_fail;
35258 }
35259 {
35260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35261 }
35262 return resultobj;
35263 fail:
35264 return NULL;
35265 }
35266
35267
35268 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35269 PyObject *resultobj = 0;
35270 wxClipboard *arg1 = (wxClipboard *) 0 ;
35271 wxDataObject *arg2 = (wxDataObject *) 0 ;
35272 bool result;
35273 void *argp1 = 0 ;
35274 int res1 = 0 ;
35275 int res2 = 0 ;
35276 PyObject * obj0 = 0 ;
35277 PyObject * obj1 = 0 ;
35278 char * kwnames[] = {
35279 (char *) "self",(char *) "data", NULL
35280 };
35281
35282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35284 if (!SWIG_IsOK(res1)) {
35285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35286 }
35287 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35288 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35289 if (!SWIG_IsOK(res2)) {
35290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35291 }
35292 {
35293 PyThreadState* __tstate = wxPyBeginAllowThreads();
35294 result = (bool)(arg1)->SetData(arg2);
35295 wxPyEndAllowThreads(__tstate);
35296 if (PyErr_Occurred()) SWIG_fail;
35297 }
35298 {
35299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35300 }
35301 return resultobj;
35302 fail:
35303 return NULL;
35304 }
35305
35306
35307 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35308 PyObject *resultobj = 0;
35309 wxClipboard *arg1 = (wxClipboard *) 0 ;
35310 wxDataFormat *arg2 = 0 ;
35311 bool result;
35312 void *argp1 = 0 ;
35313 int res1 = 0 ;
35314 void *argp2 = 0 ;
35315 int res2 = 0 ;
35316 PyObject * obj0 = 0 ;
35317 PyObject * obj1 = 0 ;
35318 char * kwnames[] = {
35319 (char *) "self",(char *) "format", NULL
35320 };
35321
35322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35324 if (!SWIG_IsOK(res1)) {
35325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35326 }
35327 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35329 if (!SWIG_IsOK(res2)) {
35330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35331 }
35332 if (!argp2) {
35333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35334 }
35335 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35336 {
35337 PyThreadState* __tstate = wxPyBeginAllowThreads();
35338 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35339 wxPyEndAllowThreads(__tstate);
35340 if (PyErr_Occurred()) SWIG_fail;
35341 }
35342 {
35343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35344 }
35345 return resultobj;
35346 fail:
35347 return NULL;
35348 }
35349
35350
35351 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35352 PyObject *resultobj = 0;
35353 wxClipboard *arg1 = (wxClipboard *) 0 ;
35354 wxDataObject *arg2 = 0 ;
35355 bool result;
35356 void *argp1 = 0 ;
35357 int res1 = 0 ;
35358 void *argp2 = 0 ;
35359 int res2 = 0 ;
35360 PyObject * obj0 = 0 ;
35361 PyObject * obj1 = 0 ;
35362 char * kwnames[] = {
35363 (char *) "self",(char *) "data", NULL
35364 };
35365
35366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35368 if (!SWIG_IsOK(res1)) {
35369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35370 }
35371 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35373 if (!SWIG_IsOK(res2)) {
35374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35375 }
35376 if (!argp2) {
35377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35378 }
35379 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35380 {
35381 PyThreadState* __tstate = wxPyBeginAllowThreads();
35382 result = (bool)(arg1)->GetData(*arg2);
35383 wxPyEndAllowThreads(__tstate);
35384 if (PyErr_Occurred()) SWIG_fail;
35385 }
35386 {
35387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35388 }
35389 return resultobj;
35390 fail:
35391 return NULL;
35392 }
35393
35394
35395 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35396 PyObject *resultobj = 0;
35397 wxClipboard *arg1 = (wxClipboard *) 0 ;
35398 void *argp1 = 0 ;
35399 int res1 = 0 ;
35400 PyObject *swig_obj[1] ;
35401
35402 if (!args) SWIG_fail;
35403 swig_obj[0] = args;
35404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35405 if (!SWIG_IsOK(res1)) {
35406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35407 }
35408 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35409 {
35410 PyThreadState* __tstate = wxPyBeginAllowThreads();
35411 (arg1)->Clear();
35412 wxPyEndAllowThreads(__tstate);
35413 if (PyErr_Occurred()) SWIG_fail;
35414 }
35415 resultobj = SWIG_Py_Void();
35416 return resultobj;
35417 fail:
35418 return NULL;
35419 }
35420
35421
35422 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35423 PyObject *resultobj = 0;
35424 wxClipboard *arg1 = (wxClipboard *) 0 ;
35425 bool result;
35426 void *argp1 = 0 ;
35427 int res1 = 0 ;
35428 PyObject *swig_obj[1] ;
35429
35430 if (!args) SWIG_fail;
35431 swig_obj[0] = args;
35432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35433 if (!SWIG_IsOK(res1)) {
35434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35435 }
35436 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 result = (bool)(arg1)->Flush();
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 {
35444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35445 }
35446 return resultobj;
35447 fail:
35448 return NULL;
35449 }
35450
35451
35452 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35453 PyObject *resultobj = 0;
35454 wxClipboard *arg1 = (wxClipboard *) 0 ;
35455 bool arg2 = (bool) true ;
35456 void *argp1 = 0 ;
35457 int res1 = 0 ;
35458 bool val2 ;
35459 int ecode2 = 0 ;
35460 PyObject * obj0 = 0 ;
35461 PyObject * obj1 = 0 ;
35462 char * kwnames[] = {
35463 (char *) "self",(char *) "primary", NULL
35464 };
35465
35466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35468 if (!SWIG_IsOK(res1)) {
35469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35470 }
35471 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35472 if (obj1) {
35473 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35474 if (!SWIG_IsOK(ecode2)) {
35475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35476 }
35477 arg2 = static_cast< bool >(val2);
35478 }
35479 {
35480 PyThreadState* __tstate = wxPyBeginAllowThreads();
35481 (arg1)->UsePrimarySelection(arg2);
35482 wxPyEndAllowThreads(__tstate);
35483 if (PyErr_Occurred()) SWIG_fail;
35484 }
35485 resultobj = SWIG_Py_Void();
35486 return resultobj;
35487 fail:
35488 return NULL;
35489 }
35490
35491
35492 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35493 PyObject *resultobj = 0;
35494 wxClipboard *result = 0 ;
35495
35496 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 result = (wxClipboard *)wxClipboard::Get();
35500 wxPyEndAllowThreads(__tstate);
35501 if (PyErr_Occurred()) SWIG_fail;
35502 }
35503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35504 return resultobj;
35505 fail:
35506 return NULL;
35507 }
35508
35509
35510 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35511 PyObject *obj;
35512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35513 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35514 return SWIG_Py_Void();
35515 }
35516
35517 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35518 return SWIG_Python_InitShadowInstance(args);
35519 }
35520
35521 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35522 PyObject *resultobj = 0;
35523 wxClipboard *arg1 = (wxClipboard *) NULL ;
35524 wxClipboardLocker *result = 0 ;
35525 void *argp1 = 0 ;
35526 int res1 = 0 ;
35527 PyObject * obj0 = 0 ;
35528 char * kwnames[] = {
35529 (char *) "clipboard", NULL
35530 };
35531
35532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35533 if (obj0) {
35534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35535 if (!SWIG_IsOK(res1)) {
35536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35537 }
35538 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35539 }
35540 {
35541 PyThreadState* __tstate = wxPyBeginAllowThreads();
35542 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35543 wxPyEndAllowThreads(__tstate);
35544 if (PyErr_Occurred()) SWIG_fail;
35545 }
35546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35547 return resultobj;
35548 fail:
35549 return NULL;
35550 }
35551
35552
35553 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35554 PyObject *resultobj = 0;
35555 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35556 void *argp1 = 0 ;
35557 int res1 = 0 ;
35558 PyObject *swig_obj[1] ;
35559
35560 if (!args) SWIG_fail;
35561 swig_obj[0] = args;
35562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35563 if (!SWIG_IsOK(res1)) {
35564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35565 }
35566 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35567 {
35568 PyThreadState* __tstate = wxPyBeginAllowThreads();
35569 delete arg1;
35570
35571 wxPyEndAllowThreads(__tstate);
35572 if (PyErr_Occurred()) SWIG_fail;
35573 }
35574 resultobj = SWIG_Py_Void();
35575 return resultobj;
35576 fail:
35577 return NULL;
35578 }
35579
35580
35581 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35582 PyObject *resultobj = 0;
35583 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35584 bool result;
35585 void *argp1 = 0 ;
35586 int res1 = 0 ;
35587 PyObject *swig_obj[1] ;
35588
35589 if (!args) SWIG_fail;
35590 swig_obj[0] = args;
35591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35592 if (!SWIG_IsOK(res1)) {
35593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35594 }
35595 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35596 {
35597 PyThreadState* __tstate = wxPyBeginAllowThreads();
35598 result = (bool)wxClipboardLocker___nonzero__(arg1);
35599 wxPyEndAllowThreads(__tstate);
35600 if (PyErr_Occurred()) SWIG_fail;
35601 }
35602 {
35603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35604 }
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35612 PyObject *obj;
35613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35614 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35615 return SWIG_Py_Void();
35616 }
35617
35618 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35619 return SWIG_Python_InitShadowInstance(args);
35620 }
35621
35622 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35623 PyObject *resultobj = 0;
35624 int arg1 = (int) 0 ;
35625 int arg2 = (int) 0 ;
35626 int arg3 = (int) 0 ;
35627 int arg4 = (int) 0 ;
35628 wxVideoMode *result = 0 ;
35629 int val1 ;
35630 int ecode1 = 0 ;
35631 int val2 ;
35632 int ecode2 = 0 ;
35633 int val3 ;
35634 int ecode3 = 0 ;
35635 int val4 ;
35636 int ecode4 = 0 ;
35637 PyObject * obj0 = 0 ;
35638 PyObject * obj1 = 0 ;
35639 PyObject * obj2 = 0 ;
35640 PyObject * obj3 = 0 ;
35641 char * kwnames[] = {
35642 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35643 };
35644
35645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35646 if (obj0) {
35647 ecode1 = SWIG_AsVal_int(obj0, &val1);
35648 if (!SWIG_IsOK(ecode1)) {
35649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35650 }
35651 arg1 = static_cast< int >(val1);
35652 }
35653 if (obj1) {
35654 ecode2 = SWIG_AsVal_int(obj1, &val2);
35655 if (!SWIG_IsOK(ecode2)) {
35656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35657 }
35658 arg2 = static_cast< int >(val2);
35659 }
35660 if (obj2) {
35661 ecode3 = SWIG_AsVal_int(obj2, &val3);
35662 if (!SWIG_IsOK(ecode3)) {
35663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35664 }
35665 arg3 = static_cast< int >(val3);
35666 }
35667 if (obj3) {
35668 ecode4 = SWIG_AsVal_int(obj3, &val4);
35669 if (!SWIG_IsOK(ecode4)) {
35670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35671 }
35672 arg4 = static_cast< int >(val4);
35673 }
35674 {
35675 PyThreadState* __tstate = wxPyBeginAllowThreads();
35676 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35677 wxPyEndAllowThreads(__tstate);
35678 if (PyErr_Occurred()) SWIG_fail;
35679 }
35680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35681 return resultobj;
35682 fail:
35683 return NULL;
35684 }
35685
35686
35687 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35688 PyObject *resultobj = 0;
35689 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35690 void *argp1 = 0 ;
35691 int res1 = 0 ;
35692 PyObject *swig_obj[1] ;
35693
35694 if (!args) SWIG_fail;
35695 swig_obj[0] = args;
35696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35697 if (!SWIG_IsOK(res1)) {
35698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35699 }
35700 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35701 {
35702 PyThreadState* __tstate = wxPyBeginAllowThreads();
35703 delete arg1;
35704
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 resultobj = SWIG_Py_Void();
35709 return resultobj;
35710 fail:
35711 return NULL;
35712 }
35713
35714
35715 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35716 PyObject *resultobj = 0;
35717 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35718 wxVideoMode *arg2 = 0 ;
35719 bool result;
35720 void *argp1 = 0 ;
35721 int res1 = 0 ;
35722 void *argp2 = 0 ;
35723 int res2 = 0 ;
35724 PyObject * obj0 = 0 ;
35725 PyObject * obj1 = 0 ;
35726 char * kwnames[] = {
35727 (char *) "self",(char *) "other", NULL
35728 };
35729
35730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35732 if (!SWIG_IsOK(res1)) {
35733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35734 }
35735 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35736 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35737 if (!SWIG_IsOK(res2)) {
35738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35739 }
35740 if (!argp2) {
35741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35742 }
35743 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35744 {
35745 PyThreadState* __tstate = wxPyBeginAllowThreads();
35746 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35747 wxPyEndAllowThreads(__tstate);
35748 if (PyErr_Occurred()) SWIG_fail;
35749 }
35750 {
35751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35752 }
35753 return resultobj;
35754 fail:
35755 return NULL;
35756 }
35757
35758
35759 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35760 PyObject *resultobj = 0;
35761 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35762 int result;
35763 void *argp1 = 0 ;
35764 int res1 = 0 ;
35765 PyObject *swig_obj[1] ;
35766
35767 if (!args) SWIG_fail;
35768 swig_obj[0] = args;
35769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35770 if (!SWIG_IsOK(res1)) {
35771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35772 }
35773 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35774 {
35775 PyThreadState* __tstate = wxPyBeginAllowThreads();
35776 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35777 wxPyEndAllowThreads(__tstate);
35778 if (PyErr_Occurred()) SWIG_fail;
35779 }
35780 resultobj = SWIG_From_int(static_cast< int >(result));
35781 return resultobj;
35782 fail:
35783 return NULL;
35784 }
35785
35786
35787 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35788 PyObject *resultobj = 0;
35789 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35790 int result;
35791 void *argp1 = 0 ;
35792 int res1 = 0 ;
35793 PyObject *swig_obj[1] ;
35794
35795 if (!args) SWIG_fail;
35796 swig_obj[0] = args;
35797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35798 if (!SWIG_IsOK(res1)) {
35799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35800 }
35801 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35802 {
35803 PyThreadState* __tstate = wxPyBeginAllowThreads();
35804 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35805 wxPyEndAllowThreads(__tstate);
35806 if (PyErr_Occurred()) SWIG_fail;
35807 }
35808 resultobj = SWIG_From_int(static_cast< int >(result));
35809 return resultobj;
35810 fail:
35811 return NULL;
35812 }
35813
35814
35815 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35816 PyObject *resultobj = 0;
35817 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35818 int result;
35819 void *argp1 = 0 ;
35820 int res1 = 0 ;
35821 PyObject *swig_obj[1] ;
35822
35823 if (!args) SWIG_fail;
35824 swig_obj[0] = args;
35825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35826 if (!SWIG_IsOK(res1)) {
35827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35828 }
35829 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35830 {
35831 PyThreadState* __tstate = wxPyBeginAllowThreads();
35832 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35833 wxPyEndAllowThreads(__tstate);
35834 if (PyErr_Occurred()) SWIG_fail;
35835 }
35836 resultobj = SWIG_From_int(static_cast< int >(result));
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35844 PyObject *resultobj = 0;
35845 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35846 bool result;
35847 void *argp1 = 0 ;
35848 int res1 = 0 ;
35849 PyObject *swig_obj[1] ;
35850
35851 if (!args) SWIG_fail;
35852 swig_obj[0] = args;
35853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35854 if (!SWIG_IsOK(res1)) {
35855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35856 }
35857 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35858 {
35859 PyThreadState* __tstate = wxPyBeginAllowThreads();
35860 result = (bool)((wxVideoMode const *)arg1)->IsOk();
35861 wxPyEndAllowThreads(__tstate);
35862 if (PyErr_Occurred()) SWIG_fail;
35863 }
35864 {
35865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35866 }
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35874 PyObject *resultobj = 0;
35875 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35876 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35877 bool result;
35878 void *argp1 = 0 ;
35879 int res1 = 0 ;
35880 void *argp2 = 0 ;
35881 int res2 = 0 ;
35882 PyObject * obj0 = 0 ;
35883 PyObject * obj1 = 0 ;
35884 char * kwnames[] = {
35885 (char *) "self",(char *) "other", NULL
35886 };
35887
35888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
35889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35890 if (!SWIG_IsOK(res1)) {
35891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35892 }
35893 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35894 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35895 if (!SWIG_IsOK(res2)) {
35896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35897 }
35898 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35899 {
35900 PyThreadState* __tstate = wxPyBeginAllowThreads();
35901 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
35902 wxPyEndAllowThreads(__tstate);
35903 if (PyErr_Occurred()) SWIG_fail;
35904 }
35905 {
35906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35907 }
35908 return resultobj;
35909 fail:
35910 return NULL;
35911 }
35912
35913
35914 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35915 PyObject *resultobj = 0;
35916 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35917 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35918 bool result;
35919 void *argp1 = 0 ;
35920 int res1 = 0 ;
35921 void *argp2 = 0 ;
35922 int res2 = 0 ;
35923 PyObject * obj0 = 0 ;
35924 PyObject * obj1 = 0 ;
35925 char * kwnames[] = {
35926 (char *) "self",(char *) "other", NULL
35927 };
35928
35929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
35930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35931 if (!SWIG_IsOK(res1)) {
35932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35933 }
35934 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35936 if (!SWIG_IsOK(res2)) {
35937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35938 }
35939 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35940 {
35941 PyThreadState* __tstate = wxPyBeginAllowThreads();
35942 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
35943 wxPyEndAllowThreads(__tstate);
35944 if (PyErr_Occurred()) SWIG_fail;
35945 }
35946 {
35947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35948 }
35949 return resultobj;
35950 fail:
35951 return NULL;
35952 }
35953
35954
35955 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35956 PyObject *resultobj = 0;
35957 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35958 int arg2 ;
35959 void *argp1 = 0 ;
35960 int res1 = 0 ;
35961 int val2 ;
35962 int ecode2 = 0 ;
35963 PyObject *swig_obj[2] ;
35964
35965 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
35966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35967 if (!SWIG_IsOK(res1)) {
35968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35969 }
35970 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35971 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35972 if (!SWIG_IsOK(ecode2)) {
35973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35974 }
35975 arg2 = static_cast< int >(val2);
35976 if (arg1) (arg1)->w = arg2;
35977
35978 resultobj = SWIG_Py_Void();
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35986 PyObject *resultobj = 0;
35987 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35988 int result;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 PyObject *swig_obj[1] ;
35992
35993 if (!args) SWIG_fail;
35994 swig_obj[0] = args;
35995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35996 if (!SWIG_IsOK(res1)) {
35997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35998 }
35999 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36000 result = (int) ((arg1)->w);
36001 resultobj = SWIG_From_int(static_cast< int >(result));
36002 return resultobj;
36003 fail:
36004 return NULL;
36005 }
36006
36007
36008 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36009 PyObject *resultobj = 0;
36010 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36011 int arg2 ;
36012 void *argp1 = 0 ;
36013 int res1 = 0 ;
36014 int val2 ;
36015 int ecode2 = 0 ;
36016 PyObject *swig_obj[2] ;
36017
36018 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36020 if (!SWIG_IsOK(res1)) {
36021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36022 }
36023 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36024 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36025 if (!SWIG_IsOK(ecode2)) {
36026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36027 }
36028 arg2 = static_cast< int >(val2);
36029 if (arg1) (arg1)->h = arg2;
36030
36031 resultobj = SWIG_Py_Void();
36032 return resultobj;
36033 fail:
36034 return NULL;
36035 }
36036
36037
36038 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36039 PyObject *resultobj = 0;
36040 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36041 int result;
36042 void *argp1 = 0 ;
36043 int res1 = 0 ;
36044 PyObject *swig_obj[1] ;
36045
36046 if (!args) SWIG_fail;
36047 swig_obj[0] = args;
36048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36049 if (!SWIG_IsOK(res1)) {
36050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36051 }
36052 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36053 result = (int) ((arg1)->h);
36054 resultobj = SWIG_From_int(static_cast< int >(result));
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36062 PyObject *resultobj = 0;
36063 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36064 int arg2 ;
36065 void *argp1 = 0 ;
36066 int res1 = 0 ;
36067 int val2 ;
36068 int ecode2 = 0 ;
36069 PyObject *swig_obj[2] ;
36070
36071 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36073 if (!SWIG_IsOK(res1)) {
36074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36075 }
36076 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36077 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36078 if (!SWIG_IsOK(ecode2)) {
36079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36080 }
36081 arg2 = static_cast< int >(val2);
36082 if (arg1) (arg1)->bpp = arg2;
36083
36084 resultobj = SWIG_Py_Void();
36085 return resultobj;
36086 fail:
36087 return NULL;
36088 }
36089
36090
36091 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36092 PyObject *resultobj = 0;
36093 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36094 int result;
36095 void *argp1 = 0 ;
36096 int res1 = 0 ;
36097 PyObject *swig_obj[1] ;
36098
36099 if (!args) SWIG_fail;
36100 swig_obj[0] = args;
36101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36102 if (!SWIG_IsOK(res1)) {
36103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36104 }
36105 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36106 result = (int) ((arg1)->bpp);
36107 resultobj = SWIG_From_int(static_cast< int >(result));
36108 return resultobj;
36109 fail:
36110 return NULL;
36111 }
36112
36113
36114 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36115 PyObject *resultobj = 0;
36116 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36117 int arg2 ;
36118 void *argp1 = 0 ;
36119 int res1 = 0 ;
36120 int val2 ;
36121 int ecode2 = 0 ;
36122 PyObject *swig_obj[2] ;
36123
36124 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36126 if (!SWIG_IsOK(res1)) {
36127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36128 }
36129 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36130 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36131 if (!SWIG_IsOK(ecode2)) {
36132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36133 }
36134 arg2 = static_cast< int >(val2);
36135 if (arg1) (arg1)->refresh = arg2;
36136
36137 resultobj = SWIG_Py_Void();
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36145 PyObject *resultobj = 0;
36146 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36147 int result;
36148 void *argp1 = 0 ;
36149 int res1 = 0 ;
36150 PyObject *swig_obj[1] ;
36151
36152 if (!args) SWIG_fail;
36153 swig_obj[0] = args;
36154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36155 if (!SWIG_IsOK(res1)) {
36156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36157 }
36158 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36159 result = (int) ((arg1)->refresh);
36160 resultobj = SWIG_From_int(static_cast< int >(result));
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36168 PyObject *obj;
36169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36170 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36171 return SWIG_Py_Void();
36172 }
36173
36174 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36175 return SWIG_Python_InitShadowInstance(args);
36176 }
36177
36178 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36179 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36180 return 1;
36181 }
36182
36183
36184 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36185 PyObject *pyobj = 0;
36186
36187 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36188 return pyobj;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36193 PyObject *resultobj = 0;
36194 size_t arg1 = (size_t) 0 ;
36195 wxDisplay *result = 0 ;
36196 size_t val1 ;
36197 int ecode1 = 0 ;
36198 PyObject * obj0 = 0 ;
36199 char * kwnames[] = {
36200 (char *) "index", NULL
36201 };
36202
36203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36204 if (obj0) {
36205 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
36206 if (!SWIG_IsOK(ecode1)) {
36207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
36208 }
36209 arg1 = static_cast< size_t >(val1);
36210 }
36211 {
36212 PyThreadState* __tstate = wxPyBeginAllowThreads();
36213 result = (wxDisplay *)new wxDisplay(arg1);
36214 wxPyEndAllowThreads(__tstate);
36215 if (PyErr_Occurred()) SWIG_fail;
36216 }
36217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36218 return resultobj;
36219 fail:
36220 return NULL;
36221 }
36222
36223
36224 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36225 PyObject *resultobj = 0;
36226 wxDisplay *arg1 = (wxDisplay *) 0 ;
36227 void *argp1 = 0 ;
36228 int res1 = 0 ;
36229 PyObject *swig_obj[1] ;
36230
36231 if (!args) SWIG_fail;
36232 swig_obj[0] = args;
36233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36234 if (!SWIG_IsOK(res1)) {
36235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36236 }
36237 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36238 {
36239 PyThreadState* __tstate = wxPyBeginAllowThreads();
36240 delete arg1;
36241
36242 wxPyEndAllowThreads(__tstate);
36243 if (PyErr_Occurred()) SWIG_fail;
36244 }
36245 resultobj = SWIG_Py_Void();
36246 return resultobj;
36247 fail:
36248 return NULL;
36249 }
36250
36251
36252 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36253 PyObject *resultobj = 0;
36254 size_t result;
36255
36256 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36257 {
36258 PyThreadState* __tstate = wxPyBeginAllowThreads();
36259 result = (size_t)wxDisplay::GetCount();
36260 wxPyEndAllowThreads(__tstate);
36261 if (PyErr_Occurred()) SWIG_fail;
36262 }
36263 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
36264 return resultobj;
36265 fail:
36266 return NULL;
36267 }
36268
36269
36270 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36271 PyObject *resultobj = 0;
36272 wxPoint *arg1 = 0 ;
36273 int result;
36274 wxPoint temp1 ;
36275 PyObject * obj0 = 0 ;
36276 char * kwnames[] = {
36277 (char *) "pt", NULL
36278 };
36279
36280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36281 {
36282 arg1 = &temp1;
36283 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36284 }
36285 {
36286 PyThreadState* __tstate = wxPyBeginAllowThreads();
36287 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36288 wxPyEndAllowThreads(__tstate);
36289 if (PyErr_Occurred()) SWIG_fail;
36290 }
36291 resultobj = SWIG_From_int(static_cast< int >(result));
36292 return resultobj;
36293 fail:
36294 return NULL;
36295 }
36296
36297
36298 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36299 PyObject *resultobj = 0;
36300 wxWindow *arg1 = (wxWindow *) 0 ;
36301 int result;
36302 void *argp1 = 0 ;
36303 int res1 = 0 ;
36304 PyObject * obj0 = 0 ;
36305 char * kwnames[] = {
36306 (char *) "window", NULL
36307 };
36308
36309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36311 if (!SWIG_IsOK(res1)) {
36312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36313 }
36314 arg1 = reinterpret_cast< wxWindow * >(argp1);
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (int)wxDisplay::GetFromWindow(arg1);
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 resultobj = SWIG_From_int(static_cast< int >(result));
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36329 PyObject *resultobj = 0;
36330 wxDisplay *arg1 = (wxDisplay *) 0 ;
36331 bool result;
36332 void *argp1 = 0 ;
36333 int res1 = 0 ;
36334 PyObject *swig_obj[1] ;
36335
36336 if (!args) SWIG_fail;
36337 swig_obj[0] = args;
36338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36339 if (!SWIG_IsOK(res1)) {
36340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36341 }
36342 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36343 {
36344 PyThreadState* __tstate = wxPyBeginAllowThreads();
36345 result = (bool)((wxDisplay const *)arg1)->IsOk();
36346 wxPyEndAllowThreads(__tstate);
36347 if (PyErr_Occurred()) SWIG_fail;
36348 }
36349 {
36350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36351 }
36352 return resultobj;
36353 fail:
36354 return NULL;
36355 }
36356
36357
36358 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36359 PyObject *resultobj = 0;
36360 wxDisplay *arg1 = (wxDisplay *) 0 ;
36361 wxRect result;
36362 void *argp1 = 0 ;
36363 int res1 = 0 ;
36364 PyObject *swig_obj[1] ;
36365
36366 if (!args) SWIG_fail;
36367 swig_obj[0] = args;
36368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36369 if (!SWIG_IsOK(res1)) {
36370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36371 }
36372 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = ((wxDisplay const *)arg1)->GetGeometry();
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36380 return resultobj;
36381 fail:
36382 return NULL;
36383 }
36384
36385
36386 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36387 PyObject *resultobj = 0;
36388 wxDisplay *arg1 = (wxDisplay *) 0 ;
36389 wxRect result;
36390 void *argp1 = 0 ;
36391 int res1 = 0 ;
36392 PyObject *swig_obj[1] ;
36393
36394 if (!args) SWIG_fail;
36395 swig_obj[0] = args;
36396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36397 if (!SWIG_IsOK(res1)) {
36398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36399 }
36400 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36401 {
36402 PyThreadState* __tstate = wxPyBeginAllowThreads();
36403 result = ((wxDisplay const *)arg1)->GetClientArea();
36404 wxPyEndAllowThreads(__tstate);
36405 if (PyErr_Occurred()) SWIG_fail;
36406 }
36407 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36408 return resultobj;
36409 fail:
36410 return NULL;
36411 }
36412
36413
36414 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36415 PyObject *resultobj = 0;
36416 wxDisplay *arg1 = (wxDisplay *) 0 ;
36417 wxString 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_wxDisplay, 0 | 0 );
36425 if (!SWIG_IsOK(res1)) {
36426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36427 }
36428 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 result = ((wxDisplay const *)arg1)->GetName();
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 {
36436 #if wxUSE_UNICODE
36437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36438 #else
36439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36440 #endif
36441 }
36442 return resultobj;
36443 fail:
36444 return NULL;
36445 }
36446
36447
36448 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36449 PyObject *resultobj = 0;
36450 wxDisplay *arg1 = (wxDisplay *) 0 ;
36451 bool result;
36452 void *argp1 = 0 ;
36453 int res1 = 0 ;
36454 PyObject *swig_obj[1] ;
36455
36456 if (!args) SWIG_fail;
36457 swig_obj[0] = args;
36458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36459 if (!SWIG_IsOK(res1)) {
36460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36461 }
36462 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36466 wxPyEndAllowThreads(__tstate);
36467 if (PyErr_Occurred()) SWIG_fail;
36468 }
36469 {
36470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36471 }
36472 return resultobj;
36473 fail:
36474 return NULL;
36475 }
36476
36477
36478 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36479 PyObject *resultobj = 0;
36480 wxDisplay *arg1 = (wxDisplay *) 0 ;
36481 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36482 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36483 PyObject *result = 0 ;
36484 void *argp1 = 0 ;
36485 int res1 = 0 ;
36486 void *argp2 = 0 ;
36487 int res2 = 0 ;
36488 PyObject * obj0 = 0 ;
36489 PyObject * obj1 = 0 ;
36490 char * kwnames[] = {
36491 (char *) "self",(char *) "mode", NULL
36492 };
36493
36494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36496 if (!SWIG_IsOK(res1)) {
36497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36498 }
36499 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36500 if (obj1) {
36501 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36502 if (!SWIG_IsOK(res2)) {
36503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36504 }
36505 if (!argp2) {
36506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36507 }
36508 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36509 }
36510 {
36511 PyThreadState* __tstate = wxPyBeginAllowThreads();
36512 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36513 wxPyEndAllowThreads(__tstate);
36514 if (PyErr_Occurred()) SWIG_fail;
36515 }
36516 resultobj = result;
36517 return resultobj;
36518 fail:
36519 return NULL;
36520 }
36521
36522
36523 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36524 PyObject *resultobj = 0;
36525 wxDisplay *arg1 = (wxDisplay *) 0 ;
36526 wxVideoMode result;
36527 void *argp1 = 0 ;
36528 int res1 = 0 ;
36529 PyObject *swig_obj[1] ;
36530
36531 if (!args) SWIG_fail;
36532 swig_obj[0] = args;
36533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36534 if (!SWIG_IsOK(res1)) {
36535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36536 }
36537 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36538 {
36539 PyThreadState* __tstate = wxPyBeginAllowThreads();
36540 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36541 wxPyEndAllowThreads(__tstate);
36542 if (PyErr_Occurred()) SWIG_fail;
36543 }
36544 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36545 return resultobj;
36546 fail:
36547 return NULL;
36548 }
36549
36550
36551 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36552 PyObject *resultobj = 0;
36553 wxDisplay *arg1 = (wxDisplay *) 0 ;
36554 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36555 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36556 bool result;
36557 void *argp1 = 0 ;
36558 int res1 = 0 ;
36559 void *argp2 = 0 ;
36560 int res2 = 0 ;
36561 PyObject * obj0 = 0 ;
36562 PyObject * obj1 = 0 ;
36563 char * kwnames[] = {
36564 (char *) "self",(char *) "mode", NULL
36565 };
36566
36567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36569 if (!SWIG_IsOK(res1)) {
36570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36571 }
36572 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36573 if (obj1) {
36574 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36575 if (!SWIG_IsOK(res2)) {
36576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36577 }
36578 if (!argp2) {
36579 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36580 }
36581 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36582 }
36583 {
36584 PyThreadState* __tstate = wxPyBeginAllowThreads();
36585 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36586 wxPyEndAllowThreads(__tstate);
36587 if (PyErr_Occurred()) SWIG_fail;
36588 }
36589 {
36590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36591 }
36592 return resultobj;
36593 fail:
36594 return NULL;
36595 }
36596
36597
36598 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36599 PyObject *resultobj = 0;
36600 wxDisplay *arg1 = (wxDisplay *) 0 ;
36601 void *argp1 = 0 ;
36602 int res1 = 0 ;
36603 PyObject *swig_obj[1] ;
36604
36605 if (!args) SWIG_fail;
36606 swig_obj[0] = args;
36607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36608 if (!SWIG_IsOK(res1)) {
36609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36610 }
36611 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36612 {
36613 PyThreadState* __tstate = wxPyBeginAllowThreads();
36614 wxDisplay_ResetMode(arg1);
36615 wxPyEndAllowThreads(__tstate);
36616 if (PyErr_Occurred()) SWIG_fail;
36617 }
36618 resultobj = SWIG_Py_Void();
36619 return resultobj;
36620 fail:
36621 return NULL;
36622 }
36623
36624
36625 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36626 PyObject *obj;
36627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36628 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36629 return SWIG_Py_Void();
36630 }
36631
36632 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36633 return SWIG_Python_InitShadowInstance(args);
36634 }
36635
36636 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36637 PyObject *resultobj = 0;
36638 wxStandardPaths *result = 0 ;
36639
36640 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36641 {
36642 PyThreadState* __tstate = wxPyBeginAllowThreads();
36643 result = (wxStandardPaths *)wxStandardPaths_Get();
36644 wxPyEndAllowThreads(__tstate);
36645 if (PyErr_Occurred()) SWIG_fail;
36646 }
36647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36648 return resultobj;
36649 fail:
36650 return NULL;
36651 }
36652
36653
36654 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36655 PyObject *resultobj = 0;
36656 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36657 wxString result;
36658 void *argp1 = 0 ;
36659 int res1 = 0 ;
36660 PyObject *swig_obj[1] ;
36661
36662 if (!args) SWIG_fail;
36663 swig_obj[0] = args;
36664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36665 if (!SWIG_IsOK(res1)) {
36666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36667 }
36668 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 {
36676 #if wxUSE_UNICODE
36677 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36678 #else
36679 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36680 #endif
36681 }
36682 return resultobj;
36683 fail:
36684 return NULL;
36685 }
36686
36687
36688 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36689 PyObject *resultobj = 0;
36690 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36691 wxString result;
36692 void *argp1 = 0 ;
36693 int res1 = 0 ;
36694 PyObject *swig_obj[1] ;
36695
36696 if (!args) SWIG_fail;
36697 swig_obj[0] = args;
36698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36699 if (!SWIG_IsOK(res1)) {
36700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36701 }
36702 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 {
36710 #if wxUSE_UNICODE
36711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36712 #else
36713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36714 #endif
36715 }
36716 return resultobj;
36717 fail:
36718 return NULL;
36719 }
36720
36721
36722 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36723 PyObject *resultobj = 0;
36724 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36725 wxString result;
36726 void *argp1 = 0 ;
36727 int res1 = 0 ;
36728 PyObject *swig_obj[1] ;
36729
36730 if (!args) SWIG_fail;
36731 swig_obj[0] = args;
36732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36733 if (!SWIG_IsOK(res1)) {
36734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36735 }
36736 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36737 {
36738 PyThreadState* __tstate = wxPyBeginAllowThreads();
36739 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36740 wxPyEndAllowThreads(__tstate);
36741 if (PyErr_Occurred()) SWIG_fail;
36742 }
36743 {
36744 #if wxUSE_UNICODE
36745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36746 #else
36747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36748 #endif
36749 }
36750 return resultobj;
36751 fail:
36752 return NULL;
36753 }
36754
36755
36756 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36757 PyObject *resultobj = 0;
36758 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36759 wxString result;
36760 void *argp1 = 0 ;
36761 int res1 = 0 ;
36762 PyObject *swig_obj[1] ;
36763
36764 if (!args) SWIG_fail;
36765 swig_obj[0] = args;
36766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36767 if (!SWIG_IsOK(res1)) {
36768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36769 }
36770 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36771 {
36772 PyThreadState* __tstate = wxPyBeginAllowThreads();
36773 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 {
36778 #if wxUSE_UNICODE
36779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36780 #else
36781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36782 #endif
36783 }
36784 return resultobj;
36785 fail:
36786 return NULL;
36787 }
36788
36789
36790 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36791 PyObject *resultobj = 0;
36792 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36793 wxString result;
36794 void *argp1 = 0 ;
36795 int res1 = 0 ;
36796 PyObject *swig_obj[1] ;
36797
36798 if (!args) SWIG_fail;
36799 swig_obj[0] = args;
36800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36801 if (!SWIG_IsOK(res1)) {
36802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36803 }
36804 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36805 {
36806 PyThreadState* __tstate = wxPyBeginAllowThreads();
36807 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36808 wxPyEndAllowThreads(__tstate);
36809 if (PyErr_Occurred()) SWIG_fail;
36810 }
36811 {
36812 #if wxUSE_UNICODE
36813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36814 #else
36815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36816 #endif
36817 }
36818 return resultobj;
36819 fail:
36820 return NULL;
36821 }
36822
36823
36824 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36825 PyObject *resultobj = 0;
36826 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36827 wxString result;
36828 void *argp1 = 0 ;
36829 int res1 = 0 ;
36830 PyObject *swig_obj[1] ;
36831
36832 if (!args) SWIG_fail;
36833 swig_obj[0] = args;
36834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36835 if (!SWIG_IsOK(res1)) {
36836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36837 }
36838 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36839 {
36840 PyThreadState* __tstate = wxPyBeginAllowThreads();
36841 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
36842 wxPyEndAllowThreads(__tstate);
36843 if (PyErr_Occurred()) SWIG_fail;
36844 }
36845 {
36846 #if wxUSE_UNICODE
36847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36848 #else
36849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36850 #endif
36851 }
36852 return resultobj;
36853 fail:
36854 return NULL;
36855 }
36856
36857
36858 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36859 PyObject *resultobj = 0;
36860 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36861 wxString result;
36862 void *argp1 = 0 ;
36863 int res1 = 0 ;
36864 PyObject *swig_obj[1] ;
36865
36866 if (!args) SWIG_fail;
36867 swig_obj[0] = args;
36868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36869 if (!SWIG_IsOK(res1)) {
36870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36871 }
36872 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36873 {
36874 PyThreadState* __tstate = wxPyBeginAllowThreads();
36875 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
36876 wxPyEndAllowThreads(__tstate);
36877 if (PyErr_Occurred()) SWIG_fail;
36878 }
36879 {
36880 #if wxUSE_UNICODE
36881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36882 #else
36883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36884 #endif
36885 }
36886 return resultobj;
36887 fail:
36888 return NULL;
36889 }
36890
36891
36892 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36893 PyObject *resultobj = 0;
36894 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36895 wxString result;
36896 void *argp1 = 0 ;
36897 int res1 = 0 ;
36898 PyObject *swig_obj[1] ;
36899
36900 if (!args) SWIG_fail;
36901 swig_obj[0] = args;
36902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36903 if (!SWIG_IsOK(res1)) {
36904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36905 }
36906 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36907 {
36908 PyThreadState* __tstate = wxPyBeginAllowThreads();
36909 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
36910 wxPyEndAllowThreads(__tstate);
36911 if (PyErr_Occurred()) SWIG_fail;
36912 }
36913 {
36914 #if wxUSE_UNICODE
36915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36916 #else
36917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36918 #endif
36919 }
36920 return resultobj;
36921 fail:
36922 return NULL;
36923 }
36924
36925
36926 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36927 PyObject *resultobj = 0;
36928 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36929 wxString *arg2 = 0 ;
36930 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
36931 wxString result;
36932 void *argp1 = 0 ;
36933 int res1 = 0 ;
36934 bool temp2 = false ;
36935 int val3 ;
36936 int ecode3 = 0 ;
36937 PyObject * obj0 = 0 ;
36938 PyObject * obj1 = 0 ;
36939 PyObject * obj2 = 0 ;
36940 char * kwnames[] = {
36941 (char *) "self",(char *) "lang",(char *) "category", NULL
36942 };
36943
36944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36946 if (!SWIG_IsOK(res1)) {
36947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36948 }
36949 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36950 {
36951 arg2 = wxString_in_helper(obj1);
36952 if (arg2 == NULL) SWIG_fail;
36953 temp2 = true;
36954 }
36955 if (obj2) {
36956 ecode3 = SWIG_AsVal_int(obj2, &val3);
36957 if (!SWIG_IsOK(ecode3)) {
36958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
36959 }
36960 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
36961 }
36962 {
36963 PyThreadState* __tstate = wxPyBeginAllowThreads();
36964 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
36965 wxPyEndAllowThreads(__tstate);
36966 if (PyErr_Occurred()) SWIG_fail;
36967 }
36968 {
36969 #if wxUSE_UNICODE
36970 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36971 #else
36972 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36973 #endif
36974 }
36975 {
36976 if (temp2)
36977 delete arg2;
36978 }
36979 return resultobj;
36980 fail:
36981 {
36982 if (temp2)
36983 delete arg2;
36984 }
36985 return NULL;
36986 }
36987
36988
36989 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36990 PyObject *resultobj = 0;
36991 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36992 wxString result;
36993 void *argp1 = 0 ;
36994 int res1 = 0 ;
36995 PyObject *swig_obj[1] ;
36996
36997 if (!args) SWIG_fail;
36998 swig_obj[0] = args;
36999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37000 if (!SWIG_IsOK(res1)) {
37001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37002 }
37003 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37004 {
37005 PyThreadState* __tstate = wxPyBeginAllowThreads();
37006 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37007 wxPyEndAllowThreads(__tstate);
37008 if (PyErr_Occurred()) SWIG_fail;
37009 }
37010 {
37011 #if wxUSE_UNICODE
37012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37013 #else
37014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37015 #endif
37016 }
37017 return resultobj;
37018 fail:
37019 return NULL;
37020 }
37021
37022
37023 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37024 PyObject *resultobj = 0;
37025 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37026 wxString *arg2 = 0 ;
37027 void *argp1 = 0 ;
37028 int res1 = 0 ;
37029 bool temp2 = false ;
37030 PyObject * obj0 = 0 ;
37031 PyObject * obj1 = 0 ;
37032 char * kwnames[] = {
37033 (char *) "self",(char *) "prefix", NULL
37034 };
37035
37036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37038 if (!SWIG_IsOK(res1)) {
37039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37040 }
37041 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37042 {
37043 arg2 = wxString_in_helper(obj1);
37044 if (arg2 == NULL) SWIG_fail;
37045 temp2 = true;
37046 }
37047 {
37048 PyThreadState* __tstate = wxPyBeginAllowThreads();
37049 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37050 wxPyEndAllowThreads(__tstate);
37051 if (PyErr_Occurred()) SWIG_fail;
37052 }
37053 resultobj = SWIG_Py_Void();
37054 {
37055 if (temp2)
37056 delete arg2;
37057 }
37058 return resultobj;
37059 fail:
37060 {
37061 if (temp2)
37062 delete arg2;
37063 }
37064 return NULL;
37065 }
37066
37067
37068 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37069 PyObject *resultobj = 0;
37070 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37071 wxString result;
37072 void *argp1 = 0 ;
37073 int res1 = 0 ;
37074 PyObject *swig_obj[1] ;
37075
37076 if (!args) SWIG_fail;
37077 swig_obj[0] = args;
37078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37079 if (!SWIG_IsOK(res1)) {
37080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37081 }
37082 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37083 {
37084 PyThreadState* __tstate = wxPyBeginAllowThreads();
37085 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37086 wxPyEndAllowThreads(__tstate);
37087 if (PyErr_Occurred()) SWIG_fail;
37088 }
37089 {
37090 #if wxUSE_UNICODE
37091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37092 #else
37093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37094 #endif
37095 }
37096 return resultobj;
37097 fail:
37098 return NULL;
37099 }
37100
37101
37102 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37103 PyObject *obj;
37104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37105 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37106 return SWIG_Py_Void();
37107 }
37108
37109 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37110 PyObject *resultobj = 0;
37111 wxEventType arg1 ;
37112 wxPowerEvent *result = 0 ;
37113 int val1 ;
37114 int ecode1 = 0 ;
37115 PyObject * obj0 = 0 ;
37116 char * kwnames[] = {
37117 (char *) "evtType", NULL
37118 };
37119
37120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37121 ecode1 = SWIG_AsVal_int(obj0, &val1);
37122 if (!SWIG_IsOK(ecode1)) {
37123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37124 }
37125 arg1 = static_cast< wxEventType >(val1);
37126 {
37127 PyThreadState* __tstate = wxPyBeginAllowThreads();
37128 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37129 wxPyEndAllowThreads(__tstate);
37130 if (PyErr_Occurred()) SWIG_fail;
37131 }
37132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37133 return resultobj;
37134 fail:
37135 return NULL;
37136 }
37137
37138
37139 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37140 PyObject *resultobj = 0;
37141 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37142 void *argp1 = 0 ;
37143 int res1 = 0 ;
37144 PyObject *swig_obj[1] ;
37145
37146 if (!args) SWIG_fail;
37147 swig_obj[0] = args;
37148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37149 if (!SWIG_IsOK(res1)) {
37150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37151 }
37152 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 (arg1)->Veto();
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 resultobj = SWIG_Py_Void();
37160 return resultobj;
37161 fail:
37162 return NULL;
37163 }
37164
37165
37166 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37167 PyObject *resultobj = 0;
37168 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37169 bool result;
37170 void *argp1 = 0 ;
37171 int res1 = 0 ;
37172 PyObject *swig_obj[1] ;
37173
37174 if (!args) SWIG_fail;
37175 swig_obj[0] = args;
37176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37177 if (!SWIG_IsOK(res1)) {
37178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37179 }
37180 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37181 {
37182 PyThreadState* __tstate = wxPyBeginAllowThreads();
37183 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37184 wxPyEndAllowThreads(__tstate);
37185 if (PyErr_Occurred()) SWIG_fail;
37186 }
37187 {
37188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37189 }
37190 return resultobj;
37191 fail:
37192 return NULL;
37193 }
37194
37195
37196 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37197 PyObject *obj;
37198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37199 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37200 return SWIG_Py_Void();
37201 }
37202
37203 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37204 return SWIG_Python_InitShadowInstance(args);
37205 }
37206
37207 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37208 PyObject *resultobj = 0;
37209 wxPowerType result;
37210
37211 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 result = (wxPowerType)wxGetPowerType();
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 resultobj = SWIG_From_int(static_cast< int >(result));
37219 return resultobj;
37220 fail:
37221 return NULL;
37222 }
37223
37224
37225 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37226 PyObject *resultobj = 0;
37227 wxBatteryState result;
37228
37229 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37230 {
37231 PyThreadState* __tstate = wxPyBeginAllowThreads();
37232 result = (wxBatteryState)wxGetBatteryState();
37233 wxPyEndAllowThreads(__tstate);
37234 if (PyErr_Occurred()) SWIG_fail;
37235 }
37236 resultobj = SWIG_From_int(static_cast< int >(result));
37237 return resultobj;
37238 fail:
37239 return NULL;
37240 }
37241
37242
37243 static PyMethodDef SwigMethods[] = {
37244 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
37245 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
37246 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
37247 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
37248 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
37249 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
37250 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
37251 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
37252 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37253 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37254 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37255 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37256 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
37257 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
37258 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
37259 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
37260 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
37261 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
37262 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
37263 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
37264 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37265 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37266 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
37267 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
37268 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
37269 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
37270 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
37271 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
37272 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
37273 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
37274 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
37275 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
37276 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
37277 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
37278 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
37279 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
37280 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
37281 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37282 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37283 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
37284 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
37285 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
37286 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
37287 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
37288 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
37289 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
37290 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
37291 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
37292 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
37293 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
37294 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37295 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37296 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37297 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37298 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37299 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37300 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
37301 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
37302 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
37303 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37304 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
37305 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
37306 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
37307 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
37308 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
37309 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
37310 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
37311 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
37312 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
37313 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37314 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
37315 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37316 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
37317 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
37318 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
37319 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37320 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37321 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
37322 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
37323 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
37324 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
37325 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
37326 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
37327 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
37328 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
37329 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
37330 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
37331 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
37332 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
37333 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
37334 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
37335 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
37336 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
37337 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
37338 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37339 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
37340 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
37341 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
37342 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37343 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
37344 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
37345 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
37346 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
37347 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
37348 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
37349 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
37350 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
37351 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
37352 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
37353 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
37354 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
37355 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
37356 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
37357 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
37358 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
37359 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
37360 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
37361 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
37362 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
37363 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
37364 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
37365 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
37366 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
37367 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
37368 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
37369 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
37370 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
37371 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
37372 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
37373 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
37374 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
37375 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
37376 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
37377 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
37378 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
37379 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37380 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
37381 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
37382 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
37383 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
37384 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
37385 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37386 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
37387 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
37388 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
37389 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
37390 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
37391 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
37392 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
37393 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37394 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
37395 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
37396 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
37397 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
37398 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37399 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
37400 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
37401 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
37402 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
37403 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
37404 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37405 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
37406 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37407 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37408 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
37409 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37410 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37411 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
37412 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
37413 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
37414 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37415 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
37416 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
37417 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
37418 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
37419 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
37420 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
37421 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
37422 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37423 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
37424 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
37425 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
37426 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
37427 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37428 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37429 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
37430 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
37431 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
37432 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
37433 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
37434 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
37435 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
37436 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
37437 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
37438 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
37439 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
37440 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
37441 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
37442 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
37443 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
37444 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37445 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37446 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
37447 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
37448 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
37449 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
37450 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
37451 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
37452 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
37453 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
37454 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
37455 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
37456 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
37457 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
37458 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
37459 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37460 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37461 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
37462 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
37463 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
37464 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37465 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
37466 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
37467 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37468 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
37469 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
37470 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37471 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
37472 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
37473 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
37474 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
37475 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
37476 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
37477 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
37478 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
37479 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37480 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
37481 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
37482 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
37483 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
37484 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
37485 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37486 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
37487 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
37488 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
37489 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
37490 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
37491 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
37492 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
37493 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
37494 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
37495 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
37496 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37497 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
37498 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
37499 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37500 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
37501 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
37502 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
37503 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
37504 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37505 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37506 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37507 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
37508 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
37509 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
37510 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
37511 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
37512 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37513 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
37514 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
37515 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
37516 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
37517 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
37518 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
37519 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
37520 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
37521 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
37522 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
37523 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
37524 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
37525 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
37526 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
37527 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
37528 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37529 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37530 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
37531 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
37532 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
37533 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37534 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
37535 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
37536 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
37537 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
37538 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37539 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
37540 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
37541 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
37542 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
37543 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
37544 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
37545 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
37546 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
37547 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
37548 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
37549 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
37550 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
37551 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
37552 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37553 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37554 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
37555 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37556 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
37557 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
37558 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
37559 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
37560 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
37561 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37562 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
37563 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
37564 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
37565 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
37566 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
37567 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37568 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
37569 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
37570 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37571 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37572 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
37573 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
37574 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37575 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
37576 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
37577 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
37578 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
37579 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
37580 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
37581 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
37582 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
37583 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
37584 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
37585 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
37586 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
37587 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
37588 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37589 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
37590 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
37591 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
37592 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
37593 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
37594 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
37595 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
37596 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
37597 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
37598 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37599 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
37600 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
37601 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
37602 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
37603 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
37604 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
37605 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
37606 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
37607 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
37608 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
37609 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
37610 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
37611 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
37612 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
37613 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
37614 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
37615 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
37616 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
37617 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
37618 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
37619 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
37620 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
37621 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
37622 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
37623 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
37624 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
37625 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
37626 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
37627 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
37628 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
37629 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
37630 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
37631 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
37632 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
37633 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
37634 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
37635 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
37636 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
37637 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
37638 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
37639 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
37640 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
37641 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
37642 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
37643 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
37644 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
37645 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37646 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
37647 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
37648 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
37649 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
37650 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
37651 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
37652 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
37653 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
37654 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37655 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37656 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
37657 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
37658 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
37659 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
37660 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
37661 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
37662 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
37663 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
37664 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
37665 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37666 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
37667 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37668 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37669 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
37670 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
37671 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
37672 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
37673 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
37674 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
37675 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37676 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
37677 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
37678 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
37679 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37680 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
37681 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
37682 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
37683 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
37684 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
37685 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
37686 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
37687 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
37688 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
37689 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
37690 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
37691 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
37692 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
37693 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
37694 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
37695 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
37696 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
37697 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
37698 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
37699 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
37700 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37701 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37702 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
37703 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37704 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37705 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
37706 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37707 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
37708 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
37709 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
37710 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
37711 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
37712 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
37713 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
37714 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
37715 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
37716 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
37717 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
37718 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
37719 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
37720 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
37721 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
37722 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
37723 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
37724 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
37725 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
37726 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37727 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37728 { (char *)"ArtProvider_InsertProvider", (PyCFunction) _wrap_ArtProvider_InsertProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37729 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
37730 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37731 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37732 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37733 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
37734 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
37735 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
37736 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
37737 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
37738 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37739 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
37740 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
37741 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
37742 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
37743 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
37744 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
37745 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37746 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
37747 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37748 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
37749 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
37750 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37751 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37752 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37753 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
37754 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
37755 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
37756 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37757 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
37758 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
37759 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
37760 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37761 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
37762 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
37763 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37764 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37765 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37766 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37767 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
37768 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37769 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
37770 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
37771 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
37772 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37773 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
37774 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
37775 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
37776 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
37777 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
37778 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
37779 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
37780 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
37781 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
37782 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
37783 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
37784 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
37785 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
37786 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
37787 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
37788 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
37789 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
37790 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
37791 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
37792 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
37793 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37794 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37795 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
37796 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37797 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
37798 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
37799 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37800 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
37801 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
37802 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
37803 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37804 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
37805 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
37806 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
37807 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
37808 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
37809 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
37810 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
37811 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
37812 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
37813 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
37814 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37815 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37816 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37817 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
37818 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37819 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
37820 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
37821 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37822 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37823 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37824 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37825 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
37826 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37827 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37828 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37829 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37830 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37831 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37832 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37833 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37834 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37835 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37836 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37837 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37838 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37839 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37840 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37841 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37842 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37843 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37844 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37845 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37846 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37847 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37848 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37849 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
37850 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
37851 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
37852 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
37853 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
37854 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37855 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37856 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37857 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37858 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37859 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37860 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37861 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37862 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37863 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37864 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
37865 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
37866 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
37867 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37868 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37869 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37870 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37871 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37872 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37873 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37874 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37875 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37876 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37877 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37878 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
37879 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37880 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
37881 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37882 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37883 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37884 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
37885 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
37886 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
37887 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
37888 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
37889 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
37890 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
37891 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37892 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
37893 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
37894 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
37895 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
37896 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37897 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37898 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37899 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37900 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37901 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37902 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
37903 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37904 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37905 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
37906 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
37907 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37908 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
37909 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
37910 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
37911 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
37912 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
37913 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
37914 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
37915 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
37916 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
37917 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
37918 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
37919 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
37920 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
37921 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
37922 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37923 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
37924 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37925 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
37926 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37927 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
37928 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37929 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37930 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37931 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
37932 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
37933 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37934 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37935 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37936 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
37937 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37938 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37939 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37940 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37941 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37942 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37943 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37944 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37945 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37946 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37947 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
37948 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
37949 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
37950 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37951 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
37952 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37953 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
37954 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
37955 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
37956 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
37957 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
37958 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
37959 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37960 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
37961 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
37962 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37963 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
37964 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37965 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
37966 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37967 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
37968 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
37969 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
37970 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
37971 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
37972 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
37973 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
37974 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
37975 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
37976 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
37977 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
37978 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
37979 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
37980 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
37981 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37982 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37983 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
37984 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37985 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37986 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37987 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
37988 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37989 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37990 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37991 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37992 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37993 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37994 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37995 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
37996 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
37997 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
37998 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
37999 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
38000 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
38001 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38002 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38003 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
38004 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
38005 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
38006 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
38007 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
38008 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
38009 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
38010 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
38011 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
38012 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
38013 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38014 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
38015 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38016 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
38017 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
38018 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
38019 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38020 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
38021 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38022 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
38023 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38024 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
38025 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
38026 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38027 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
38028 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
38029 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38030 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38031 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
38032 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
38033 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
38034 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38035 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
38036 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
38037 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
38038 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38039 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
38040 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
38041 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
38042 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
38043 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
38044 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38045 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38046 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
38047 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
38048 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38049 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
38050 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
38051 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
38052 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
38053 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38054 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38055 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
38056 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
38057 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
38058 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
38059 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
38060 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
38061 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
38062 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
38063 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38064 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
38065 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
38066 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
38067 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
38068 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38069 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
38070 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
38071 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
38072 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
38073 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
38074 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
38075 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
38076 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
38077 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
38078 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38079 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
38080 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38081 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
38082 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
38083 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38084 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
38085 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
38086 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
38087 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
38088 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38089 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
38090 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
38091 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38092 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38093 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38094 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
38095 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38096 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
38097 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
38098 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
38099 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
38100 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
38101 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
38102 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38103 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
38104 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38105 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38106 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
38107 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38108 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38109 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
38110 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
38111 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
38112 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38113 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
38114 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38115 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38116 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
38117 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38118 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38119 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
38120 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
38121 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
38122 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
38123 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
38124 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
38125 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
38126 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
38127 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38128 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38129 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
38130 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
38131 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
38132 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
38133 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
38134 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
38135 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
38136 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
38137 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
38138 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
38139 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
38140 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
38141 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
38142 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
38143 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
38144 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
38145 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
38146 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
38147 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
38148 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38149 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38150 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
38151 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
38152 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
38153 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
38154 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
38155 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
38156 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
38157 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
38158 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
38159 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
38160 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
38161 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
38162 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
38163 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
38164 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
38165 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
38166 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
38167 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
38168 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
38169 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
38170 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
38171 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
38172 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
38173 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
38174 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
38175 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
38176 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
38177 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
38178 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
38179 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
38180 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
38181 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
38182 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
38183 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
38184 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
38185 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
38186 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
38187 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
38188 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
38189 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
38190 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
38191 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
38192 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
38193 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
38194 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
38195 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
38196 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
38197 { NULL, NULL, 0, NULL }
38198 };
38199
38200
38201 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38202
38203 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
38204 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
38205 }
38206 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
38207 return (void *)((wxEvent *) ((wxMenuEvent *) x));
38208 }
38209 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
38210 return (void *)((wxEvent *) ((wxCloseEvent *) x));
38211 }
38212 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
38213 return (void *)((wxEvent *) ((wxMouseEvent *) x));
38214 }
38215 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
38216 return (void *)((wxEvent *) ((wxEraseEvent *) x));
38217 }
38218 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
38219 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
38220 }
38221 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
38222 return (void *)((wxEvent *) ((wxTimerEvent *) x));
38223 }
38224 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
38225 return (void *)((wxEvent *) ((wxPowerEvent *) x));
38226 }
38227 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
38228 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
38229 }
38230 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
38231 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
38232 }
38233 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
38234 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
38235 }
38236 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
38237 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
38238 }
38239 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
38240 return (void *)((wxEvent *) ((wxPyEvent *) x));
38241 }
38242 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
38243 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
38244 }
38245 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
38246 return (void *)((wxEvent *) ((wxIdleEvent *) x));
38247 }
38248 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
38249 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
38250 }
38251 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
38252 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
38253 }
38254 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
38255 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
38256 }
38257 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
38258 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
38259 }
38260 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
38261 return (void *)((wxEvent *) ((wxActivateEvent *) x));
38262 }
38263 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
38264 return (void *)((wxEvent *) ((wxSizeEvent *) x));
38265 }
38266 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
38267 return (void *)((wxEvent *) ((wxMoveEvent *) x));
38268 }
38269 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
38270 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
38271 }
38272 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
38273 return (void *)((wxEvent *) ((wxPaintEvent *) x));
38274 }
38275 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
38276 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
38277 }
38278 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
38279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
38280 }
38281 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
38282 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
38283 }
38284 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
38285 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
38286 }
38287 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
38288 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
38289 }
38290 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
38291 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38292 }
38293 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
38294 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
38295 }
38296 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
38297 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
38298 }
38299 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
38300 return (void *)((wxEvent *) ((wxFocusEvent *) x));
38301 }
38302 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
38303 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
38304 }
38305 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
38306 return (void *)((wxEvent *) ((wxProcessEvent *) x));
38307 }
38308 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
38309 return (void *)((wxEvent *) ((wxShowEvent *) x));
38310 }
38311 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
38312 return (void *)((wxEvent *) ((wxCommandEvent *) x));
38313 }
38314 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
38315 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
38316 }
38317 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
38318 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38319 }
38320 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
38321 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
38322 }
38323 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
38324 return (void *)((wxEvent *) ((wxKeyEvent *) x));
38325 }
38326 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
38327 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
38328 }
38329 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
38330 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
38331 }
38332 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
38333 return (void *)((wxConfigBase *) ((wxConfig *) x));
38334 }
38335 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
38336 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38337 }
38338 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
38339 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
38340 }
38341 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
38342 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
38343 }
38344 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
38345 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38346 }
38347 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
38348 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
38349 }
38350 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
38351 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
38352 }
38353 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
38354 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
38355 }
38356 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
38357 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38358 }
38359 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
38360 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38361 }
38362 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
38363 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
38364 }
38365 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
38366 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
38367 }
38368 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
38369 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
38370 }
38371 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
38372 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38373 }
38374 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
38375 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38376 }
38377 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38378 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
38379 }
38380 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38381 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
38382 }
38383 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38384 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38385 }
38386 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38387 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38388 }
38389 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
38390 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
38391 }
38392 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
38393 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
38394 }
38395 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
38396 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38397 }
38398 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
38399 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
38400 }
38401 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
38402 return (void *)((wxEvtHandler *) ((wxWindow *) x));
38403 }
38404 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
38405 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38406 }
38407 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
38408 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
38409 }
38410 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
38411 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
38412 }
38413 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
38414 return (void *)((wxEvtHandler *) ((wxValidator *) x));
38415 }
38416 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
38417 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
38418 }
38419 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
38420 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
38421 }
38422 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
38423 return (void *)((wxEvtHandler *) ((wxMenu *) x));
38424 }
38425 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
38426 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
38427 }
38428 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
38429 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
38430 }
38431 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
38432 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
38433 }
38434 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
38435 return (void *)((wxObject *) ((wxSizerItem *) x));
38436 }
38437 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
38438 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
38439 }
38440 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
38441 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
38442 }
38443 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
38444 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
38445 }
38446 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
38447 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
38448 }
38449 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
38450 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
38451 }
38452 static void *_p_wxSizerTo_p_wxObject(void *x) {
38453 return (void *)((wxObject *) ((wxSizer *) x));
38454 }
38455 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
38456 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
38457 }
38458 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
38459 return (void *)((wxObject *) ((wxFileHistory *) x));
38460 }
38461 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
38462 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
38463 }
38464 static void *_p_wxEventTo_p_wxObject(void *x) {
38465 return (void *)((wxObject *) ((wxEvent *) x));
38466 }
38467 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
38468 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
38469 }
38470 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
38471 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
38472 }
38473 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
38474 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
38475 }
38476 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
38477 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
38478 }
38479 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
38480 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
38481 }
38482 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
38483 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
38484 }
38485 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
38486 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
38487 }
38488 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
38489 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
38490 }
38491 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
38492 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38493 }
38494 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
38495 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
38496 }
38497 static void *_p_wxControlTo_p_wxObject(void *x) {
38498 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
38499 }
38500 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
38501 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
38502 }
38503 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
38504 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
38505 }
38506 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
38507 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
38508 }
38509 static void *_p_wxFSFileTo_p_wxObject(void *x) {
38510 return (void *)((wxObject *) ((wxFSFile *) x));
38511 }
38512 static void *_p_wxClipboardTo_p_wxObject(void *x) {
38513 return (void *)((wxObject *) ((wxClipboard *) x));
38514 }
38515 static void *_p_wxPySizerTo_p_wxObject(void *x) {
38516 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
38517 }
38518 static void *_p_wxPyEventTo_p_wxObject(void *x) {
38519 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
38520 }
38521 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
38522 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
38523 }
38524 static void *_p_wxShowEventTo_p_wxObject(void *x) {
38525 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
38526 }
38527 static void *_p_wxToolTipTo_p_wxObject(void *x) {
38528 return (void *)((wxObject *) ((wxToolTip *) x));
38529 }
38530 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
38531 return (void *)((wxObject *) ((wxMenuItem *) x));
38532 }
38533 static void *_p_wxDateEventTo_p_wxObject(void *x) {
38534 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
38535 }
38536 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
38537 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
38538 }
38539 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
38540 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
38541 }
38542 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
38543 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
38544 }
38545 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
38546 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
38547 }
38548 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
38549 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
38550 }
38551 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
38552 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
38553 }
38554 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
38555 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
38556 }
38557 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
38558 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
38559 }
38560 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
38561 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
38562 }
38563 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
38564 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
38565 }
38566 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
38567 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
38568 }
38569 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
38570 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
38571 }
38572 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
38573 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
38574 }
38575 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
38576 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
38577 }
38578 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
38579 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
38580 }
38581 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
38582 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
38583 }
38584 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
38585 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
38586 }
38587 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
38588 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
38589 }
38590 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
38591 return (void *)((wxObject *) ((wxImageHandler *) x));
38592 }
38593 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
38594 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
38595 }
38596 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
38597 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
38598 }
38599 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
38600 return (void *)((wxObject *) ((wxEvtHandler *) x));
38601 }
38602 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
38603 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
38604 }
38605 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
38606 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
38607 }
38608 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
38609 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
38610 }
38611 static void *_p_wxImageTo_p_wxObject(void *x) {
38612 return (void *)((wxObject *) ((wxImage *) x));
38613 }
38614 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
38615 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
38616 }
38617 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
38618 return (void *)((wxObject *) ((wxSystemOptions *) x));
38619 }
38620 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
38621 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
38622 }
38623 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
38624 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38625 }
38626 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
38627 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
38628 }
38629 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
38630 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
38631 }
38632 static void *_p_wxWindowTo_p_wxObject(void *x) {
38633 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
38634 }
38635 static void *_p_wxMenuTo_p_wxObject(void *x) {
38636 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
38637 }
38638 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
38639 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
38640 }
38641 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
38642 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
38643 }
38644 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
38645 return (void *)((wxObject *) ((wxFileSystem *) x));
38646 }
38647 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
38648 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
38649 }
38650 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
38651 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
38652 }
38653 static void *_p_wxPyAppTo_p_wxObject(void *x) {
38654 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
38655 }
38656 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
38657 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
38658 }
38659 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
38660 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
38661 }
38662 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
38663 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
38664 }
38665 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
38666 return (void *)((wxObject *) ((wxBusyInfo *) x));
38667 }
38668 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
38669 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
38670 }
38671 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
38672 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
38673 }
38674 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
38675 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
38676 }
38677 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
38678 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
38679 }
38680 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
38681 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
38682 }
38683 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
38684 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
38685 }
38686 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
38687 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38688 }
38689 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
38690 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
38691 }
38692 static void *_p_wxValidatorTo_p_wxObject(void *x) {
38693 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
38694 }
38695 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
38696 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
38697 }
38698 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
38699 return (void *)((wxLog *) ((wxLogBuffer *) x));
38700 }
38701 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
38702 return (void *)((wxLog *) ((wxLogStderr *) x));
38703 }
38704 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
38705 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
38706 }
38707 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
38708 return (void *)((wxLog *) ((wxLogWindow *) x));
38709 }
38710 static void *_p_wxLogChainTo_p_wxLog(void *x) {
38711 return (void *)((wxLog *) ((wxLogChain *) x));
38712 }
38713 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
38714 return (void *)((wxLog *) ((wxLogGui *) x));
38715 }
38716 static void *_p_wxPyLogTo_p_wxLog(void *x) {
38717 return (void *)((wxLog *) ((wxPyLog *) x));
38718 }
38719 static void *_p_wxControlTo_p_wxWindow(void *x) {
38720 return (void *)((wxWindow *) ((wxControl *) x));
38721 }
38722 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
38723 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
38724 }
38725 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
38726 return (void *)((wxWindow *) ((wxMenuBar *) x));
38727 }
38728 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
38729 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
38730 }
38731 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
38732 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
38733 }
38734 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38735 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};
38736 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
38737 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
38738 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
38739 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
38740 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38741 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
38742 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
38743 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
38744 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
38745 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
38746 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
38747 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
38748 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
38749 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
38750 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
38751 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
38752 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
38753 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
38754 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
38755 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
38756 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
38757 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
38758 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
38759 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
38760 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
38761 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
38762 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
38763 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
38764 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
38765 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
38766 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
38767 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
38768 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
38769 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
38770 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
38771 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
38772 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
38773 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
38774 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
38775 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
38776 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
38777 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
38778 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
38779 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
38780 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
38781 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
38782 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
38783 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
38784 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
38785 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
38786 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
38787 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
38788 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
38789 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
38790 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
38791 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
38792 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
38793 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
38794 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
38795 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
38796 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
38797 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
38798 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
38799 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
38800 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
38801 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
38802 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
38803 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
38804 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
38805 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
38806 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
38807 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
38808 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
38809 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
38810 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
38811 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
38812 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
38813 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
38814 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
38815 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
38816 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
38817 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
38818 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
38819 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
38820 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
38821 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
38822 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
38823 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
38824 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
38825 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
38826 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
38827 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
38828 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
38829 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
38830 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
38831 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
38832 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
38833 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
38834 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
38835 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
38836 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
38837 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
38838 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
38839 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
38840 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
38841 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
38842 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
38843 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
38844 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
38845 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
38846 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
38847 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
38848 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
38849 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
38850 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
38851 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
38852 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
38853 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
38854 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
38855 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
38856 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
38857 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
38858 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
38859 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
38860 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
38861 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
38862 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
38863 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
38864 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
38865 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
38866 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
38867 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
38868 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
38869 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
38870 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
38871 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
38872 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
38873 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
38874 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
38875 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
38876 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
38877 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
38878 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
38879 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
38880 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
38881 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
38882 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
38883 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
38884 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
38885 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
38886 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
38887 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
38888 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
38889 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
38890 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
38891 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
38892 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
38893 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
38894 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
38895 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
38896 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
38897 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
38898 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
38899 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
38900 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
38901 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
38902 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
38903 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
38904 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
38905 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
38906
38907 static swig_type_info *swig_type_initial[] = {
38908 &_swigt__p_char,
38909 &_swigt__p_form_ops_t,
38910 &_swigt__p_int,
38911 &_swigt__p_unsigned_char,
38912 &_swigt__p_unsigned_int,
38913 &_swigt__p_unsigned_long,
38914 &_swigt__p_void,
38915 &_swigt__p_wxANIHandler,
38916 &_swigt__p_wxAcceleratorTable,
38917 &_swigt__p_wxActivateEvent,
38918 &_swigt__p_wxArrayString,
38919 &_swigt__p_wxBMPHandler,
38920 &_swigt__p_wxBitmap,
38921 &_swigt__p_wxBitmapDataObject,
38922 &_swigt__p_wxBoxSizer,
38923 &_swigt__p_wxBusyCursor,
38924 &_swigt__p_wxBusyInfo,
38925 &_swigt__p_wxCURHandler,
38926 &_swigt__p_wxCaret,
38927 &_swigt__p_wxChar,
38928 &_swigt__p_wxChildFocusEvent,
38929 &_swigt__p_wxClipboard,
38930 &_swigt__p_wxClipboardLocker,
38931 &_swigt__p_wxClipboardTextEvent,
38932 &_swigt__p_wxCloseEvent,
38933 &_swigt__p_wxColour,
38934 &_swigt__p_wxCommandEvent,
38935 &_swigt__p_wxConfig,
38936 &_swigt__p_wxConfigBase,
38937 &_swigt__p_wxConfigPathChanger,
38938 &_swigt__p_wxContextMenuEvent,
38939 &_swigt__p_wxControl,
38940 &_swigt__p_wxControlWithItems,
38941 &_swigt__p_wxCursor,
38942 &_swigt__p_wxCustomDataObject,
38943 &_swigt__p_wxDC,
38944 &_swigt__p_wxDataFormat,
38945 &_swigt__p_wxDataObject,
38946 &_swigt__p_wxDataObjectComposite,
38947 &_swigt__p_wxDataObjectSimple,
38948 &_swigt__p_wxDateEvent,
38949 &_swigt__p_wxDateSpan,
38950 &_swigt__p_wxDateTime,
38951 &_swigt__p_wxDateTime__TimeZone,
38952 &_swigt__p_wxDisplay,
38953 &_swigt__p_wxDisplayChangedEvent,
38954 &_swigt__p_wxDropFilesEvent,
38955 &_swigt__p_wxDuplexMode,
38956 &_swigt__p_wxEraseEvent,
38957 &_swigt__p_wxEvent,
38958 &_swigt__p_wxEvtHandler,
38959 &_swigt__p_wxFSFile,
38960 &_swigt__p_wxFileConfig,
38961 &_swigt__p_wxFileDataObject,
38962 &_swigt__p_wxFileHistory,
38963 &_swigt__p_wxFileSystem,
38964 &_swigt__p_wxFileType,
38965 &_swigt__p_wxFileTypeInfo,
38966 &_swigt__p_wxFlexGridSizer,
38967 &_swigt__p_wxFocusEvent,
38968 &_swigt__p_wxFont,
38969 &_swigt__p_wxFrame,
38970 &_swigt__p_wxGBSizerItem,
38971 &_swigt__p_wxGIFHandler,
38972 &_swigt__p_wxGridBagSizer,
38973 &_swigt__p_wxGridSizer,
38974 &_swigt__p_wxICOHandler,
38975 &_swigt__p_wxIcon,
38976 &_swigt__p_wxIconizeEvent,
38977 &_swigt__p_wxIdleEvent,
38978 &_swigt__p_wxImage,
38979 &_swigt__p_wxImageHandler,
38980 &_swigt__p_wxIndividualLayoutConstraint,
38981 &_swigt__p_wxInitDialogEvent,
38982 &_swigt__p_wxJPEGHandler,
38983 &_swigt__p_wxJoystick,
38984 &_swigt__p_wxJoystickEvent,
38985 &_swigt__p_wxKeyEvent,
38986 &_swigt__p_wxKillError,
38987 &_swigt__p_wxLayoutConstraints,
38988 &_swigt__p_wxLog,
38989 &_swigt__p_wxLogBuffer,
38990 &_swigt__p_wxLogChain,
38991 &_swigt__p_wxLogGui,
38992 &_swigt__p_wxLogNull,
38993 &_swigt__p_wxLogStderr,
38994 &_swigt__p_wxLogTextCtrl,
38995 &_swigt__p_wxLogWindow,
38996 &_swigt__p_wxMaximizeEvent,
38997 &_swigt__p_wxMenu,
38998 &_swigt__p_wxMenuBar,
38999 &_swigt__p_wxMenuEvent,
39000 &_swigt__p_wxMenuItem,
39001 &_swigt__p_wxMetafileDataObject,
39002 &_swigt__p_wxMimeTypesManager,
39003 &_swigt__p_wxMouseCaptureChangedEvent,
39004 &_swigt__p_wxMouseCaptureLostEvent,
39005 &_swigt__p_wxMouseEvent,
39006 &_swigt__p_wxMouseState,
39007 &_swigt__p_wxMoveEvent,
39008 &_swigt__p_wxMutexGuiLocker,
39009 &_swigt__p_wxNavigationKeyEvent,
39010 &_swigt__p_wxNcPaintEvent,
39011 &_swigt__p_wxNotifyEvent,
39012 &_swigt__p_wxObject,
39013 &_swigt__p_wxOutputStream,
39014 &_swigt__p_wxPCXHandler,
39015 &_swigt__p_wxPNGHandler,
39016 &_swigt__p_wxPNMHandler,
39017 &_swigt__p_wxPaintEvent,
39018 &_swigt__p_wxPaletteChangedEvent,
39019 &_swigt__p_wxPaperSize,
39020 &_swigt__p_wxPlatformInfo,
39021 &_swigt__p_wxPoint,
39022 &_swigt__p_wxPowerEvent,
39023 &_swigt__p_wxProcessEvent,
39024 &_swigt__p_wxPyApp,
39025 &_swigt__p_wxPyArtProvider,
39026 &_swigt__p_wxPyBitmapDataObject,
39027 &_swigt__p_wxPyCommandEvent,
39028 &_swigt__p_wxPyDataObjectSimple,
39029 &_swigt__p_wxPyDropSource,
39030 &_swigt__p_wxPyDropTarget,
39031 &_swigt__p_wxPyEvent,
39032 &_swigt__p_wxPyFileDropTarget,
39033 &_swigt__p_wxPyImageHandler,
39034 &_swigt__p_wxPyLog,
39035 &_swigt__p_wxPyProcess,
39036 &_swigt__p_wxPySizer,
39037 &_swigt__p_wxPyTextDataObject,
39038 &_swigt__p_wxPyTextDropTarget,
39039 &_swigt__p_wxPyTimer,
39040 &_swigt__p_wxPyTipProvider,
39041 &_swigt__p_wxPyValidator,
39042 &_swigt__p_wxQueryNewPaletteEvent,
39043 &_swigt__p_wxRect,
39044 &_swigt__p_wxScrollEvent,
39045 &_swigt__p_wxScrollWinEvent,
39046 &_swigt__p_wxSetCursorEvent,
39047 &_swigt__p_wxShowEvent,
39048 &_swigt__p_wxSingleInstanceChecker,
39049 &_swigt__p_wxSize,
39050 &_swigt__p_wxSizeEvent,
39051 &_swigt__p_wxSizer,
39052 &_swigt__p_wxSizerItem,
39053 &_swigt__p_wxSound,
39054 &_swigt__p_wxStandardPaths,
39055 &_swigt__p_wxStaticBoxSizer,
39056 &_swigt__p_wxStdDialogButtonSizer,
39057 &_swigt__p_wxStopWatch,
39058 &_swigt__p_wxString,
39059 &_swigt__p_wxSysColourChangedEvent,
39060 &_swigt__p_wxSystemOptions,
39061 &_swigt__p_wxSystemSettings,
39062 &_swigt__p_wxTIFFHandler,
39063 &_swigt__p_wxTextCtrl,
39064 &_swigt__p_wxTextDataObject,
39065 &_swigt__p_wxTimeSpan,
39066 &_swigt__p_wxTimer,
39067 &_swigt__p_wxTimerEvent,
39068 &_swigt__p_wxTimerRunner,
39069 &_swigt__p_wxTipProvider,
39070 &_swigt__p_wxToolTip,
39071 &_swigt__p_wxURLDataObject,
39072 &_swigt__p_wxUpdateUIEvent,
39073 &_swigt__p_wxValidator,
39074 &_swigt__p_wxVideoMode,
39075 &_swigt__p_wxWindow,
39076 &_swigt__p_wxWindowCreateEvent,
39077 &_swigt__p_wxWindowDestroyEvent,
39078 &_swigt__p_wxWindowDisabler,
39079 &_swigt__p_wxXPMHandler,
39080 };
39081
39082 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39083 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
39084 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39085 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
39086 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39087 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
39088 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39089 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
39090 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
39091 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}};
39092 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
39093 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
39094 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
39095 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
39096 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
39097 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
39098 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
39099 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
39100 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}};
39101 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
39102 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
39103 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
39104 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
39105 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
39106 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}};
39107 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
39108 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}};
39109 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
39110 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
39111 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
39112 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
39113 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
39114 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39115 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39116 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
39117 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
39118 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
39119 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
39120 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
39121 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
39122 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
39123 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
39124 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
39125 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
39126 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
39127 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
39128 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39129 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39130 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
39131 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39132 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
39133 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
39134 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39135 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39136 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
39137 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
39138 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39139 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39140 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39141 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39142 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
39143 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39144 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39145 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
39146 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39147 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39148 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
39149 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39150 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39151 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
39152 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}};
39153 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
39154 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
39155 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
39156 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
39157 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
39158 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
39159 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}};
39160 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
39161 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39162 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
39163 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
39164 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
39165 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
39166 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
39167 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
39168 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
39169 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
39170 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
39171 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}};
39172 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
39173 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
39174 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
39175 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
39176 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
39177 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39178 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
39179 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
39180 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39181 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
39182 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
39183 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
39184 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
39185 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39186 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39187 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
39188 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39189 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39190 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
39191 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
39192 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39193 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39194 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
39195 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
39196 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
39197 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39198 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
39199 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
39200 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39201 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
39202 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
39203 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
39204 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
39205 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
39206 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
39207 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
39208 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
39209 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
39210 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
39211 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
39212 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
39213 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
39214 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
39215 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
39216 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
39217 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
39218 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
39219 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
39220 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
39221 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
39222 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
39223 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
39224 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
39225 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0}, {&_swigt__p_wxPyTextDropTarget, _p_wxPyTextDropTargetTo_p_wxPyDropTarget, 0, 0}, {&_swigt__p_wxPyFileDropTarget, _p_wxPyFileDropTargetTo_p_wxPyDropTarget, 0, 0},{0, 0, 0, 0}};
39226 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39227 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
39228 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
39229 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
39230 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39231 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
39232 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
39233 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
39234 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
39235 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
39236 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
39237 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
39238 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
39239 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
39240 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
39241 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
39242 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39243 static swig_cast_info _swigc__p_wxTextDataObject[] = { {&_swigt__p_wxTextDataObject, 0, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxTextDataObject, 0, 0},{0, 0, 0, 0}};
39244 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
39245 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
39246 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
39247 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
39248 static swig_cast_info _swigc__p_wxTipProvider[] = { {&_swigt__p_wxTipProvider, 0, 0, 0}, {&_swigt__p_wxPyTipProvider, _p_wxPyTipProviderTo_p_wxTipProvider, 0, 0},{0, 0, 0, 0}};
39249 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
39250 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
39251 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
39252 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
39253 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
39254
39255 static swig_cast_info *swig_cast_initial[] = {
39256 _swigc__p_char,
39257 _swigc__p_form_ops_t,
39258 _swigc__p_int,
39259 _swigc__p_unsigned_char,
39260 _swigc__p_unsigned_int,
39261 _swigc__p_unsigned_long,
39262 _swigc__p_void,
39263 _swigc__p_wxANIHandler,
39264 _swigc__p_wxAcceleratorTable,
39265 _swigc__p_wxActivateEvent,
39266 _swigc__p_wxArrayString,
39267 _swigc__p_wxBMPHandler,
39268 _swigc__p_wxBitmap,
39269 _swigc__p_wxBitmapDataObject,
39270 _swigc__p_wxBoxSizer,
39271 _swigc__p_wxBusyCursor,
39272 _swigc__p_wxBusyInfo,
39273 _swigc__p_wxCURHandler,
39274 _swigc__p_wxCaret,
39275 _swigc__p_wxChar,
39276 _swigc__p_wxChildFocusEvent,
39277 _swigc__p_wxClipboard,
39278 _swigc__p_wxClipboardLocker,
39279 _swigc__p_wxClipboardTextEvent,
39280 _swigc__p_wxCloseEvent,
39281 _swigc__p_wxColour,
39282 _swigc__p_wxCommandEvent,
39283 _swigc__p_wxConfig,
39284 _swigc__p_wxConfigBase,
39285 _swigc__p_wxConfigPathChanger,
39286 _swigc__p_wxContextMenuEvent,
39287 _swigc__p_wxControl,
39288 _swigc__p_wxControlWithItems,
39289 _swigc__p_wxCursor,
39290 _swigc__p_wxCustomDataObject,
39291 _swigc__p_wxDC,
39292 _swigc__p_wxDataFormat,
39293 _swigc__p_wxDataObject,
39294 _swigc__p_wxDataObjectComposite,
39295 _swigc__p_wxDataObjectSimple,
39296 _swigc__p_wxDateEvent,
39297 _swigc__p_wxDateSpan,
39298 _swigc__p_wxDateTime,
39299 _swigc__p_wxDateTime__TimeZone,
39300 _swigc__p_wxDisplay,
39301 _swigc__p_wxDisplayChangedEvent,
39302 _swigc__p_wxDropFilesEvent,
39303 _swigc__p_wxDuplexMode,
39304 _swigc__p_wxEraseEvent,
39305 _swigc__p_wxEvent,
39306 _swigc__p_wxEvtHandler,
39307 _swigc__p_wxFSFile,
39308 _swigc__p_wxFileConfig,
39309 _swigc__p_wxFileDataObject,
39310 _swigc__p_wxFileHistory,
39311 _swigc__p_wxFileSystem,
39312 _swigc__p_wxFileType,
39313 _swigc__p_wxFileTypeInfo,
39314 _swigc__p_wxFlexGridSizer,
39315 _swigc__p_wxFocusEvent,
39316 _swigc__p_wxFont,
39317 _swigc__p_wxFrame,
39318 _swigc__p_wxGBSizerItem,
39319 _swigc__p_wxGIFHandler,
39320 _swigc__p_wxGridBagSizer,
39321 _swigc__p_wxGridSizer,
39322 _swigc__p_wxICOHandler,
39323 _swigc__p_wxIcon,
39324 _swigc__p_wxIconizeEvent,
39325 _swigc__p_wxIdleEvent,
39326 _swigc__p_wxImage,
39327 _swigc__p_wxImageHandler,
39328 _swigc__p_wxIndividualLayoutConstraint,
39329 _swigc__p_wxInitDialogEvent,
39330 _swigc__p_wxJPEGHandler,
39331 _swigc__p_wxJoystick,
39332 _swigc__p_wxJoystickEvent,
39333 _swigc__p_wxKeyEvent,
39334 _swigc__p_wxKillError,
39335 _swigc__p_wxLayoutConstraints,
39336 _swigc__p_wxLog,
39337 _swigc__p_wxLogBuffer,
39338 _swigc__p_wxLogChain,
39339 _swigc__p_wxLogGui,
39340 _swigc__p_wxLogNull,
39341 _swigc__p_wxLogStderr,
39342 _swigc__p_wxLogTextCtrl,
39343 _swigc__p_wxLogWindow,
39344 _swigc__p_wxMaximizeEvent,
39345 _swigc__p_wxMenu,
39346 _swigc__p_wxMenuBar,
39347 _swigc__p_wxMenuEvent,
39348 _swigc__p_wxMenuItem,
39349 _swigc__p_wxMetafileDataObject,
39350 _swigc__p_wxMimeTypesManager,
39351 _swigc__p_wxMouseCaptureChangedEvent,
39352 _swigc__p_wxMouseCaptureLostEvent,
39353 _swigc__p_wxMouseEvent,
39354 _swigc__p_wxMouseState,
39355 _swigc__p_wxMoveEvent,
39356 _swigc__p_wxMutexGuiLocker,
39357 _swigc__p_wxNavigationKeyEvent,
39358 _swigc__p_wxNcPaintEvent,
39359 _swigc__p_wxNotifyEvent,
39360 _swigc__p_wxObject,
39361 _swigc__p_wxOutputStream,
39362 _swigc__p_wxPCXHandler,
39363 _swigc__p_wxPNGHandler,
39364 _swigc__p_wxPNMHandler,
39365 _swigc__p_wxPaintEvent,
39366 _swigc__p_wxPaletteChangedEvent,
39367 _swigc__p_wxPaperSize,
39368 _swigc__p_wxPlatformInfo,
39369 _swigc__p_wxPoint,
39370 _swigc__p_wxPowerEvent,
39371 _swigc__p_wxProcessEvent,
39372 _swigc__p_wxPyApp,
39373 _swigc__p_wxPyArtProvider,
39374 _swigc__p_wxPyBitmapDataObject,
39375 _swigc__p_wxPyCommandEvent,
39376 _swigc__p_wxPyDataObjectSimple,
39377 _swigc__p_wxPyDropSource,
39378 _swigc__p_wxPyDropTarget,
39379 _swigc__p_wxPyEvent,
39380 _swigc__p_wxPyFileDropTarget,
39381 _swigc__p_wxPyImageHandler,
39382 _swigc__p_wxPyLog,
39383 _swigc__p_wxPyProcess,
39384 _swigc__p_wxPySizer,
39385 _swigc__p_wxPyTextDataObject,
39386 _swigc__p_wxPyTextDropTarget,
39387 _swigc__p_wxPyTimer,
39388 _swigc__p_wxPyTipProvider,
39389 _swigc__p_wxPyValidator,
39390 _swigc__p_wxQueryNewPaletteEvent,
39391 _swigc__p_wxRect,
39392 _swigc__p_wxScrollEvent,
39393 _swigc__p_wxScrollWinEvent,
39394 _swigc__p_wxSetCursorEvent,
39395 _swigc__p_wxShowEvent,
39396 _swigc__p_wxSingleInstanceChecker,
39397 _swigc__p_wxSize,
39398 _swigc__p_wxSizeEvent,
39399 _swigc__p_wxSizer,
39400 _swigc__p_wxSizerItem,
39401 _swigc__p_wxSound,
39402 _swigc__p_wxStandardPaths,
39403 _swigc__p_wxStaticBoxSizer,
39404 _swigc__p_wxStdDialogButtonSizer,
39405 _swigc__p_wxStopWatch,
39406 _swigc__p_wxString,
39407 _swigc__p_wxSysColourChangedEvent,
39408 _swigc__p_wxSystemOptions,
39409 _swigc__p_wxSystemSettings,
39410 _swigc__p_wxTIFFHandler,
39411 _swigc__p_wxTextCtrl,
39412 _swigc__p_wxTextDataObject,
39413 _swigc__p_wxTimeSpan,
39414 _swigc__p_wxTimer,
39415 _swigc__p_wxTimerEvent,
39416 _swigc__p_wxTimerRunner,
39417 _swigc__p_wxTipProvider,
39418 _swigc__p_wxToolTip,
39419 _swigc__p_wxURLDataObject,
39420 _swigc__p_wxUpdateUIEvent,
39421 _swigc__p_wxValidator,
39422 _swigc__p_wxVideoMode,
39423 _swigc__p_wxWindow,
39424 _swigc__p_wxWindowCreateEvent,
39425 _swigc__p_wxWindowDestroyEvent,
39426 _swigc__p_wxWindowDisabler,
39427 _swigc__p_wxXPMHandler,
39428 };
39429
39430
39431 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39432
39433 static swig_const_info swig_const_table[] = {
39434 {0, 0, 0, 0.0, 0, 0}};
39435
39436 #ifdef __cplusplus
39437 }
39438 #endif
39439 /* -----------------------------------------------------------------------------
39440 * Type initialization:
39441 * This problem is tough by the requirement that no dynamic
39442 * memory is used. Also, since swig_type_info structures store pointers to
39443 * swig_cast_info structures and swig_cast_info structures store pointers back
39444 * to swig_type_info structures, we need some lookup code at initialization.
39445 * The idea is that swig generates all the structures that are needed.
39446 * The runtime then collects these partially filled structures.
39447 * The SWIG_InitializeModule function takes these initial arrays out of
39448 * swig_module, and does all the lookup, filling in the swig_module.types
39449 * array with the correct data and linking the correct swig_cast_info
39450 * structures together.
39451 *
39452 * The generated swig_type_info structures are assigned staticly to an initial
39453 * array. We just loop though that array, and handle each type individually.
39454 * First we lookup if this type has been already loaded, and if so, use the
39455 * loaded structure instead of the generated one. Then we have to fill in the
39456 * cast linked list. The cast data is initially stored in something like a
39457 * two-dimensional array. Each row corresponds to a type (there are the same
39458 * number of rows as there are in the swig_type_initial array). Each entry in
39459 * a column is one of the swig_cast_info structures for that type.
39460 * The cast_initial array is actually an array of arrays, because each row has
39461 * a variable number of columns. So to actually build the cast linked list,
39462 * we find the array of casts associated with the type, and loop through it
39463 * adding the casts to the list. The one last trick we need to do is making
39464 * sure the type pointer in the swig_cast_info struct is correct.
39465 *
39466 * First off, we lookup the cast->type name to see if it is already loaded.
39467 * There are three cases to handle:
39468 * 1) If the cast->type has already been loaded AND the type we are adding
39469 * casting info to has not been loaded (it is in this module), THEN we
39470 * replace the cast->type pointer with the type pointer that has already
39471 * been loaded.
39472 * 2) If BOTH types (the one we are adding casting info to, and the
39473 * cast->type) are loaded, THEN the cast info has already been loaded by
39474 * the previous module so we just ignore it.
39475 * 3) Finally, if cast->type has not already been loaded, then we add that
39476 * swig_cast_info to the linked list (because the cast->type) pointer will
39477 * be correct.
39478 * ----------------------------------------------------------------------------- */
39479
39480 #ifdef __cplusplus
39481 extern "C" {
39482 #if 0
39483 } /* c-mode */
39484 #endif
39485 #endif
39486
39487 #if 0
39488 #define SWIGRUNTIME_DEBUG
39489 #endif
39490
39491 SWIGRUNTIME void
39492 SWIG_InitializeModule(void *clientdata) {
39493 size_t i;
39494 swig_module_info *module_head;
39495 static int init_run = 0;
39496
39497 clientdata = clientdata;
39498
39499 if (init_run) return;
39500 init_run = 1;
39501
39502 /* Initialize the swig_module */
39503 swig_module.type_initial = swig_type_initial;
39504 swig_module.cast_initial = swig_cast_initial;
39505
39506 /* Try and load any already created modules */
39507 module_head = SWIG_GetModule(clientdata);
39508 if (module_head) {
39509 swig_module.next = module_head->next;
39510 module_head->next = &swig_module;
39511 } else {
39512 /* This is the first module loaded */
39513 swig_module.next = &swig_module;
39514 SWIG_SetModule(clientdata, &swig_module);
39515 }
39516
39517 /* Now work on filling in swig_module.types */
39518 #ifdef SWIGRUNTIME_DEBUG
39519 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39520 #endif
39521 for (i = 0; i < swig_module.size; ++i) {
39522 swig_type_info *type = 0;
39523 swig_type_info *ret;
39524 swig_cast_info *cast;
39525
39526 #ifdef SWIGRUNTIME_DEBUG
39527 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39528 #endif
39529
39530 /* if there is another module already loaded */
39531 if (swig_module.next != &swig_module) {
39532 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39533 }
39534 if (type) {
39535 /* Overwrite clientdata field */
39536 #ifdef SWIGRUNTIME_DEBUG
39537 printf("SWIG_InitializeModule: found type %s\n", type->name);
39538 #endif
39539 if (swig_module.type_initial[i]->clientdata) {
39540 type->clientdata = swig_module.type_initial[i]->clientdata;
39541 #ifdef SWIGRUNTIME_DEBUG
39542 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39543 #endif
39544 }
39545 } else {
39546 type = swig_module.type_initial[i];
39547 }
39548
39549 /* Insert casting types */
39550 cast = swig_module.cast_initial[i];
39551 while (cast->type) {
39552 /* Don't need to add information already in the list */
39553 ret = 0;
39554 #ifdef SWIGRUNTIME_DEBUG
39555 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39556 #endif
39557 if (swig_module.next != &swig_module) {
39558 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39559 #ifdef SWIGRUNTIME_DEBUG
39560 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39561 #endif
39562 }
39563 if (ret) {
39564 if (type == swig_module.type_initial[i]) {
39565 #ifdef SWIGRUNTIME_DEBUG
39566 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39567 #endif
39568 cast->type = ret;
39569 ret = 0;
39570 } else {
39571 /* Check for casting already in the list */
39572 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39573 #ifdef SWIGRUNTIME_DEBUG
39574 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39575 #endif
39576 if (!ocast) ret = 0;
39577 }
39578 }
39579
39580 if (!ret) {
39581 #ifdef SWIGRUNTIME_DEBUG
39582 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39583 #endif
39584 if (type->cast) {
39585 type->cast->prev = cast;
39586 cast->next = type->cast;
39587 }
39588 type->cast = cast;
39589 }
39590 cast++;
39591 }
39592 /* Set entry in modules->types array equal to the type */
39593 swig_module.types[i] = type;
39594 }
39595 swig_module.types[i] = 0;
39596
39597 #ifdef SWIGRUNTIME_DEBUG
39598 printf("**** SWIG_InitializeModule: Cast List ******\n");
39599 for (i = 0; i < swig_module.size; ++i) {
39600 int j = 0;
39601 swig_cast_info *cast = swig_module.cast_initial[i];
39602 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39603 while (cast->type) {
39604 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39605 cast++;
39606 ++j;
39607 }
39608 printf("---- Total casts: %d\n",j);
39609 }
39610 printf("**** SWIG_InitializeModule: Cast List ******\n");
39611 #endif
39612 }
39613
39614 /* This function will propagate the clientdata field of type to
39615 * any new swig_type_info structures that have been added into the list
39616 * of equivalent types. It is like calling
39617 * SWIG_TypeClientData(type, clientdata) a second time.
39618 */
39619 SWIGRUNTIME void
39620 SWIG_PropagateClientData(void) {
39621 size_t i;
39622 swig_cast_info *equiv;
39623 static int init_run = 0;
39624
39625 if (init_run) return;
39626 init_run = 1;
39627
39628 for (i = 0; i < swig_module.size; i++) {
39629 if (swig_module.types[i]->clientdata) {
39630 equiv = swig_module.types[i]->cast;
39631 while (equiv) {
39632 if (!equiv->converter) {
39633 if (equiv->type && !equiv->type->clientdata)
39634 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39635 }
39636 equiv = equiv->next;
39637 }
39638 }
39639 }
39640 }
39641
39642 #ifdef __cplusplus
39643 #if 0
39644 {
39645 /* c-mode */
39646 #endif
39647 }
39648 #endif
39649
39650
39651
39652 #ifdef __cplusplus
39653 extern "C" {
39654 #endif
39655
39656 /* Python-specific SWIG API */
39657 #define SWIG_newvarlink() SWIG_Python_newvarlink()
39658 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39659 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39660
39661 /* -----------------------------------------------------------------------------
39662 * global variable support code.
39663 * ----------------------------------------------------------------------------- */
39664
39665 typedef struct swig_globalvar {
39666 char *name; /* Name of global variable */
39667 PyObject *(*get_attr)(void); /* Return the current value */
39668 int (*set_attr)(PyObject *); /* Set the value */
39669 struct swig_globalvar *next;
39670 } swig_globalvar;
39671
39672 typedef struct swig_varlinkobject {
39673 PyObject_HEAD
39674 swig_globalvar *vars;
39675 } swig_varlinkobject;
39676
39677 SWIGINTERN PyObject *
39678 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39679 return PyString_FromString("<Swig global variables>");
39680 }
39681
39682 SWIGINTERN PyObject *
39683 swig_varlink_str(swig_varlinkobject *v) {
39684 PyObject *str = PyString_FromString("(");
39685 swig_globalvar *var;
39686 for (var = v->vars; var; var=var->next) {
39687 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39688 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39689 }
39690 PyString_ConcatAndDel(&str,PyString_FromString(")"));
39691 return str;
39692 }
39693
39694 SWIGINTERN int
39695 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39696 PyObject *str = swig_varlink_str(v);
39697 fprintf(fp,"Swig global variables ");
39698 fprintf(fp,"%s\n", PyString_AsString(str));
39699 Py_DECREF(str);
39700 return 0;
39701 }
39702
39703 SWIGINTERN void
39704 swig_varlink_dealloc(swig_varlinkobject *v) {
39705 swig_globalvar *var = v->vars;
39706 while (var) {
39707 swig_globalvar *n = var->next;
39708 free(var->name);
39709 free(var);
39710 var = n;
39711 }
39712 }
39713
39714 SWIGINTERN PyObject *
39715 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39716 PyObject *res = NULL;
39717 swig_globalvar *var = v->vars;
39718 while (var) {
39719 if (strcmp(var->name,n) == 0) {
39720 res = (*var->get_attr)();
39721 break;
39722 }
39723 var = var->next;
39724 }
39725 if (res == NULL && !PyErr_Occurred()) {
39726 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39727 }
39728 return res;
39729 }
39730
39731 SWIGINTERN int
39732 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39733 int res = 1;
39734 swig_globalvar *var = v->vars;
39735 while (var) {
39736 if (strcmp(var->name,n) == 0) {
39737 res = (*var->set_attr)(p);
39738 break;
39739 }
39740 var = var->next;
39741 }
39742 if (res == 1 && !PyErr_Occurred()) {
39743 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39744 }
39745 return res;
39746 }
39747
39748 SWIGINTERN PyTypeObject*
39749 swig_varlink_type(void) {
39750 static char varlink__doc__[] = "Swig var link object";
39751 static PyTypeObject varlink_type;
39752 static int type_init = 0;
39753 if (!type_init) {
39754 const PyTypeObject tmp
39755 = {
39756 PyObject_HEAD_INIT(NULL)
39757 0, /* Number of items in variable part (ob_size) */
39758 (char *)"swigvarlink", /* Type name (tp_name) */
39759 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
39760 0, /* Itemsize (tp_itemsize) */
39761 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
39762 (printfunc) swig_varlink_print, /* Print (tp_print) */
39763 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
39764 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
39765 0, /* tp_compare */
39766 (reprfunc) swig_varlink_repr, /* tp_repr */
39767 0, /* tp_as_number */
39768 0, /* tp_as_sequence */
39769 0, /* tp_as_mapping */
39770 0, /* tp_hash */
39771 0, /* tp_call */
39772 (reprfunc)swig_varlink_str, /* tp_str */
39773 0, /* tp_getattro */
39774 0, /* tp_setattro */
39775 0, /* tp_as_buffer */
39776 0, /* tp_flags */
39777 varlink__doc__, /* tp_doc */
39778 0, /* tp_traverse */
39779 0, /* tp_clear */
39780 0, /* tp_richcompare */
39781 0, /* tp_weaklistoffset */
39782 #if PY_VERSION_HEX >= 0x02020000
39783 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39784 #endif
39785 #if PY_VERSION_HEX >= 0x02030000
39786 0, /* tp_del */
39787 #endif
39788 #ifdef COUNT_ALLOCS
39789 0,0,0,0 /* tp_alloc -> tp_next */
39790 #endif
39791 };
39792 varlink_type = tmp;
39793 varlink_type.ob_type = &PyType_Type;
39794 type_init = 1;
39795 }
39796 return &varlink_type;
39797 }
39798
39799 /* Create a variable linking object for use later */
39800 SWIGINTERN PyObject *
39801 SWIG_Python_newvarlink(void) {
39802 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39803 if (result) {
39804 result->vars = 0;
39805 }
39806 return ((PyObject*) result);
39807 }
39808
39809 SWIGINTERN void
39810 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39811 swig_varlinkobject *v = (swig_varlinkobject *) p;
39812 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39813 if (gv) {
39814 size_t size = strlen(name)+1;
39815 gv->name = (char *)malloc(size);
39816 if (gv->name) {
39817 strncpy(gv->name,name,size);
39818 gv->get_attr = get_attr;
39819 gv->set_attr = set_attr;
39820 gv->next = v->vars;
39821 }
39822 }
39823 v->vars = gv;
39824 }
39825
39826 SWIGINTERN PyObject *
39827 SWIG_globals() {
39828 static PyObject *_SWIG_globals = 0;
39829 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39830 return _SWIG_globals;
39831 }
39832
39833 /* -----------------------------------------------------------------------------
39834 * constants/methods manipulation
39835 * ----------------------------------------------------------------------------- */
39836
39837 /* Install Constants */
39838 SWIGINTERN void
39839 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39840 PyObject *obj = 0;
39841 size_t i;
39842 for (i = 0; constants[i].type; ++i) {
39843 switch(constants[i].type) {
39844 case SWIG_PY_POINTER:
39845 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39846 break;
39847 case SWIG_PY_BINARY:
39848 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39849 break;
39850 default:
39851 obj = 0;
39852 break;
39853 }
39854 if (obj) {
39855 PyDict_SetItemString(d, constants[i].name, obj);
39856 Py_DECREF(obj);
39857 }
39858 }
39859 }
39860
39861 /* -----------------------------------------------------------------------------*/
39862 /* Fix SwigMethods to carry the callback ptrs when needed */
39863 /* -----------------------------------------------------------------------------*/
39864
39865 SWIGINTERN void
39866 SWIG_Python_FixMethods(PyMethodDef *methods,
39867 swig_const_info *const_table,
39868 swig_type_info **types,
39869 swig_type_info **types_initial) {
39870 size_t i;
39871 for (i = 0; methods[i].ml_name; ++i) {
39872 const char *c = methods[i].ml_doc;
39873 if (c && (c = strstr(c, "swig_ptr: "))) {
39874 int j;
39875 swig_const_info *ci = 0;
39876 const char *name = c + 10;
39877 for (j = 0; const_table[j].type; ++j) {
39878 if (strncmp(const_table[j].name, name,
39879 strlen(const_table[j].name)) == 0) {
39880 ci = &(const_table[j]);
39881 break;
39882 }
39883 }
39884 if (ci) {
39885 size_t shift = (ci->ptype) - types;
39886 swig_type_info *ty = types_initial[shift];
39887 size_t ldoc = (c - methods[i].ml_doc);
39888 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39889 char *ndoc = (char*)malloc(ldoc + lptr + 10);
39890 if (ndoc) {
39891 char *buff = ndoc;
39892 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39893 if (ptr) {
39894 strncpy(buff, methods[i].ml_doc, ldoc);
39895 buff += ldoc;
39896 strncpy(buff, "swig_ptr: ", 10);
39897 buff += 10;
39898 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
39899 methods[i].ml_doc = ndoc;
39900 }
39901 }
39902 }
39903 }
39904 }
39905 }
39906
39907 #ifdef __cplusplus
39908 }
39909 #endif
39910
39911 /* -----------------------------------------------------------------------------*
39912 * Partial Init method
39913 * -----------------------------------------------------------------------------*/
39914
39915 #ifdef __cplusplus
39916 extern "C"
39917 #endif
39918 SWIGEXPORT void SWIG_init(void) {
39919 PyObject *m, *d;
39920
39921 /* Fix SwigMethods to carry the callback ptrs when needed */
39922 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
39923
39924 m = Py_InitModule((char *) SWIG_name, SwigMethods);
39925 d = PyModule_GetDict(m);
39926
39927 SWIG_InitializeModule(0);
39928 SWIG_InstallConstants(d,swig_const_table);
39929
39930
39931 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
39932 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
39933 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
39934 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
39935 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
39936 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
39937 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
39938 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
39939 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
39940 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
39941 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
39942 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
39943 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
39944 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
39945 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
39946 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
39947 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
39948 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
39949 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
39950 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
39951 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
39952 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
39953 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
39954 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
39955 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
39956 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
39957 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
39958 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
39959 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
39960 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
39961 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
39962 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
39963 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
39964 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
39965 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
39966 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
39967 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
39968 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
39969 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
39970 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
39971 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
39972 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
39973 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
39974 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
39975 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
39976 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
39977 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
39978 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
39979 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
39980 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
39981 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
39982 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
39983 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
39984 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
39985 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
39986 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
39987 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
39988 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
39989 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
39990 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
39991 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
39992 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
39993 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
39994 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
39995 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
39996 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
39997 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
39998 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
39999 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
40000 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
40001 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
40002 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
40003 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
40004 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
40005 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
40006 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
40007 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
40008 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
40009 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
40010 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
40011 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
40012 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
40013 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
40014 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
40015 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
40016 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
40017 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
40018 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
40019 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
40020 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
40021 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
40022 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
40023 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
40024 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
40025 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
40026 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
40027 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
40028 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
40029 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
40030 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
40031 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
40032 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
40033 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
40034 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
40035 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
40036 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
40037 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
40038 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
40039 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
40040 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
40041 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
40042 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
40043 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
40044 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
40045 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
40046 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
40047 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
40048 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
40049 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
40050 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
40051 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
40052 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
40053 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
40054 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
40055 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
40056 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
40057 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
40058 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
40059 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
40060 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
40061 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
40062 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
40063 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
40064 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
40065 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
40066 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
40067 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
40068 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
40069 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
40070 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
40071 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
40072 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
40073 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
40074 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
40075 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
40076 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
40077 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
40078 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
40079
40080 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
40081
40082 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
40083 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
40084 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
40085 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
40086 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
40087 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
40088 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
40089 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
40090 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
40091 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
40092 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
40093 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
40094 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
40095 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
40096 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
40097 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
40098 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
40099 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
40100 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
40101 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
40102 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
40103 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
40104 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
40105 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
40106 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
40107 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
40108 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
40109 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
40110 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
40111 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
40112 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
40113 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
40114 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
40115 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
40116 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
40117 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
40118 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
40119 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
40120 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
40121 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
40122 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
40123 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
40124 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
40125 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
40126 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
40127 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
40128 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
40129 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
40130 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
40131 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
40132 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
40133 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
40134 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
40135
40136 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
40137
40138 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
40139 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
40140 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
40141 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
40142 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
40143 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
40144 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
40145 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
40146 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
40147 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
40148 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
40149 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
40150 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
40151 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
40152 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
40153 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
40154 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
40155 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
40156 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
40157 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
40158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
40159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
40160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
40161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
40162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
40163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
40164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
40165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
40166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
40167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
40168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
40169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
40170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
40171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
40172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
40173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
40174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
40175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
40176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
40177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
40178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
40179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
40180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
40181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
40182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
40183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
40184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
40185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
40186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
40187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
40188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
40189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
40190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
40191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
40192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
40193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
40194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
40195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
40196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
40197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
40198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
40199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
40200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
40201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
40202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
40203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
40204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
40205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
40206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
40207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
40208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
40209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
40210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
40211 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
40212 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
40213 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
40214
40215 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
40216
40217 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
40218 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
40219 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
40220 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
40221 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
40222 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
40223 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
40224 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
40225 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
40226 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
40227 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
40228 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
40229 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
40230 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
40231 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
40232 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
40233 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
40234 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
40235 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
40236 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
40237 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
40238 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
40239 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
40240 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
40241 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
40242 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
40243 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
40244 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
40245 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
40246 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
40247 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
40248 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
40249 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
40250 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
40251 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
40252 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
40253 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
40254 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
40255 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
40256 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
40257 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
40258 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
40259 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
40260 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
40261 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
40262 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
40263 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
40264 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
40265 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
40266 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
40267 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
40268 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
40269 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
40270 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
40271 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
40272 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
40273 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
40274 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
40275 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
40276 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
40277 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
40278 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
40279 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
40280 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
40281 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
40282 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
40283 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
40284 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
40285 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
40286 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
40287 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
40288 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
40289 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
40290 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
40291 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
40292 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
40293 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
40294 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
40295 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
40296 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
40297 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
40298 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
40299 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
40300 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
40301 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
40302 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
40303 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
40304 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
40305 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
40306 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
40307 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
40308 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
40309 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
40310 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
40311 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
40312 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
40313 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
40314 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
40315 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
40316 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
40317 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
40318 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
40319 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
40320 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
40321 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
40322 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
40323 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
40324 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
40325 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
40326 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
40327 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
40328 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
40329 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
40330 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
40331 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
40332 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
40333 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
40334 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
40335 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
40336 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
40337 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
40338 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
40339 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
40340 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
40341 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
40342 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
40343 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
40344 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
40345 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
40346 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
40347 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
40348 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
40349 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
40350 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
40351 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
40352 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
40353 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
40354 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
40355 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
40356 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
40357 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
40358 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
40359 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
40360 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
40361 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
40362 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
40363 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
40364 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
40365 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
40366 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
40367 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
40368 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
40369 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
40370 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
40371 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
40372 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
40373 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
40374 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
40375 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
40376 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
40377 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
40378 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
40379 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
40380 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
40381 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
40382 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
40383 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
40384 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
40385 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
40386 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
40387 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
40388 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
40389 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
40390 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
40391 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
40392 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
40393 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
40394 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
40395 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
40396 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
40397 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
40398 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
40399 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
40400 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
40401 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
40402 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
40403 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
40404 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
40405 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
40406 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
40407 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
40408 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
40409 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
40410 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
40411 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
40412 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
40413 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
40414 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
40415 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
40416 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
40417
40418 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
40419 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
40420 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
40421 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
40422
40423 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
40424 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
40425 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
40426 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
40427 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
40428 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
40429 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
40430 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
40431 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
40432 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
40433 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
40434 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
40435 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
40436 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
40437 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
40438 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
40439 }
40440
wxWidgets (Impactor)