]> 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 test for operator?: and wxCStrData
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEventBlocker swig_types[51]
2518 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
2519 #define SWIGTYPE_p_wxFSFile swig_types[53]
2520 #define SWIGTYPE_p_wxFileConfig swig_types[54]
2521 #define SWIGTYPE_p_wxFileDataObject swig_types[55]
2522 #define SWIGTYPE_p_wxFileHistory swig_types[56]
2523 #define SWIGTYPE_p_wxFileSystem swig_types[57]
2524 #define SWIGTYPE_p_wxFileType swig_types[58]
2525 #define SWIGTYPE_p_wxFileTypeInfo swig_types[59]
2526 #define SWIGTYPE_p_wxFlexGridSizer swig_types[60]
2527 #define SWIGTYPE_p_wxFocusEvent swig_types[61]
2528 #define SWIGTYPE_p_wxFont swig_types[62]
2529 #define SWIGTYPE_p_wxFrame swig_types[63]
2530 #define SWIGTYPE_p_wxGBSizerItem swig_types[64]
2531 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
2532 #define SWIGTYPE_p_wxGridBagSizer swig_types[66]
2533 #define SWIGTYPE_p_wxGridSizer swig_types[67]
2534 #define SWIGTYPE_p_wxICOHandler swig_types[68]
2535 #define SWIGTYPE_p_wxIcon swig_types[69]
2536 #define SWIGTYPE_p_wxIconizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxIdleEvent swig_types[71]
2538 #define SWIGTYPE_p_wxImage swig_types[72]
2539 #define SWIGTYPE_p_wxImageHandler swig_types[73]
2540 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[74]
2541 #define SWIGTYPE_p_wxInitDialogEvent swig_types[75]
2542 #define SWIGTYPE_p_wxJPEGHandler swig_types[76]
2543 #define SWIGTYPE_p_wxJoystick swig_types[77]
2544 #define SWIGTYPE_p_wxJoystickEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKeyEvent swig_types[79]
2546 #define SWIGTYPE_p_wxKillError swig_types[80]
2547 #define SWIGTYPE_p_wxLayoutConstraints swig_types[81]
2548 #define SWIGTYPE_p_wxLog swig_types[82]
2549 #define SWIGTYPE_p_wxLogBuffer swig_types[83]
2550 #define SWIGTYPE_p_wxLogChain swig_types[84]
2551 #define SWIGTYPE_p_wxLogGui swig_types[85]
2552 #define SWIGTYPE_p_wxLogNull swig_types[86]
2553 #define SWIGTYPE_p_wxLogStderr swig_types[87]
2554 #define SWIGTYPE_p_wxLogTextCtrl swig_types[88]
2555 #define SWIGTYPE_p_wxLogWindow swig_types[89]
2556 #define SWIGTYPE_p_wxMaximizeEvent swig_types[90]
2557 #define SWIGTYPE_p_wxMenu swig_types[91]
2558 #define SWIGTYPE_p_wxMenuBar swig_types[92]
2559 #define SWIGTYPE_p_wxMenuEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenuItem swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_wxTGAHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTIFFHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTextCtrl swig_types[158]
2625 #define SWIGTYPE_p_wxTextDataObject swig_types[159]
2626 #define SWIGTYPE_p_wxTimeSpan swig_types[160]
2627 #define SWIGTYPE_p_wxTimer swig_types[161]
2628 #define SWIGTYPE_p_wxTimerEvent swig_types[162]
2629 #define SWIGTYPE_p_wxTimerRunner swig_types[163]
2630 #define SWIGTYPE_p_wxTipProvider swig_types[164]
2631 #define SWIGTYPE_p_wxToolTip swig_types[165]
2632 #define SWIGTYPE_p_wxURLDataObject swig_types[166]
2633 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[167]
2634 #define SWIGTYPE_p_wxValidator swig_types[168]
2635 #define SWIGTYPE_p_wxVideoMode swig_types[169]
2636 #define SWIGTYPE_p_wxWindow swig_types[170]
2637 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDisabler swig_types[173]
2640 #define SWIGTYPE_p_wxXPMHandler swig_types[174]
2641 static swig_type_info *swig_types[176];
2642 static swig_module_info swig_module = {swig_types, 175, 0, 0, 0, 0};
2643 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2644 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2645
2646 /* -------- TYPES TABLE (END) -------- */
2647
2648 #if (PY_VERSION_HEX <= 0x02000000)
2649 # if !defined(SWIG_PYTHON_CLASSIC)
2650 # error "This python version requires to use swig with the '-classic' option"
2651 # endif
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodern' option"
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodernargs' option"
2658 #endif
2659 #ifndef METH_O
2660 # error "This python version requires to use swig with the '-nofastunpack' option"
2661 #endif
2662
2663 /*-----------------------------------------------
2664 @(target):= _misc_.so
2665 ------------------------------------------------*/
2666 #define SWIG_init init_misc_
2667
2668 #define SWIG_name "_misc_"
2669
2670 #define SWIGVERSION 0x010329
2671
2672
2673 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2674 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2675
2676
2677 #include <stdexcept>
2678
2679
2680 namespace swig {
2681 class PyObject_ptr {
2682 protected:
2683 PyObject *_obj;
2684
2685 public:
2686 PyObject_ptr() :_obj(0)
2687 {
2688 }
2689
2690 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2691 {
2692 Py_XINCREF(_obj);
2693 }
2694
2695 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2696 {
2697 if (initial_ref) Py_XINCREF(_obj);
2698 }
2699
2700 PyObject_ptr & operator=(const PyObject_ptr& item)
2701 {
2702 Py_XINCREF(item._obj);
2703 Py_XDECREF(_obj);
2704 _obj = item._obj;
2705 return *this;
2706 }
2707
2708 ~PyObject_ptr()
2709 {
2710 Py_XDECREF(_obj);
2711 }
2712
2713 operator PyObject *() const
2714 {
2715 return _obj;
2716 }
2717
2718 PyObject *operator->() const
2719 {
2720 return _obj;
2721 }
2722 };
2723 }
2724
2725
2726 namespace swig {
2727 struct PyObject_var : PyObject_ptr {
2728 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2729
2730 PyObject_var & operator = (PyObject* obj)
2731 {
2732 Py_XDECREF(_obj);
2733 _obj = obj;
2734 return *this;
2735 }
2736 };
2737 }
2738
2739
2740 #include "wx/wxPython/wxPython.h"
2741 #include "wx/wxPython/pyclasses.h"
2742 #include "wx/wxPython/pyistream.h"
2743
2744 static const wxString wxPyEmptyString(wxEmptyString);
2745
2746
2747
2748 #define SWIG_From_long PyInt_FromLong
2749
2750
2751 SWIGINTERNINLINE PyObject *
2752 SWIG_From_int (int value)
2753 {
2754 return SWIG_From_long (value);
2755 }
2756
2757
2758 #include <limits.h>
2759 #ifndef LLONG_MIN
2760 # define LLONG_MIN LONG_LONG_MIN
2761 #endif
2762 #ifndef LLONG_MAX
2763 # define LLONG_MAX LONG_LONG_MAX
2764 #endif
2765 #ifndef ULLONG_MAX
2766 # define ULLONG_MAX ULONG_LONG_MAX
2767 #endif
2768
2769
2770 SWIGINTERN int
2771 SWIG_AsVal_long (PyObject* obj, long* val)
2772 {
2773 if (PyNumber_Check(obj)) {
2774 if (val) *val = PyInt_AsLong(obj);
2775 return SWIG_OK;
2776 }
2777 return SWIG_TypeError;
2778 }
2779
2780
2781 SWIGINTERN int
2782 SWIG_AsVal_int (PyObject * obj, int *val)
2783 {
2784 long v;
2785 int res = SWIG_AsVal_long (obj, &v);
2786 if (SWIG_IsOK(res)) {
2787 if ((v < INT_MIN || v > INT_MAX)) {
2788 return SWIG_OverflowError;
2789 } else {
2790 if (val) *val = static_cast< int >(v);
2791 }
2792 }
2793 return res;
2794 }
2795
2796 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2797
2798 #include <wx/stockitem.h>
2799
2800 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2801 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2802 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2803
2804 wxMemorySize wxGetFreeMemory()
2805 { wxPyRaiseNotImplemented(); return 0; }
2806
2807
2808 SWIGINTERN int
2809 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2810 {
2811 long v = 0;
2812 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2813 return SWIG_TypeError;
2814 }
2815 else if (val)
2816 *val = (unsigned long)v;
2817 return SWIG_OK;
2818 }
2819
2820
2821 SWIGINTERN int
2822 SWIG_AsVal_bool (PyObject *obj, bool *val)
2823 {
2824 if (obj == Py_True) {
2825 if (val) *val = true;
2826 return SWIG_OK;
2827 } else if (obj == Py_False) {
2828 if (val) *val = false;
2829 return SWIG_OK;
2830 } else {
2831 long v = 0;
2832 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2833 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2834 return res;
2835 }
2836 }
2837
2838
2839 SWIGINTERNINLINE PyObject*
2840 SWIG_From_unsigned_SS_long (unsigned long value)
2841 {
2842 return (value > LONG_MAX) ?
2843 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2844 }
2845
2846
2847 void* wxGetXDisplay()
2848 {
2849 #ifdef __WXGTK__
2850 return wxGetDisplay();
2851 #else
2852 return NULL;
2853 #endif
2854 }
2855
2856
2857 wxWindow* FindWindowAtPointer() {
2858 wxPoint unused;
2859 return wxFindWindowAtPointer(unused);
2860 }
2861
2862
2863 void wxWakeUpMainThread() {}
2864
2865
2866 bool wxThread_IsMain() {
2867 #ifdef WXP_WITH_THREAD
2868 return wxThread::IsMain();
2869 #else
2870 return true;
2871 #endif
2872 }
2873
2874 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2875 delete self;
2876 }
2877
2878 #include <wx/snglinst.h>
2879
2880
2881 #ifdef __WXMSW__
2882 #include <wx/msw/private.h>
2883 #include <wx/dynload.h>
2884 #endif
2885
2886
2887
2888 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2889 #if 0
2890 , int method
2891 #endif
2892 )
2893 {
2894 #ifdef __WXMSW__
2895 #if 0
2896 switch (method)
2897 {
2898 case 1:
2899 // This one only partially works. Appears to be an undocumented
2900 // "standard" convention that not all widgets adhear to. For
2901 // example, for some widgets backgrounds or non-client areas may
2902 // not be painted.
2903 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2904 break;
2905
2906 case 2:
2907 #endif
2908 // This one works much better, nearly all widgets and their
2909 // children are captured correctly[**]. Prior to the big
2910 // background erase changes that Vadim did in 2004-2005 this
2911 // method failed badly on XP with Themes activated, most native
2912 // widgets draw only partially, if at all. Without themes it
2913 // worked just like on Win2k. After those changes this method
2914 // works very well.
2915 //
2916 // ** For example the radio buttons in a wxRadioBox are not its
2917 // children by default, but you can capture it via the panel
2918 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2919 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2920 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2921 PRF_ERASEBKGND | PRF_OWNED );
2922 return true;
2923 #if 0
2924 break;
2925
2926 case 3:
2927 // This one is only defined in the latest SDK and is only
2928 // available on XP. MSDN says it is similar to sending WM_PRINT
2929 // so I expect that it will work similar to the above. Since it
2930 // is avaialble only on XP, it can't be compiled like this and
2931 // will have to be loaded dynamically.
2932 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2933
2934 // fall through
2935
2936 case 4:
2937 // Use PrintWindow if available, or fallback to WM_PRINT
2938 // otherwise. Unfortunately using PrintWindow is even worse than
2939 // WM_PRINT. For most native widgets nothing is drawn to the dc
2940 // at all, with or without Themes.
2941 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2942 static bool s_triedToLoad = false;
2943 static PrintWindow_t pfnPrintWindow = NULL;
2944 if ( !s_triedToLoad )
2945 {
2946
2947 s_triedToLoad = true;
2948 wxDynamicLibrary dllUser32(_T("user32.dll"));
2949 if ( dllUser32.IsLoaded() )
2950 {
2951 wxLogNull nolog; // Don't report errors here
2952 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2953 }
2954 }
2955 if (pfnPrintWindow)
2956 {
2957 //printf("Using PrintWindow\n");
2958 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2959 }
2960 else
2961 {
2962 //printf("Using WM_PRINT\n");
2963 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2964 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2965 PRF_ERASEBKGND | PRF_OWNED );
2966 }
2967 }
2968 #endif // 0
2969 #else
2970 return false;
2971 #endif // __WXMSW__
2972 }
2973
2974
2975
2976 #include <wx/tipdlg.h>
2977
2978
2979 SWIGINTERNINLINE PyObject *
2980 SWIG_From_size_t (size_t value)
2981 {
2982 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2983 }
2984
2985
2986 class wxPyTipProvider : public wxTipProvider {
2987 public:
2988 wxPyTipProvider(size_t currentTip)
2989 : wxTipProvider(currentTip) {}
2990
2991 DEC_PYCALLBACK_STRING__pure(GetTip);
2992 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2993 PYPRIVATE;
2994 };
2995
2996 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2997 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2998
2999
3000 SWIGINTERNINLINE int
3001 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3002 {
3003 unsigned long v;
3004 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3005 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3006 return res;
3007 }
3008
3009
3010 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3011
3012 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3013
3014 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3015 : wxTimer(owner, id)
3016 {
3017 if (owner == NULL)
3018 SetOwner(this);
3019 }
3020
3021 wxPyTimer::~wxPyTimer()
3022 {
3023 // printf("-=* ~wxPyTimer\n");
3024 }
3025
3026
3027
3028 SWIGINTERN swig_type_info*
3029 SWIG_pchar_descriptor()
3030 {
3031 static int init = 0;
3032 static swig_type_info* info = 0;
3033 if (!init) {
3034 info = SWIG_TypeQuery("_p_char");
3035 init = 1;
3036 }
3037 return info;
3038 }
3039
3040
3041 SWIGINTERNINLINE PyObject *
3042 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3043 {
3044 if (carray) {
3045 if (size > INT_MAX) {
3046 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3047 return pchar_descriptor ?
3048 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3049 } else {
3050 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3051 }
3052 } else {
3053 return SWIG_Py_Void();
3054 }
3055 }
3056
3057
3058 SWIGINTERNINLINE PyObject *
3059 SWIG_FromCharPtr(const char *cptr)
3060 {
3061 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3062 }
3063
3064
3065 SWIGINTERN int
3066 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3067 {
3068 unsigned long v;
3069 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3070 if (SWIG_IsOK(res)) {
3071 if ((v > UINT_MAX)) {
3072 return SWIG_OverflowError;
3073 } else {
3074 if (val) *val = static_cast< unsigned int >(v);
3075 }
3076 }
3077 return res;
3078 }
3079
3080 SWIGINTERN wxString wxLog_TimeStamp(){
3081 wxString msg;
3082 wxLog::TimeStamp(&msg);
3083 return msg;
3084 }
3085 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3086 // Make some wrappers that double any % signs so they are 'escaped'
3087 void wxPyLogFatalError(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogFatalError(m);
3092 }
3093
3094 void wxPyLogError(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogError(m);
3099 }
3100
3101 void wxPyLogWarning(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogWarning(m);
3106 }
3107
3108 void wxPyLogMessage(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogMessage(m);
3113 }
3114
3115 void wxPyLogInfo(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogInfo(m);
3120 }
3121
3122 void wxPyLogDebug(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogDebug(m);
3127 }
3128
3129 void wxPyLogVerbose(const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogVerbose(m);
3134 }
3135
3136 void wxPyLogStatus(const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogStatus(m);
3141 }
3142
3143 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogStatus(pFrame, m);
3148 }
3149
3150 void wxPyLogSysError(const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogSysError(m);
3155 }
3156
3157 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogGeneric(level, m);
3162 }
3163
3164 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3165 {
3166 wxString m(msg);
3167 m.Replace(wxT("%"), wxT("%%"));
3168 wxLogTrace(mask, m);
3169 }
3170
3171 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3172 {
3173 wxString m(msg);
3174 m.Replace(wxT("%"), wxT("%%"));
3175 wxLogTrace(mask, m);
3176 }
3177
3178
3179
3180 // A wxLog class that can be derived from in wxPython
3181 class wxPyLog : public wxLog {
3182 public:
3183 wxPyLog() : wxLog() {}
3184
3185 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3186 bool found;
3187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3188 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3189 PyObject* s = wx2PyString(szString);
3190 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3191 Py_DECREF(s);
3192 }
3193 wxPyEndBlockThreads(blocked);
3194 if (! found)
3195 wxLog::DoLog(level, szString, t);
3196 }
3197
3198 virtual void DoLogString(const wxChar *szString, time_t t) {
3199 bool found;
3200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3202 PyObject* s = wx2PyString(szString);
3203 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3204 Py_DECREF(s);
3205 }
3206 wxPyEndBlockThreads(blocked);
3207 if (! found)
3208 wxLog::DoLogString(szString, t);
3209 }
3210
3211 DEC_PYCALLBACK_VOID_(Flush);
3212 PYPRIVATE;
3213 };
3214 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3215
3216
3217
3218
3219 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3220
3221
3222 #include <wx/joystick.h>
3223
3224
3225 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3226 // A C++ stub class for wxJoystick for platforms that don't have it.
3227 class wxJoystick : public wxObject {
3228 public:
3229 wxJoystick(int joystick = wxJOYSTICK1) {
3230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3231 PyErr_SetString(PyExc_NotImplementedError,
3232 "wxJoystick is not available on this platform.");
3233 wxPyEndBlockThreads(blocked);
3234 }
3235 wxPoint GetPosition() { return wxPoint(-1,-1); }
3236 int GetZPosition() { return -1; }
3237 int GetButtonState() { return -1; }
3238 int GetPOVPosition() { return -1; }
3239 int GetPOVCTSPosition() { return -1; }
3240 int GetRudderPosition() { return -1; }
3241 int GetUPosition() { return -1; }
3242 int GetVPosition() { return -1; }
3243 int GetMovementThreshold() { return -1; }
3244 void SetMovementThreshold(int threshold) {}
3245
3246 bool IsOk(void) { return false; }
3247 int GetNumberJoysticks() { return -1; }
3248 int GetManufacturerId() { return -1; }
3249 int GetProductId() { return -1; }
3250 wxString GetProductName() { return wxEmptyString; }
3251 int GetXMin() { return -1; }
3252 int GetYMin() { return -1; }
3253 int GetZMin() { return -1; }
3254 int GetXMax() { return -1; }
3255 int GetYMax() { return -1; }
3256 int GetZMax() { return -1; }
3257 int GetNumberButtons() { return -1; }
3258 int GetNumberAxes() { return -1; }
3259 int GetMaxButtons() { return -1; }
3260 int GetMaxAxes() { return -1; }
3261 int GetPollingMin() { return -1; }
3262 int GetPollingMax() { return -1; }
3263 int GetRudderMin() { return -1; }
3264 int GetRudderMax() { return -1; }
3265 int GetUMin() { return -1; }
3266 int GetUMax() { return -1; }
3267 int GetVMin() { return -1; }
3268 int GetVMax() { return -1; }
3269
3270 bool HasRudder() { return false; }
3271 bool HasZ() { return false; }
3272 bool HasU() { return false; }
3273 bool HasV() { return false; }
3274 bool HasPOV() { return false; }
3275 bool HasPOV4Dir() { return false; }
3276 bool HasPOVCTS() { return false; }
3277
3278 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3279 bool ReleaseCapture() { return false; }
3280 };
3281 #endif
3282
3283
3284 #include <wx/sound.h>
3285
3286
3287 #if !wxUSE_SOUND
3288 // A C++ stub class for wxWave for platforms that don't have it.
3289 class wxSound : public wxObject
3290 {
3291 public:
3292 wxSound() {
3293 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3294 PyErr_SetString(PyExc_NotImplementedError,
3295 "wxSound is not available on this platform.");
3296 wxPyEndBlockThreads(blocked);
3297 }
3298 wxSound(const wxString&/*, bool*/) {
3299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3300 PyErr_SetString(PyExc_NotImplementedError,
3301 "wxSound is not available on this platform.");
3302 wxPyEndBlockThreads(blocked);
3303 }
3304 wxSound(int, const wxByte*) {
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 PyErr_SetString(PyExc_NotImplementedError,
3307 "wxSound is not available on this platform.");
3308 wxPyEndBlockThreads(blocked);
3309 }
3310
3311 ~wxSound() {};
3312
3313 bool Create(const wxString&/*, bool*/) { return false; }
3314 bool Create(int, const wxByte*) { return false; };
3315 bool IsOk() { return false; };
3316 bool Play(unsigned) const { return false; }
3317 static bool Play(const wxString&, unsigned) { return false; }
3318 static void Stop() {}
3319 };
3320
3321 #endif
3322
3323 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3324 if (fileName.Length() == 0)
3325 return new wxSound;
3326 else
3327 return new wxSound(fileName);
3328 }
3329 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3330 unsigned char* buffer; int size;
3331 wxSound *sound = NULL;
3332
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 if (!PyArg_Parse(data, "t#", &buffer, &size))
3335 goto done;
3336 sound = new wxSound(size, buffer);
3337 done:
3338 wxPyEndBlockThreads(blocked);
3339 return sound;
3340 }
3341 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3342 #ifndef __WXMAC__
3343 unsigned char* buffer;
3344 int size;
3345 bool rv = false;
3346
3347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3348 if (!PyArg_Parse(data, "t#", &buffer, &size))
3349 goto done;
3350 rv = self->Create(size, buffer);
3351 done:
3352 wxPyEndBlockThreads(blocked);
3353 return rv;
3354 #else
3355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3356 PyErr_SetString(PyExc_NotImplementedError,
3357 "Create from data is not available on this platform.");
3358 wxPyEndBlockThreads(blocked);
3359 return false;
3360 #endif
3361 }
3362
3363 #include <wx/mimetype.h>
3364
3365 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3366 wxString str;
3367 if (self->GetMimeType(&str))
3368 return wx2PyString(str);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3373 wxArrayString arr;
3374 if (self->GetMimeTypes(arr))
3375 return wxArrayString2PyList_helper(arr);
3376 else
3377 RETURN_NONE();
3378 }
3379 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3380 wxArrayString arr;
3381 if (self->GetExtensions(arr))
3382 return wxArrayString2PyList_helper(arr);
3383 else
3384 RETURN_NONE();
3385 }
3386 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3387 wxIconLocation loc;
3388 if (self->GetIcon(&loc))
3389 return new wxIcon(loc);
3390 else
3391 return NULL;
3392 }
3393 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3394 wxIconLocation loc;
3395 if (self->GetIcon(&loc)) {
3396 wxString iconFile = loc.GetFileName();
3397 int iconIndex = -1;
3398
3399
3400
3401 // Make a tuple and put the values in it
3402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3403 PyObject* tuple = PyTuple_New(3);
3404 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3405 wxT("wxIcon"), true));
3406 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3407 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3408 wxPyEndBlockThreads(blocked);
3409 return tuple;
3410 }
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3415 wxString str;
3416 if (self->GetDescription(&str))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxString str;
3423 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3424 return wx2PyString(str);
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 wxString str;
3430 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3431 return wx2PyString(str);
3432 else
3433 RETURN_NONE();
3434 }
3435 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3436 wxArrayString verbs;
3437 wxArrayString commands;
3438 if (self->GetAllCommands(&verbs, &commands,
3439 wxFileType::MessageParameters(filename, mimetype))) {
3440 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3441 PyObject* tuple = PyTuple_New(2);
3442 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3443 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3444 wxPyEndBlockThreads(blocked);
3445 return tuple;
3446 }
3447 else
3448 RETURN_NONE();
3449 }
3450 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3451 return wxFileType::ExpandCommand(command,
3452 wxFileType::MessageParameters(filename, mimetype));
3453 }
3454 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3455 wxArrayString arr;
3456 self->EnumAllFileTypes(arr);
3457 return wxArrayString2PyList_helper(arr);
3458 }
3459
3460 #include <wx/artprov.h>
3461
3462 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3463 static const wxString wxPyART_MENU(wxART_MENU);
3464 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3465 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3466 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3467 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3468 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3469 static const wxString wxPyART_OTHER(wxART_OTHER);
3470 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3471 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3472 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3473 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3474 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3475 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3476 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3477 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3478 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3479 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3480 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3481 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3482 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3483 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3484 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3485 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3486 static const wxString wxPyART_PRINT(wxART_PRINT);
3487 static const wxString wxPyART_HELP(wxART_HELP);
3488 static const wxString wxPyART_TIP(wxART_TIP);
3489 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3490 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3491 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3492 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3493 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3494 static const wxString wxPyART_CDROM(wxART_CDROM);
3495 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3496 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3497 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3498 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3499 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3500 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3501 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3502 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3503 static const wxString wxPyART_ERROR(wxART_ERROR);
3504 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3505 static const wxString wxPyART_WARNING(wxART_WARNING);
3506 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3507 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3508 static const wxString wxPyART_COPY(wxART_COPY);
3509 static const wxString wxPyART_CUT(wxART_CUT);
3510 static const wxString wxPyART_PASTE(wxART_PASTE);
3511 static const wxString wxPyART_DELETE(wxART_DELETE);
3512 static const wxString wxPyART_NEW(wxART_NEW);
3513 static const wxString wxPyART_UNDO(wxART_UNDO);
3514 static const wxString wxPyART_REDO(wxART_REDO);
3515 static const wxString wxPyART_QUIT(wxART_QUIT);
3516 static const wxString wxPyART_FIND(wxART_FIND);
3517 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3518 // Python aware wxArtProvider
3519 class wxPyArtProvider : public wxArtProvider {
3520 public:
3521
3522 virtual wxBitmap CreateBitmap(const wxArtID& id,
3523 const wxArtClient& client,
3524 const wxSize& size) {
3525 wxBitmap rval = wxNullBitmap;
3526 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3527 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3528 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3529 PyObject* ro;
3530 wxBitmap* ptr;
3531 PyObject* s1, *s2;
3532 s1 = wx2PyString(id);
3533 s2 = wx2PyString(client);
3534 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3535 Py_DECREF(so);
3536 Py_DECREF(s1);
3537 Py_DECREF(s2);
3538 if (ro) {
3539 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3540 rval = *ptr;
3541 Py_DECREF(ro);
3542 }
3543 }
3544 wxPyEndBlockThreads(blocked);
3545 return rval;
3546 }
3547
3548 PYPRIVATE;
3549 };
3550
3551 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3552
3553
3554
3555 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3556 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3557 PyObject* ret = PyTuple_New(3);
3558 if (ret) {
3559 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3560 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3561 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3562 }
3563 wxPyEndBlockThreads(blocked);
3564 return ret;
3565 }
3566
3567 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3568 bool cont;
3569 long index = 0;
3570 wxString value;
3571
3572 cont = self->GetFirstGroup(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3576 bool cont;
3577 wxString value;
3578
3579 cont = self->GetNextGroup(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3583 bool cont;
3584 long index = 0;
3585 wxString value;
3586
3587 cont = self->GetFirstEntry(value, index);
3588 return __EnumerationHelper(cont, value, index);
3589 }
3590 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3591 bool cont;
3592 wxString value;
3593
3594 cont = self->GetNextEntry(value, index);
3595 return __EnumerationHelper(cont, value, index);
3596 }
3597 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3598 long rv;
3599 self->Read(key, &rv, defaultVal);
3600 return rv;
3601 }
3602
3603 SWIGINTERN int
3604 SWIG_AsVal_double (PyObject *obj, double* val)
3605 {
3606 if (PyNumber_Check(obj)) {
3607 if (val) *val = PyFloat_AsDouble(obj);
3608 return SWIG_OK;
3609 }
3610 return SWIG_TypeError;
3611 }
3612
3613 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3614 double rv;
3615 self->Read(key, &rv, defaultVal);
3616 return rv;
3617 }
3618
3619 #define SWIG_From_double PyFloat_FromDouble
3620
3621 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3622 bool rv;
3623 self->Read(key, &rv, defaultVal);
3624 return rv;
3625 }
3626
3627 #include <wx/datetime.h>
3628
3629 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3630 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3631
3632 #define LOCAL_TZ wxDateTime::Local
3633
3634 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3635 wxString am;
3636 wxString pm;
3637 wxDateTime::GetAmPmStrings(&am, &pm);
3638 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3639 PyObject* tup = PyTuple_New(2);
3640 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3641 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3642 wxPyEndBlockThreads(blocked);
3643 return tup;
3644 }
3645
3646 SWIGINTERNINLINE PyObject *
3647 SWIG_From_unsigned_SS_int (unsigned int value)
3648 {
3649 return SWIG_From_unsigned_SS_long (value);
3650 }
3651
3652 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3653 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3654 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3655 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3656 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3657 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3659 return (*self < *other);
3660 }
3661 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3662 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3663 return (*self <= *other);
3664 }
3665 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3666 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3667 return (*self > *other);
3668 }
3669 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3670 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3671 return (*self >= *other);
3672 }
3673 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3674 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3675 return (*self == *other);
3676 }
3677 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3678 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3679 return (*self != *other);
3680 }
3681 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3682 const wxChar* rv;
3683 const wxChar* _date = date;
3684 rv = self->ParseRfc822Date(_date);
3685 if (rv == NULL) return -1;
3686 return rv - _date;
3687 }
3688 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3689 const wxChar* rv;
3690 const wxChar* _date = date;
3691 rv = self->ParseFormat(_date, format, dateDef);
3692 if (rv == NULL) return -1;
3693 return rv - _date;
3694 }
3695 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3696 const wxChar* rv;
3697 const wxChar* _datetime = datetime;
3698 rv = self->ParseDateTime(_datetime);
3699 if (rv == NULL) return -1;
3700 return rv - _datetime;
3701 }
3702 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3703 const wxChar* rv;
3704 const wxChar* _date = date;
3705 rv = self->ParseDate(_date);
3706 if (rv == NULL) return -1;
3707 return rv - _date;
3708 }
3709 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3710 const wxChar* rv;
3711 const wxChar* _time = time;
3712 rv = self->ParseTime(_time);
3713 if (rv == NULL) return -1;
3714 return rv - _time;
3715 }
3716 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3717 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3718 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3719 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3720 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3721 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3722 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3723 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3724 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3725 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3726 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3727 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3728 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3729 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3730 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3731 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3732
3733 #include <wx/dataobj.h>
3734
3735 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3736 size_t count = self->GetFormatCount(dir);
3737 wxDataFormat* formats = new wxDataFormat[count];
3738 self->GetAllFormats(formats, dir);
3739
3740 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3741 PyObject* list = PyList_New(count);
3742 for (size_t i=0; i<count; i++) {
3743 wxDataFormat* format = new wxDataFormat(formats[i]);
3744 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3745 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3746 }
3747 wxPyEndBlockThreads(blocked);
3748 delete [] formats;
3749 return list;
3750 }
3751 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3752 PyObject* rval = NULL;
3753 size_t size = self->GetDataSize(format);
3754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3755 if (size) {
3756 char* buf = new char[size];
3757 if (self->GetDataHere(format, buf))
3758 rval = PyString_FromStringAndSize(buf, size);
3759 delete [] buf;
3760 }
3761 if (! rval) {
3762 rval = Py_None;
3763 Py_INCREF(rval);
3764 }
3765 wxPyEndBlockThreads(blocked);
3766 return rval;
3767 }
3768 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3769 bool rval;
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 if (PyString_Check(data)) {
3772 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3773 }
3774 else {
3775 // raise a TypeError if not a string
3776 PyErr_SetString(PyExc_TypeError, "String expected.");
3777 rval = false;
3778 }
3779 wxPyEndBlockThreads(blocked);
3780 return rval;
3781 }
3782 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3783 PyObject* rval = NULL;
3784 size_t size = self->GetDataSize();
3785 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3786 if (size) {
3787 char* buf = new char[size];
3788 if (self->GetDataHere(buf))
3789 rval = PyString_FromStringAndSize(buf, size);
3790 delete [] buf;
3791 }
3792 if (! rval) {
3793 rval = Py_None;
3794 Py_INCREF(rval);
3795 }
3796 wxPyEndBlockThreads(blocked);
3797 return rval;
3798 }
3799 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3800 bool rval;
3801 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3802 if (PyString_Check(data)) {
3803 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3804 }
3805 else {
3806 // raise a TypeError if not a string
3807 PyErr_SetString(PyExc_TypeError, "String expected.");
3808 rval = false;
3809 }
3810 wxPyEndBlockThreads(blocked);
3811 return rval;
3812 }
3813 // Create a new class for wxPython to use
3814 class wxPyDataObjectSimple : public wxDataObjectSimple {
3815 public:
3816 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3817 : wxDataObjectSimple(format) {}
3818
3819 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3820 bool GetDataHere(void *buf) const;
3821 bool SetData(size_t len, const void *buf);
3822 PYPRIVATE;
3823 };
3824
3825 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3826
3827 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3828 // We need to get the data for this object and write it to buf. I think
3829 // the best way to do this for wxPython is to have the Python method
3830 // return either a string or None and then act appropriately with the
3831 // C++ version.
3832
3833 bool rval = false;
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3836 PyObject* ro;
3837 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3838 if (ro) {
3839 rval = (ro != Py_None && PyString_Check(ro));
3840 if (rval)
3841 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3842 Py_DECREF(ro);
3843 }
3844 }
3845 wxPyEndBlockThreads(blocked);
3846 return rval;
3847 }
3848
3849 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3850 // For this one we simply need to make a string from buf and len
3851 // and send it to the Python method.
3852 bool rval = false;
3853 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3854 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3855 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3856 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3857 Py_DECREF(data);
3858 }
3859 wxPyEndBlockThreads(blocked);
3860 return rval;
3861 }
3862
3863 // Create a new class for wxPython to use
3864 class wxPyTextDataObject : public wxTextDataObject {
3865 public:
3866 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3867 : wxTextDataObject(text) {}
3868
3869 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3870 DEC_PYCALLBACK_STRING__const(GetText);
3871 DEC_PYCALLBACK__STRING(SetText);
3872 PYPRIVATE;
3873 };
3874
3875 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3876 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3877 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3878
3879
3880 // Create a new class for wxPython to use
3881 class wxPyBitmapDataObject : public wxBitmapDataObject {
3882 public:
3883 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3884 : wxBitmapDataObject(bitmap) {}
3885
3886 wxBitmap GetBitmap() const;
3887 void SetBitmap(const wxBitmap& bitmap);
3888 PYPRIVATE;
3889 };
3890
3891 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3892 wxBitmap* rval = &wxNullBitmap;
3893 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3894 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3895 PyObject* ro;
3896 wxBitmap* ptr;
3897 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3898 if (ro) {
3899 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3900 rval = ptr;
3901 Py_DECREF(ro);
3902 }
3903 }
3904 wxPyEndBlockThreads(blocked);
3905 return *rval;
3906 }
3907
3908 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3910 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3911 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3912 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3913 Py_DECREF(bo);
3914 }
3915 wxPyEndBlockThreads(blocked);
3916 }
3917
3918 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3919 return new wxCustomDataObject(wxDataFormat(formatName));
3920 }
3921 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3922 bool rval;
3923 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3924 if (PyString_Check(data)) {
3925 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3926 }
3927 else {
3928 // raise a TypeError if not a string
3929 PyErr_SetString(PyExc_TypeError, "String expected.");
3930 rval = false;
3931 }
3932 wxPyEndBlockThreads(blocked);
3933 return rval;
3934 }
3935 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3936 PyObject* obj;
3937 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3938 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3939 wxPyEndBlockThreads(blocked);
3940 return obj;
3941 }
3942
3943 class wxMetafileDataObject : public wxDataObjectSimple
3944 {
3945 public:
3946 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3947 };
3948
3949
3950 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3951
3952
3953 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3954 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3955 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3956 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3957 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3958
3959
3960 class wxPyTextDropTarget : public wxTextDropTarget {
3961 public:
3962 wxPyTextDropTarget() {}
3963
3964 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3965
3966 DEC_PYCALLBACK__(OnLeave);
3967 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3968 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3969 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3970 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3971
3972 PYPRIVATE;
3973 };
3974
3975 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3976 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3977 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3978 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3979 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3980 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3981
3982
3983
3984 class wxPyFileDropTarget : public wxFileDropTarget {
3985 public:
3986 wxPyFileDropTarget() {}
3987
3988 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3989
3990 DEC_PYCALLBACK__(OnLeave);
3991 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3992 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3993 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3994 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3995
3996 PYPRIVATE;
3997 };
3998
3999 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
4000 const wxArrayString& filenames) {
4001 bool rval = false;
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
4004 PyObject* list = wxArrayString2PyList_helper(filenames);
4005 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
4006 Py_DECREF(list);
4007 }
4008 wxPyEndBlockThreads(blocked);
4009 return rval;
4010 }
4011
4012
4013
4014 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4015 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4016 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4017 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4018 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4019
4020
4021
4022
4023 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4024
4025 #include <wx/display.h>
4026 #include <wx/vidmode.h>
4027
4028 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4029 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4030
4031 #if !wxUSE_DISPLAY
4032 const wxVideoMode wxDefaultVideoMode;
4033 #endif
4034
4035 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4036 #if wxUSE_DISPLAY
4037 PyObject* pyList = NULL;
4038 wxArrayVideoModes arr = self->GetModes(mode);
4039 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4040 pyList = PyList_New(0);
4041 for (size_t i=0; i < arr.GetCount(); i++)
4042 {
4043 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4044 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4045 PyList_Append(pyList, pyObj);
4046 Py_DECREF(pyObj);
4047 }
4048 wxPyEndBlockThreads(blocked);
4049 return pyList;
4050 #else
4051 wxPyRaiseNotImplemented();
4052 return NULL;
4053 #endif
4054 }
4055 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4056 #if wxUSE_DISPLAY
4057 return self->GetCurrentMode();
4058 #else
4059 wxPyRaiseNotImplemented();
4060 return wxDefaultVideoMode;
4061 #endif
4062 }
4063 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4064 #if wxUSE_DISPLAY
4065 return self->ChangeMode(mode);
4066 #else
4067 wxPyRaiseNotImplemented();
4068 return false;
4069 #endif
4070 }
4071 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4072 #if wxUSE_DISPLAY
4073 self->ResetMode();
4074 #else
4075 wxPyRaiseNotImplemented();
4076 #endif
4077 }
4078
4079 #include <wx/stdpaths.h>
4080
4081 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4082 return (wxStandardPaths*) &wxStandardPaths::Get();
4083 }
4084
4085 #ifndef wxHAS_POWER_EVENTS
4086 // Dummy class and other definitions for platforms that don't have them
4087
4088 // See wxPython_int.h for wxPowerEvent
4089
4090 enum {
4091 wxEVT_POWER_SUSPENDING,
4092 wxEVT_POWER_SUSPENDED,
4093 wxEVT_POWER_SUSPEND_CANCEL,
4094 wxEVT_POWER_RESUME,
4095 };
4096
4097 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4098 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4099
4100 #endif
4101
4102
4103 #include <wx/aboutdlg.h>
4104
4105 #ifdef __cplusplus
4106 extern "C" {
4107 #endif
4108 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj = 0;
4110 wxSystemColour arg1 ;
4111 wxColour result;
4112 int val1 ;
4113 int ecode1 = 0 ;
4114 PyObject * obj0 = 0 ;
4115 char * kwnames[] = {
4116 (char *) "index", NULL
4117 };
4118
4119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4120 ecode1 = SWIG_AsVal_int(obj0, &val1);
4121 if (!SWIG_IsOK(ecode1)) {
4122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4123 }
4124 arg1 = static_cast< wxSystemColour >(val1);
4125 {
4126 if (!wxPyCheckForApp()) SWIG_fail;
4127 PyThreadState* __tstate = wxPyBeginAllowThreads();
4128 result = wxSystemSettings::GetColour(arg1);
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4133 return resultobj;
4134 fail:
4135 return NULL;
4136 }
4137
4138
4139 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4140 PyObject *resultobj = 0;
4141 wxSystemFont arg1 ;
4142 wxFont result;
4143 int val1 ;
4144 int ecode1 = 0 ;
4145 PyObject * obj0 = 0 ;
4146 char * kwnames[] = {
4147 (char *) "index", NULL
4148 };
4149
4150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4151 ecode1 = SWIG_AsVal_int(obj0, &val1);
4152 if (!SWIG_IsOK(ecode1)) {
4153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4154 }
4155 arg1 = static_cast< wxSystemFont >(val1);
4156 {
4157 if (!wxPyCheckForApp()) SWIG_fail;
4158 PyThreadState* __tstate = wxPyBeginAllowThreads();
4159 result = wxSystemSettings::GetFont(arg1);
4160 wxPyEndAllowThreads(__tstate);
4161 if (PyErr_Occurred()) SWIG_fail;
4162 }
4163 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4164 return resultobj;
4165 fail:
4166 return NULL;
4167 }
4168
4169
4170 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4171 PyObject *resultobj = 0;
4172 wxSystemMetric arg1 ;
4173 wxWindow *arg2 = (wxWindow *) NULL ;
4174 int result;
4175 int val1 ;
4176 int ecode1 = 0 ;
4177 void *argp2 = 0 ;
4178 int res2 = 0 ;
4179 PyObject * obj0 = 0 ;
4180 PyObject * obj1 = 0 ;
4181 char * kwnames[] = {
4182 (char *) "index",(char *) "win", NULL
4183 };
4184
4185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4186 ecode1 = SWIG_AsVal_int(obj0, &val1);
4187 if (!SWIG_IsOK(ecode1)) {
4188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4189 }
4190 arg1 = static_cast< wxSystemMetric >(val1);
4191 if (obj1) {
4192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4193 if (!SWIG_IsOK(res2)) {
4194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4195 }
4196 arg2 = reinterpret_cast< wxWindow * >(argp2);
4197 }
4198 {
4199 if (!wxPyCheckForApp()) SWIG_fail;
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4202 wxPyEndAllowThreads(__tstate);
4203 if (PyErr_Occurred()) SWIG_fail;
4204 }
4205 resultobj = SWIG_From_int(static_cast< int >(result));
4206 return resultobj;
4207 fail:
4208 return NULL;
4209 }
4210
4211
4212 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4213 PyObject *resultobj = 0;
4214 wxSystemFeature arg1 ;
4215 bool result;
4216 int val1 ;
4217 int ecode1 = 0 ;
4218 PyObject * obj0 = 0 ;
4219 char * kwnames[] = {
4220 (char *) "index", NULL
4221 };
4222
4223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4224 ecode1 = SWIG_AsVal_int(obj0, &val1);
4225 if (!SWIG_IsOK(ecode1)) {
4226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4227 }
4228 arg1 = static_cast< wxSystemFeature >(val1);
4229 {
4230 if (!wxPyCheckForApp()) SWIG_fail;
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (bool)wxSystemSettings::HasFeature(arg1);
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 {
4237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4238 }
4239 return resultobj;
4240 fail:
4241 return NULL;
4242 }
4243
4244
4245 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4246 PyObject *resultobj = 0;
4247 wxSystemScreenType result;
4248
4249 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4250 {
4251 if (!wxPyCheckForApp()) SWIG_fail;
4252 PyThreadState* __tstate = wxPyBeginAllowThreads();
4253 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4254 wxPyEndAllowThreads(__tstate);
4255 if (PyErr_Occurred()) SWIG_fail;
4256 }
4257 resultobj = SWIG_From_int(static_cast< int >(result));
4258 return resultobj;
4259 fail:
4260 return NULL;
4261 }
4262
4263
4264 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4265 PyObject *resultobj = 0;
4266 wxSystemScreenType arg1 ;
4267 int val1 ;
4268 int ecode1 = 0 ;
4269 PyObject * obj0 = 0 ;
4270 char * kwnames[] = {
4271 (char *) "screen", NULL
4272 };
4273
4274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4275 ecode1 = SWIG_AsVal_int(obj0, &val1);
4276 if (!SWIG_IsOK(ecode1)) {
4277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4278 }
4279 arg1 = static_cast< wxSystemScreenType >(val1);
4280 {
4281 if (!wxPyCheckForApp()) SWIG_fail;
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 wxSystemSettings::SetScreenType(arg1);
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 resultobj = SWIG_Py_Void();
4288 return resultobj;
4289 fail:
4290 return NULL;
4291 }
4292
4293
4294 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4295 PyObject *obj;
4296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4297 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4298 return SWIG_Py_Void();
4299 }
4300
4301 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4302 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4303 return 1;
4304 }
4305
4306
4307 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4308 PyObject *pyobj = 0;
4309
4310 {
4311 #if wxUSE_UNICODE
4312 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4313 #else
4314 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4315 #endif
4316 }
4317 return pyobj;
4318 }
4319
4320
4321 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4322 PyObject *resultobj = 0;
4323 wxSystemOptions *result = 0 ;
4324
4325 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4326 {
4327 PyThreadState* __tstate = wxPyBeginAllowThreads();
4328 result = (wxSystemOptions *)new wxSystemOptions();
4329 wxPyEndAllowThreads(__tstate);
4330 if (PyErr_Occurred()) SWIG_fail;
4331 }
4332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4333 return resultobj;
4334 fail:
4335 return NULL;
4336 }
4337
4338
4339 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4340 PyObject *resultobj = 0;
4341 wxString *arg1 = 0 ;
4342 wxString *arg2 = 0 ;
4343 bool temp1 = false ;
4344 bool temp2 = false ;
4345 PyObject * obj0 = 0 ;
4346 PyObject * obj1 = 0 ;
4347 char * kwnames[] = {
4348 (char *) "name",(char *) "value", NULL
4349 };
4350
4351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4352 {
4353 arg1 = wxString_in_helper(obj0);
4354 if (arg1 == NULL) SWIG_fail;
4355 temp1 = true;
4356 }
4357 {
4358 arg2 = wxString_in_helper(obj1);
4359 if (arg2 == NULL) SWIG_fail;
4360 temp2 = true;
4361 }
4362 {
4363 PyThreadState* __tstate = wxPyBeginAllowThreads();
4364 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4365 wxPyEndAllowThreads(__tstate);
4366 if (PyErr_Occurred()) SWIG_fail;
4367 }
4368 resultobj = SWIG_Py_Void();
4369 {
4370 if (temp1)
4371 delete arg1;
4372 }
4373 {
4374 if (temp2)
4375 delete arg2;
4376 }
4377 return resultobj;
4378 fail:
4379 {
4380 if (temp1)
4381 delete arg1;
4382 }
4383 {
4384 if (temp2)
4385 delete arg2;
4386 }
4387 return NULL;
4388 }
4389
4390
4391 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj = 0;
4393 wxString *arg1 = 0 ;
4394 int arg2 ;
4395 bool temp1 = false ;
4396 int val2 ;
4397 int ecode2 = 0 ;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 char * kwnames[] = {
4401 (char *) "name",(char *) "value", NULL
4402 };
4403
4404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4405 {
4406 arg1 = wxString_in_helper(obj0);
4407 if (arg1 == NULL) SWIG_fail;
4408 temp1 = true;
4409 }
4410 ecode2 = SWIG_AsVal_int(obj1, &val2);
4411 if (!SWIG_IsOK(ecode2)) {
4412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4413 }
4414 arg2 = static_cast< int >(val2);
4415 {
4416 PyThreadState* __tstate = wxPyBeginAllowThreads();
4417 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 resultobj = SWIG_Py_Void();
4422 {
4423 if (temp1)
4424 delete arg1;
4425 }
4426 return resultobj;
4427 fail:
4428 {
4429 if (temp1)
4430 delete arg1;
4431 }
4432 return NULL;
4433 }
4434
4435
4436 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4437 PyObject *resultobj = 0;
4438 wxString *arg1 = 0 ;
4439 wxString result;
4440 bool temp1 = false ;
4441 PyObject * obj0 = 0 ;
4442 char * kwnames[] = {
4443 (char *) "name", NULL
4444 };
4445
4446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4447 {
4448 arg1 = wxString_in_helper(obj0);
4449 if (arg1 == NULL) SWIG_fail;
4450 temp1 = true;
4451 }
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4455 wxPyEndAllowThreads(__tstate);
4456 if (PyErr_Occurred()) SWIG_fail;
4457 }
4458 {
4459 #if wxUSE_UNICODE
4460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4461 #else
4462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4463 #endif
4464 }
4465 {
4466 if (temp1)
4467 delete arg1;
4468 }
4469 return resultobj;
4470 fail:
4471 {
4472 if (temp1)
4473 delete arg1;
4474 }
4475 return NULL;
4476 }
4477
4478
4479 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4480 PyObject *resultobj = 0;
4481 wxString *arg1 = 0 ;
4482 int result;
4483 bool temp1 = false ;
4484 PyObject * obj0 = 0 ;
4485 char * kwnames[] = {
4486 (char *) "name", NULL
4487 };
4488
4489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4490 {
4491 arg1 = wxString_in_helper(obj0);
4492 if (arg1 == NULL) SWIG_fail;
4493 temp1 = true;
4494 }
4495 {
4496 PyThreadState* __tstate = wxPyBeginAllowThreads();
4497 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4498 wxPyEndAllowThreads(__tstate);
4499 if (PyErr_Occurred()) SWIG_fail;
4500 }
4501 resultobj = SWIG_From_int(static_cast< int >(result));
4502 {
4503 if (temp1)
4504 delete arg1;
4505 }
4506 return resultobj;
4507 fail:
4508 {
4509 if (temp1)
4510 delete arg1;
4511 }
4512 return NULL;
4513 }
4514
4515
4516 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj = 0;
4518 wxString *arg1 = 0 ;
4519 bool result;
4520 bool temp1 = false ;
4521 PyObject * obj0 = 0 ;
4522 char * kwnames[] = {
4523 (char *) "name", NULL
4524 };
4525
4526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4527 {
4528 arg1 = wxString_in_helper(obj0);
4529 if (arg1 == NULL) SWIG_fail;
4530 temp1 = true;
4531 }
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 {
4539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4540 }
4541 {
4542 if (temp1)
4543 delete arg1;
4544 }
4545 return resultobj;
4546 fail:
4547 {
4548 if (temp1)
4549 delete arg1;
4550 }
4551 return NULL;
4552 }
4553
4554
4555 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4556 PyObject *resultobj = 0;
4557 wxString *arg1 = 0 ;
4558 bool result;
4559 bool temp1 = false ;
4560 PyObject * obj0 = 0 ;
4561 char * kwnames[] = {
4562 (char *) "name", NULL
4563 };
4564
4565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4566 {
4567 arg1 = wxString_in_helper(obj0);
4568 if (arg1 == NULL) SWIG_fail;
4569 temp1 = true;
4570 }
4571 {
4572 PyThreadState* __tstate = wxPyBeginAllowThreads();
4573 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4574 wxPyEndAllowThreads(__tstate);
4575 if (PyErr_Occurred()) SWIG_fail;
4576 }
4577 {
4578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4579 }
4580 {
4581 if (temp1)
4582 delete arg1;
4583 }
4584 return resultobj;
4585 fail:
4586 {
4587 if (temp1)
4588 delete arg1;
4589 }
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *obj;
4596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4597 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4598 return SWIG_Py_Void();
4599 }
4600
4601 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4602 return SWIG_Python_InitShadowInstance(args);
4603 }
4604
4605 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4606 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4607 return 1;
4608 }
4609
4610
4611 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4612 PyObject *pyobj = 0;
4613
4614 {
4615 #if wxUSE_UNICODE
4616 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4617 #else
4618 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4619 #endif
4620 }
4621 return pyobj;
4622 }
4623
4624
4625 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4626 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4627 return 1;
4628 }
4629
4630
4631 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4632 PyObject *pyobj = 0;
4633
4634 {
4635 #if wxUSE_UNICODE
4636 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4637 #else
4638 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4639 #endif
4640 }
4641 return pyobj;
4642 }
4643
4644
4645 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4646 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4647 return 1;
4648 }
4649
4650
4651 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4652 PyObject *pyobj = 0;
4653
4654 {
4655 #if wxUSE_UNICODE
4656 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4657 #else
4658 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4659 #endif
4660 }
4661 return pyobj;
4662 }
4663
4664
4665 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4666 PyObject *resultobj = 0;
4667 long result;
4668
4669 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4670 {
4671 PyThreadState* __tstate = wxPyBeginAllowThreads();
4672 result = (long)wxNewId();
4673 wxPyEndAllowThreads(__tstate);
4674 if (PyErr_Occurred()) SWIG_fail;
4675 }
4676 resultobj = SWIG_From_long(static_cast< long >(result));
4677 return resultobj;
4678 fail:
4679 return NULL;
4680 }
4681
4682
4683 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4684 PyObject *resultobj = 0;
4685 long arg1 ;
4686 long val1 ;
4687 int ecode1 = 0 ;
4688 PyObject * obj0 = 0 ;
4689 char * kwnames[] = {
4690 (char *) "id", NULL
4691 };
4692
4693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4694 ecode1 = SWIG_AsVal_long(obj0, &val1);
4695 if (!SWIG_IsOK(ecode1)) {
4696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4697 }
4698 arg1 = static_cast< long >(val1);
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 wxRegisterId(arg1);
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 resultobj = SWIG_Py_Void();
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4713 PyObject *resultobj = 0;
4714 long result;
4715
4716 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 result = (long)wxGetCurrentId();
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 resultobj = SWIG_From_long(static_cast< long >(result));
4724 return resultobj;
4725 fail:
4726 return NULL;
4727 }
4728
4729
4730 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4731 PyObject *resultobj = 0;
4732 int arg1 ;
4733 bool result;
4734 int val1 ;
4735 int ecode1 = 0 ;
4736 PyObject * obj0 = 0 ;
4737 char * kwnames[] = {
4738 (char *) "id", NULL
4739 };
4740
4741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4742 ecode1 = SWIG_AsVal_int(obj0, &val1);
4743 if (!SWIG_IsOK(ecode1)) {
4744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4745 }
4746 arg1 = static_cast< int >(val1);
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (bool)wxIsStockID(arg1);
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 {
4754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4755 }
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 int arg1 ;
4765 wxString *arg2 = 0 ;
4766 bool result;
4767 int val1 ;
4768 int ecode1 = 0 ;
4769 bool temp2 = false ;
4770 PyObject * obj0 = 0 ;
4771 PyObject * obj1 = 0 ;
4772 char * kwnames[] = {
4773 (char *) "id",(char *) "label", NULL
4774 };
4775
4776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4777 ecode1 = SWIG_AsVal_int(obj0, &val1);
4778 if (!SWIG_IsOK(ecode1)) {
4779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4780 }
4781 arg1 = static_cast< int >(val1);
4782 {
4783 arg2 = wxString_in_helper(obj1);
4784 if (arg2 == NULL) SWIG_fail;
4785 temp2 = true;
4786 }
4787 {
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 {
4794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4795 }
4796 {
4797 if (temp2)
4798 delete arg2;
4799 }
4800 return resultobj;
4801 fail:
4802 {
4803 if (temp2)
4804 delete arg2;
4805 }
4806 return NULL;
4807 }
4808
4809
4810 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4811 PyObject *resultobj = 0;
4812 int arg1 ;
4813 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4814 wxString result;
4815 int val1 ;
4816 int ecode1 = 0 ;
4817 long val2 ;
4818 int ecode2 = 0 ;
4819 PyObject * obj0 = 0 ;
4820 PyObject * obj1 = 0 ;
4821 char * kwnames[] = {
4822 (char *) "id",(char *) "flags", NULL
4823 };
4824
4825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4826 ecode1 = SWIG_AsVal_int(obj0, &val1);
4827 if (!SWIG_IsOK(ecode1)) {
4828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4829 }
4830 arg1 = static_cast< int >(val1);
4831 if (obj1) {
4832 ecode2 = SWIG_AsVal_long(obj1, &val2);
4833 if (!SWIG_IsOK(ecode2)) {
4834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4835 }
4836 arg2 = static_cast< long >(val2);
4837 }
4838 {
4839 PyThreadState* __tstate = wxPyBeginAllowThreads();
4840 result = wxGetStockLabel(arg1,arg2);
4841 wxPyEndAllowThreads(__tstate);
4842 if (PyErr_Occurred()) SWIG_fail;
4843 }
4844 {
4845 #if wxUSE_UNICODE
4846 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4847 #else
4848 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4849 #endif
4850 }
4851 return resultobj;
4852 fail:
4853 return NULL;
4854 }
4855
4856
4857 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4858 PyObject *resultobj = 0;
4859 int arg1 ;
4860 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4861 wxString result;
4862 int val1 ;
4863 int ecode1 = 0 ;
4864 int val2 ;
4865 int ecode2 = 0 ;
4866 PyObject * obj0 = 0 ;
4867 PyObject * obj1 = 0 ;
4868 char * kwnames[] = {
4869 (char *) "id",(char *) "client", NULL
4870 };
4871
4872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4873 ecode1 = SWIG_AsVal_int(obj0, &val1);
4874 if (!SWIG_IsOK(ecode1)) {
4875 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4876 }
4877 arg1 = static_cast< int >(val1);
4878 if (obj1) {
4879 ecode2 = SWIG_AsVal_int(obj1, &val2);
4880 if (!SWIG_IsOK(ecode2)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4882 }
4883 arg2 = static_cast< wxStockHelpStringClient >(val2);
4884 }
4885 {
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 result = wxGetStockHelpString(arg1,arg2);
4888 wxPyEndAllowThreads(__tstate);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 {
4892 #if wxUSE_UNICODE
4893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4894 #else
4895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4896 #endif
4897 }
4898 return resultobj;
4899 fail:
4900 return NULL;
4901 }
4902
4903
4904 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4905 PyObject *resultobj = 0;
4906
4907 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4908 {
4909 if (!wxPyCheckForApp()) SWIG_fail;
4910 PyThreadState* __tstate = wxPyBeginAllowThreads();
4911 wxBell();
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 resultobj = SWIG_Py_Void();
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4923 PyObject *resultobj = 0;
4924
4925 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4926 {
4927 if (!wxPyCheckForApp()) SWIG_fail;
4928 PyThreadState* __tstate = wxPyBeginAllowThreads();
4929 wxEndBusyCursor();
4930 wxPyEndAllowThreads(__tstate);
4931 if (PyErr_Occurred()) SWIG_fail;
4932 }
4933 resultobj = SWIG_Py_Void();
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941 PyObject *resultobj = 0;
4942 bool result;
4943
4944 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4945 {
4946 PyThreadState* __tstate = wxPyBeginAllowThreads();
4947 result = (bool)wxIsBusy();
4948 wxPyEndAllowThreads(__tstate);
4949 if (PyErr_Occurred()) SWIG_fail;
4950 }
4951 {
4952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4953 }
4954 return resultobj;
4955 fail:
4956 return NULL;
4957 }
4958
4959
4960 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4961 PyObject *resultobj = 0;
4962 wxString result;
4963
4964 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4965 {
4966 PyThreadState* __tstate = wxPyBeginAllowThreads();
4967 result = wxNow();
4968 wxPyEndAllowThreads(__tstate);
4969 if (PyErr_Occurred()) SWIG_fail;
4970 }
4971 {
4972 #if wxUSE_UNICODE
4973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4974 #else
4975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4976 #endif
4977 }
4978 return resultobj;
4979 fail:
4980 return NULL;
4981 }
4982
4983
4984 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4985 PyObject *resultobj = 0;
4986 wxString const &arg1_defvalue = wxPyEmptyString ;
4987 wxString *arg1 = (wxString *) &arg1_defvalue ;
4988 bool result;
4989 bool temp1 = false ;
4990 PyObject * obj0 = 0 ;
4991 char * kwnames[] = {
4992 (char *) "command", NULL
4993 };
4994
4995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4996 if (obj0) {
4997 {
4998 arg1 = wxString_in_helper(obj0);
4999 if (arg1 == NULL) SWIG_fail;
5000 temp1 = true;
5001 }
5002 }
5003 {
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 result = (bool)wxShell((wxString const &)*arg1);
5006 wxPyEndAllowThreads(__tstate);
5007 if (PyErr_Occurred()) SWIG_fail;
5008 }
5009 {
5010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5011 }
5012 {
5013 if (temp1)
5014 delete arg1;
5015 }
5016 return resultobj;
5017 fail:
5018 {
5019 if (temp1)
5020 delete arg1;
5021 }
5022 return NULL;
5023 }
5024
5025
5026 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5027 PyObject *resultobj = 0;
5028 int *arg1 = (int *) 0 ;
5029 int *arg2 = (int *) 0 ;
5030 int result;
5031 int temp1 ;
5032 int res1 = SWIG_TMPOBJ ;
5033 int temp2 ;
5034 int res2 = SWIG_TMPOBJ ;
5035
5036 arg1 = &temp1;
5037 arg2 = &temp2;
5038 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (int)wxGetOsVersion(arg1,arg2);
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 resultobj = SWIG_From_int(static_cast< int >(result));
5046 if (SWIG_IsTmpObj(res1)) {
5047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5048 } else {
5049 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5051 }
5052 if (SWIG_IsTmpObj(res2)) {
5053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5054 } else {
5055 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5057 }
5058 return resultobj;
5059 fail:
5060 return NULL;
5061 }
5062
5063
5064 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5065 PyObject *resultobj = 0;
5066 wxString result;
5067
5068 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5069 {
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 result = wxGetOsDescription();
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 {
5076 #if wxUSE_UNICODE
5077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5078 #else
5079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5080 #endif
5081 }
5082 return resultobj;
5083 fail:
5084 return NULL;
5085 }
5086
5087
5088 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5089 PyObject *resultobj = 0;
5090 bool result;
5091
5092 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5093 {
5094 PyThreadState* __tstate = wxPyBeginAllowThreads();
5095 result = (bool)wxIsPlatformLittleEndian();
5096 wxPyEndAllowThreads(__tstate);
5097 if (PyErr_Occurred()) SWIG_fail;
5098 }
5099 {
5100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5101 }
5102 return resultobj;
5103 fail:
5104 return NULL;
5105 }
5106
5107
5108 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5109 PyObject *resultobj = 0;
5110 bool result;
5111
5112 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5113 {
5114 PyThreadState* __tstate = wxPyBeginAllowThreads();
5115 result = (bool)wxIsPlatform64Bit();
5116 wxPyEndAllowThreads(__tstate);
5117 if (PyErr_Occurred()) SWIG_fail;
5118 }
5119 {
5120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5121 }
5122 return resultobj;
5123 fail:
5124 return NULL;
5125 }
5126
5127
5128 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5129 PyObject *resultobj = 0;
5130 wxMemorySize result;
5131
5132 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = wxGetFreeMemory();
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 {
5140 #if wxUSE_LONGLONG
5141 resultobj = PyLong_FromLongLong((&result)->GetValue());
5142 #else
5143 resultobj = PyInt_FromLong(result);
5144 #endif
5145 }
5146 return resultobj;
5147 fail:
5148 return NULL;
5149 }
5150
5151
5152 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5153 PyObject *resultobj = 0;
5154 wxShutdownFlags arg1 ;
5155 bool result;
5156 int val1 ;
5157 int ecode1 = 0 ;
5158 PyObject * obj0 = 0 ;
5159 char * kwnames[] = {
5160 (char *) "wFlags", NULL
5161 };
5162
5163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5164 ecode1 = SWIG_AsVal_int(obj0, &val1);
5165 if (!SWIG_IsOK(ecode1)) {
5166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5167 }
5168 arg1 = static_cast< wxShutdownFlags >(val1);
5169 {
5170 if (!wxPyCheckForApp()) SWIG_fail;
5171 PyThreadState* __tstate = wxPyBeginAllowThreads();
5172 result = (bool)wxShutdown(arg1);
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 {
5177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5178 }
5179 return resultobj;
5180 fail:
5181 return NULL;
5182 }
5183
5184
5185 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5186 PyObject *resultobj = 0;
5187 int arg1 ;
5188 int val1 ;
5189 int ecode1 = 0 ;
5190 PyObject * obj0 = 0 ;
5191 char * kwnames[] = {
5192 (char *) "secs", NULL
5193 };
5194
5195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5196 ecode1 = SWIG_AsVal_int(obj0, &val1);
5197 if (!SWIG_IsOK(ecode1)) {
5198 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5199 }
5200 arg1 = static_cast< int >(val1);
5201 {
5202 PyThreadState* __tstate = wxPyBeginAllowThreads();
5203 wxSleep(arg1);
5204 wxPyEndAllowThreads(__tstate);
5205 if (PyErr_Occurred()) SWIG_fail;
5206 }
5207 resultobj = SWIG_Py_Void();
5208 return resultobj;
5209 fail:
5210 return NULL;
5211 }
5212
5213
5214 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5215 PyObject *resultobj = 0;
5216 unsigned long arg1 ;
5217 unsigned long val1 ;
5218 int ecode1 = 0 ;
5219 PyObject * obj0 = 0 ;
5220 char * kwnames[] = {
5221 (char *) "milliseconds", NULL
5222 };
5223
5224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5225 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5226 if (!SWIG_IsOK(ecode1)) {
5227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5228 }
5229 arg1 = static_cast< unsigned long >(val1);
5230 {
5231 PyThreadState* __tstate = wxPyBeginAllowThreads();
5232 wxMilliSleep(arg1);
5233 wxPyEndAllowThreads(__tstate);
5234 if (PyErr_Occurred()) SWIG_fail;
5235 }
5236 resultobj = SWIG_Py_Void();
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj = 0;
5245 unsigned long arg1 ;
5246 unsigned long val1 ;
5247 int ecode1 = 0 ;
5248 PyObject * obj0 = 0 ;
5249 char * kwnames[] = {
5250 (char *) "microseconds", NULL
5251 };
5252
5253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5254 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5255 if (!SWIG_IsOK(ecode1)) {
5256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5257 }
5258 arg1 = static_cast< unsigned long >(val1);
5259 {
5260 PyThreadState* __tstate = wxPyBeginAllowThreads();
5261 wxMicroSleep(arg1);
5262 wxPyEndAllowThreads(__tstate);
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 resultobj = SWIG_Py_Void();
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj = 0;
5274 bool arg1 ;
5275 bool val1 ;
5276 int ecode1 = 0 ;
5277 PyObject * obj0 = 0 ;
5278 char * kwnames[] = {
5279 (char *) "enable", NULL
5280 };
5281
5282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5283 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5284 if (!SWIG_IsOK(ecode1)) {
5285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5286 }
5287 arg1 = static_cast< bool >(val1);
5288 {
5289 PyThreadState* __tstate = wxPyBeginAllowThreads();
5290 wxEnableTopLevelWindows(arg1);
5291 wxPyEndAllowThreads(__tstate);
5292 if (PyErr_Occurred()) SWIG_fail;
5293 }
5294 resultobj = SWIG_Py_Void();
5295 return resultobj;
5296 fail:
5297 return NULL;
5298 }
5299
5300
5301 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5302 PyObject *resultobj = 0;
5303 wxString *arg1 = 0 ;
5304 wxString result;
5305 bool temp1 = false ;
5306 PyObject * obj0 = 0 ;
5307 char * kwnames[] = {
5308 (char *) "in", NULL
5309 };
5310
5311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5312 {
5313 arg1 = wxString_in_helper(obj0);
5314 if (arg1 == NULL) SWIG_fail;
5315 temp1 = true;
5316 }
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 result = wxStripMenuCodes((wxString const &)*arg1);
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 {
5324 #if wxUSE_UNICODE
5325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5326 #else
5327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5328 #endif
5329 }
5330 {
5331 if (temp1)
5332 delete arg1;
5333 }
5334 return resultobj;
5335 fail:
5336 {
5337 if (temp1)
5338 delete arg1;
5339 }
5340 return NULL;
5341 }
5342
5343
5344 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 PyObject *resultobj = 0;
5346 wxString result;
5347
5348 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = wxGetEmailAddress();
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 {
5356 #if wxUSE_UNICODE
5357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5358 #else
5359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5360 #endif
5361 }
5362 return resultobj;
5363 fail:
5364 return NULL;
5365 }
5366
5367
5368 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5369 PyObject *resultobj = 0;
5370 wxString result;
5371
5372 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5373 {
5374 PyThreadState* __tstate = wxPyBeginAllowThreads();
5375 result = wxGetHostName();
5376 wxPyEndAllowThreads(__tstate);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 {
5380 #if wxUSE_UNICODE
5381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5382 #else
5383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5384 #endif
5385 }
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 wxString result;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = wxGetFullHostName();
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 {
5404 #if wxUSE_UNICODE
5405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5406 #else
5407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5408 #endif
5409 }
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxString result;
5419
5420 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = wxGetUserId();
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 #if wxUSE_UNICODE
5429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5430 #else
5431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5432 #endif
5433 }
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5441 PyObject *resultobj = 0;
5442 wxString result;
5443
5444 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 result = wxGetUserName();
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 {
5452 #if wxUSE_UNICODE
5453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5454 #else
5455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5456 #endif
5457 }
5458 return resultobj;
5459 fail:
5460 return NULL;
5461 }
5462
5463
5464 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5465 PyObject *resultobj = 0;
5466 wxString result;
5467
5468 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = wxGetHomeDir();
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 {
5476 #if wxUSE_UNICODE
5477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5478 #else
5479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5480 #endif
5481 }
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5489 PyObject *resultobj = 0;
5490 wxString const &arg1_defvalue = wxPyEmptyString ;
5491 wxString *arg1 = (wxString *) &arg1_defvalue ;
5492 wxString result;
5493 bool temp1 = false ;
5494 PyObject * obj0 = 0 ;
5495 char * kwnames[] = {
5496 (char *) "user", NULL
5497 };
5498
5499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5500 if (obj0) {
5501 {
5502 arg1 = wxString_in_helper(obj0);
5503 if (arg1 == NULL) SWIG_fail;
5504 temp1 = true;
5505 }
5506 }
5507 {
5508 PyThreadState* __tstate = wxPyBeginAllowThreads();
5509 result = wxGetUserHome((wxString const &)*arg1);
5510 wxPyEndAllowThreads(__tstate);
5511 if (PyErr_Occurred()) SWIG_fail;
5512 }
5513 {
5514 #if wxUSE_UNICODE
5515 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5516 #else
5517 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5518 #endif
5519 }
5520 {
5521 if (temp1)
5522 delete arg1;
5523 }
5524 return resultobj;
5525 fail:
5526 {
5527 if (temp1)
5528 delete arg1;
5529 }
5530 return NULL;
5531 }
5532
5533
5534 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5535 PyObject *resultobj = 0;
5536 unsigned long result;
5537
5538 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5539 {
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = (unsigned long)wxGetProcessId();
5542 wxPyEndAllowThreads(__tstate);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5546 return resultobj;
5547 fail:
5548 return NULL;
5549 }
5550
5551
5552 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5553 PyObject *resultobj = 0;
5554
5555 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5556 {
5557 PyThreadState* __tstate = wxPyBeginAllowThreads();
5558 wxTrap();
5559 wxPyEndAllowThreads(__tstate);
5560 if (PyErr_Occurred()) SWIG_fail;
5561 }
5562 resultobj = SWIG_Py_Void();
5563 return resultobj;
5564 fail:
5565 return NULL;
5566 }
5567
5568
5569 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5570 PyObject *resultobj = 0;
5571 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5572 wxString *arg1 = (wxString *) &arg1_defvalue ;
5573 wxString const &arg2_defvalue = wxPyEmptyString ;
5574 wxString *arg2 = (wxString *) &arg2_defvalue ;
5575 wxString const &arg3_defvalue = wxPyEmptyString ;
5576 wxString *arg3 = (wxString *) &arg3_defvalue ;
5577 wxString const &arg4_defvalue = wxPyEmptyString ;
5578 wxString *arg4 = (wxString *) &arg4_defvalue ;
5579 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5580 wxString *arg5 = (wxString *) &arg5_defvalue ;
5581 int arg6 = (int) 0 ;
5582 wxWindow *arg7 = (wxWindow *) NULL ;
5583 int arg8 = (int) -1 ;
5584 int arg9 = (int) -1 ;
5585 wxString result;
5586 bool temp1 = false ;
5587 bool temp2 = false ;
5588 bool temp3 = false ;
5589 bool temp4 = false ;
5590 bool temp5 = false ;
5591 int val6 ;
5592 int ecode6 = 0 ;
5593 void *argp7 = 0 ;
5594 int res7 = 0 ;
5595 int val8 ;
5596 int ecode8 = 0 ;
5597 int val9 ;
5598 int ecode9 = 0 ;
5599 PyObject * obj0 = 0 ;
5600 PyObject * obj1 = 0 ;
5601 PyObject * obj2 = 0 ;
5602 PyObject * obj3 = 0 ;
5603 PyObject * obj4 = 0 ;
5604 PyObject * obj5 = 0 ;
5605 PyObject * obj6 = 0 ;
5606 PyObject * obj7 = 0 ;
5607 PyObject * obj8 = 0 ;
5608 char * kwnames[] = {
5609 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5610 };
5611
5612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5613 if (obj0) {
5614 {
5615 arg1 = wxString_in_helper(obj0);
5616 if (arg1 == NULL) SWIG_fail;
5617 temp1 = true;
5618 }
5619 }
5620 if (obj1) {
5621 {
5622 arg2 = wxString_in_helper(obj1);
5623 if (arg2 == NULL) SWIG_fail;
5624 temp2 = true;
5625 }
5626 }
5627 if (obj2) {
5628 {
5629 arg3 = wxString_in_helper(obj2);
5630 if (arg3 == NULL) SWIG_fail;
5631 temp3 = true;
5632 }
5633 }
5634 if (obj3) {
5635 {
5636 arg4 = wxString_in_helper(obj3);
5637 if (arg4 == NULL) SWIG_fail;
5638 temp4 = true;
5639 }
5640 }
5641 if (obj4) {
5642 {
5643 arg5 = wxString_in_helper(obj4);
5644 if (arg5 == NULL) SWIG_fail;
5645 temp5 = true;
5646 }
5647 }
5648 if (obj5) {
5649 ecode6 = SWIG_AsVal_int(obj5, &val6);
5650 if (!SWIG_IsOK(ecode6)) {
5651 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5652 }
5653 arg6 = static_cast< int >(val6);
5654 }
5655 if (obj6) {
5656 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5657 if (!SWIG_IsOK(res7)) {
5658 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5659 }
5660 arg7 = reinterpret_cast< wxWindow * >(argp7);
5661 }
5662 if (obj7) {
5663 ecode8 = SWIG_AsVal_int(obj7, &val8);
5664 if (!SWIG_IsOK(ecode8)) {
5665 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5666 }
5667 arg8 = static_cast< int >(val8);
5668 }
5669 if (obj8) {
5670 ecode9 = SWIG_AsVal_int(obj8, &val9);
5671 if (!SWIG_IsOK(ecode9)) {
5672 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5673 }
5674 arg9 = static_cast< int >(val9);
5675 }
5676 {
5677 if (!wxPyCheckForApp()) SWIG_fail;
5678 PyThreadState* __tstate = wxPyBeginAllowThreads();
5679 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5680 wxPyEndAllowThreads(__tstate);
5681 if (PyErr_Occurred()) SWIG_fail;
5682 }
5683 {
5684 #if wxUSE_UNICODE
5685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5686 #else
5687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5688 #endif
5689 }
5690 {
5691 if (temp1)
5692 delete arg1;
5693 }
5694 {
5695 if (temp2)
5696 delete arg2;
5697 }
5698 {
5699 if (temp3)
5700 delete arg3;
5701 }
5702 {
5703 if (temp4)
5704 delete arg4;
5705 }
5706 {
5707 if (temp5)
5708 delete arg5;
5709 }
5710 return resultobj;
5711 fail:
5712 {
5713 if (temp1)
5714 delete arg1;
5715 }
5716 {
5717 if (temp2)
5718 delete arg2;
5719 }
5720 {
5721 if (temp3)
5722 delete arg3;
5723 }
5724 {
5725 if (temp4)
5726 delete arg4;
5727 }
5728 {
5729 if (temp5)
5730 delete arg5;
5731 }
5732 return NULL;
5733 }
5734
5735
5736 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj = 0;
5738 wxString *arg1 = 0 ;
5739 wxString *arg2 = 0 ;
5740 wxString const &arg3_defvalue = wxPyEmptyString ;
5741 wxString *arg3 = (wxString *) &arg3_defvalue ;
5742 wxWindow *arg4 = (wxWindow *) NULL ;
5743 wxString result;
5744 bool temp1 = false ;
5745 bool temp2 = false ;
5746 bool temp3 = false ;
5747 void *argp4 = 0 ;
5748 int res4 = 0 ;
5749 PyObject * obj0 = 0 ;
5750 PyObject * obj1 = 0 ;
5751 PyObject * obj2 = 0 ;
5752 PyObject * obj3 = 0 ;
5753 char * kwnames[] = {
5754 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5755 };
5756
5757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5758 {
5759 arg1 = wxString_in_helper(obj0);
5760 if (arg1 == NULL) SWIG_fail;
5761 temp1 = true;
5762 }
5763 {
5764 arg2 = wxString_in_helper(obj1);
5765 if (arg2 == NULL) SWIG_fail;
5766 temp2 = true;
5767 }
5768 if (obj2) {
5769 {
5770 arg3 = wxString_in_helper(obj2);
5771 if (arg3 == NULL) SWIG_fail;
5772 temp3 = true;
5773 }
5774 }
5775 if (obj3) {
5776 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5777 if (!SWIG_IsOK(res4)) {
5778 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5779 }
5780 arg4 = reinterpret_cast< wxWindow * >(argp4);
5781 }
5782 {
5783 if (!wxPyCheckForApp()) SWIG_fail;
5784 PyThreadState* __tstate = wxPyBeginAllowThreads();
5785 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5786 wxPyEndAllowThreads(__tstate);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 {
5790 #if wxUSE_UNICODE
5791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5792 #else
5793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5794 #endif
5795 }
5796 {
5797 if (temp1)
5798 delete arg1;
5799 }
5800 {
5801 if (temp2)
5802 delete arg2;
5803 }
5804 {
5805 if (temp3)
5806 delete arg3;
5807 }
5808 return resultobj;
5809 fail:
5810 {
5811 if (temp1)
5812 delete arg1;
5813 }
5814 {
5815 if (temp2)
5816 delete arg2;
5817 }
5818 {
5819 if (temp3)
5820 delete arg3;
5821 }
5822 return NULL;
5823 }
5824
5825
5826 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj = 0;
5828 wxString *arg1 = 0 ;
5829 wxString *arg2 = 0 ;
5830 wxString const &arg3_defvalue = wxPyEmptyString ;
5831 wxString *arg3 = (wxString *) &arg3_defvalue ;
5832 wxWindow *arg4 = (wxWindow *) NULL ;
5833 wxString result;
5834 bool temp1 = false ;
5835 bool temp2 = false ;
5836 bool temp3 = false ;
5837 void *argp4 = 0 ;
5838 int res4 = 0 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 PyObject * obj2 = 0 ;
5842 PyObject * obj3 = 0 ;
5843 char * kwnames[] = {
5844 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5845 };
5846
5847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5848 {
5849 arg1 = wxString_in_helper(obj0);
5850 if (arg1 == NULL) SWIG_fail;
5851 temp1 = true;
5852 }
5853 {
5854 arg2 = wxString_in_helper(obj1);
5855 if (arg2 == NULL) SWIG_fail;
5856 temp2 = true;
5857 }
5858 if (obj2) {
5859 {
5860 arg3 = wxString_in_helper(obj2);
5861 if (arg3 == NULL) SWIG_fail;
5862 temp3 = true;
5863 }
5864 }
5865 if (obj3) {
5866 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5867 if (!SWIG_IsOK(res4)) {
5868 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5869 }
5870 arg4 = reinterpret_cast< wxWindow * >(argp4);
5871 }
5872 {
5873 if (!wxPyCheckForApp()) SWIG_fail;
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 #if wxUSE_UNICODE
5881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5882 #else
5883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5884 #endif
5885 }
5886 {
5887 if (temp1)
5888 delete arg1;
5889 }
5890 {
5891 if (temp2)
5892 delete arg2;
5893 }
5894 {
5895 if (temp3)
5896 delete arg3;
5897 }
5898 return resultobj;
5899 fail:
5900 {
5901 if (temp1)
5902 delete arg1;
5903 }
5904 {
5905 if (temp2)
5906 delete arg2;
5907 }
5908 {
5909 if (temp3)
5910 delete arg3;
5911 }
5912 return NULL;
5913 }
5914
5915
5916 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj = 0;
5918 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5919 wxString *arg1 = (wxString *) &arg1_defvalue ;
5920 wxString const &arg2_defvalue = wxPyEmptyString ;
5921 wxString *arg2 = (wxString *) &arg2_defvalue ;
5922 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5923 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5924 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5925 wxWindow *arg5 = (wxWindow *) NULL ;
5926 wxString result;
5927 bool temp1 = false ;
5928 bool temp2 = false ;
5929 long val3 ;
5930 int ecode3 = 0 ;
5931 wxPoint temp4 ;
5932 void *argp5 = 0 ;
5933 int res5 = 0 ;
5934 PyObject * obj0 = 0 ;
5935 PyObject * obj1 = 0 ;
5936 PyObject * obj2 = 0 ;
5937 PyObject * obj3 = 0 ;
5938 PyObject * obj4 = 0 ;
5939 char * kwnames[] = {
5940 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5941 };
5942
5943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5944 if (obj0) {
5945 {
5946 arg1 = wxString_in_helper(obj0);
5947 if (arg1 == NULL) SWIG_fail;
5948 temp1 = true;
5949 }
5950 }
5951 if (obj1) {
5952 {
5953 arg2 = wxString_in_helper(obj1);
5954 if (arg2 == NULL) SWIG_fail;
5955 temp2 = true;
5956 }
5957 }
5958 if (obj2) {
5959 ecode3 = SWIG_AsVal_long(obj2, &val3);
5960 if (!SWIG_IsOK(ecode3)) {
5961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5962 }
5963 arg3 = static_cast< long >(val3);
5964 }
5965 if (obj3) {
5966 {
5967 arg4 = &temp4;
5968 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5969 }
5970 }
5971 if (obj4) {
5972 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5973 if (!SWIG_IsOK(res5)) {
5974 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5975 }
5976 arg5 = reinterpret_cast< wxWindow * >(argp5);
5977 }
5978 {
5979 if (!wxPyCheckForApp()) SWIG_fail;
5980 PyThreadState* __tstate = wxPyBeginAllowThreads();
5981 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5982 wxPyEndAllowThreads(__tstate);
5983 if (PyErr_Occurred()) SWIG_fail;
5984 }
5985 {
5986 #if wxUSE_UNICODE
5987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5988 #else
5989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5990 #endif
5991 }
5992 {
5993 if (temp1)
5994 delete arg1;
5995 }
5996 {
5997 if (temp2)
5998 delete arg2;
5999 }
6000 return resultobj;
6001 fail:
6002 {
6003 if (temp1)
6004 delete arg1;
6005 }
6006 {
6007 if (temp2)
6008 delete arg2;
6009 }
6010 return NULL;
6011 }
6012
6013
6014 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6015 PyObject *resultobj = 0;
6016 wxString *arg1 = 0 ;
6017 wxString const &arg2_defvalue = wxPyEmptyString ;
6018 wxString *arg2 = (wxString *) &arg2_defvalue ;
6019 wxString const &arg3_defvalue = wxPyEmptyString ;
6020 wxString *arg3 = (wxString *) &arg3_defvalue ;
6021 wxWindow *arg4 = (wxWindow *) NULL ;
6022 int arg5 = (int) -1 ;
6023 int arg6 = (int) -1 ;
6024 bool arg7 = (bool) true ;
6025 wxString result;
6026 bool temp1 = false ;
6027 bool temp2 = false ;
6028 bool temp3 = false ;
6029 void *argp4 = 0 ;
6030 int res4 = 0 ;
6031 int val5 ;
6032 int ecode5 = 0 ;
6033 int val6 ;
6034 int ecode6 = 0 ;
6035 bool val7 ;
6036 int ecode7 = 0 ;
6037 PyObject * obj0 = 0 ;
6038 PyObject * obj1 = 0 ;
6039 PyObject * obj2 = 0 ;
6040 PyObject * obj3 = 0 ;
6041 PyObject * obj4 = 0 ;
6042 PyObject * obj5 = 0 ;
6043 PyObject * obj6 = 0 ;
6044 char * kwnames[] = {
6045 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6046 };
6047
6048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6049 {
6050 arg1 = wxString_in_helper(obj0);
6051 if (arg1 == NULL) SWIG_fail;
6052 temp1 = true;
6053 }
6054 if (obj1) {
6055 {
6056 arg2 = wxString_in_helper(obj1);
6057 if (arg2 == NULL) SWIG_fail;
6058 temp2 = true;
6059 }
6060 }
6061 if (obj2) {
6062 {
6063 arg3 = wxString_in_helper(obj2);
6064 if (arg3 == NULL) SWIG_fail;
6065 temp3 = true;
6066 }
6067 }
6068 if (obj3) {
6069 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6070 if (!SWIG_IsOK(res4)) {
6071 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6072 }
6073 arg4 = reinterpret_cast< wxWindow * >(argp4);
6074 }
6075 if (obj4) {
6076 ecode5 = SWIG_AsVal_int(obj4, &val5);
6077 if (!SWIG_IsOK(ecode5)) {
6078 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6079 }
6080 arg5 = static_cast< int >(val5);
6081 }
6082 if (obj5) {
6083 ecode6 = SWIG_AsVal_int(obj5, &val6);
6084 if (!SWIG_IsOK(ecode6)) {
6085 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6086 }
6087 arg6 = static_cast< int >(val6);
6088 }
6089 if (obj6) {
6090 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6091 if (!SWIG_IsOK(ecode7)) {
6092 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6093 }
6094 arg7 = static_cast< bool >(val7);
6095 }
6096 {
6097 if (!wxPyCheckForApp()) SWIG_fail;
6098 PyThreadState* __tstate = wxPyBeginAllowThreads();
6099 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6100 wxPyEndAllowThreads(__tstate);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 {
6104 #if wxUSE_UNICODE
6105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6106 #else
6107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6108 #endif
6109 }
6110 {
6111 if (temp1)
6112 delete arg1;
6113 }
6114 {
6115 if (temp2)
6116 delete arg2;
6117 }
6118 {
6119 if (temp3)
6120 delete arg3;
6121 }
6122 return resultobj;
6123 fail:
6124 {
6125 if (temp1)
6126 delete arg1;
6127 }
6128 {
6129 if (temp2)
6130 delete arg2;
6131 }
6132 {
6133 if (temp3)
6134 delete arg3;
6135 }
6136 return NULL;
6137 }
6138
6139
6140 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6141 PyObject *resultobj = 0;
6142 wxString *arg1 = 0 ;
6143 wxString const &arg2_defvalue = wxPyEmptyString ;
6144 wxString *arg2 = (wxString *) &arg2_defvalue ;
6145 wxString const &arg3_defvalue = wxPyEmptyString ;
6146 wxString *arg3 = (wxString *) &arg3_defvalue ;
6147 wxWindow *arg4 = (wxWindow *) NULL ;
6148 wxString result;
6149 bool temp1 = false ;
6150 bool temp2 = false ;
6151 bool temp3 = false ;
6152 void *argp4 = 0 ;
6153 int res4 = 0 ;
6154 PyObject * obj0 = 0 ;
6155 PyObject * obj1 = 0 ;
6156 PyObject * obj2 = 0 ;
6157 PyObject * obj3 = 0 ;
6158 char * kwnames[] = {
6159 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6160 };
6161
6162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6163 {
6164 arg1 = wxString_in_helper(obj0);
6165 if (arg1 == NULL) SWIG_fail;
6166 temp1 = true;
6167 }
6168 if (obj1) {
6169 {
6170 arg2 = wxString_in_helper(obj1);
6171 if (arg2 == NULL) SWIG_fail;
6172 temp2 = true;
6173 }
6174 }
6175 if (obj2) {
6176 {
6177 arg3 = wxString_in_helper(obj2);
6178 if (arg3 == NULL) SWIG_fail;
6179 temp3 = true;
6180 }
6181 }
6182 if (obj3) {
6183 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6184 if (!SWIG_IsOK(res4)) {
6185 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6186 }
6187 arg4 = reinterpret_cast< wxWindow * >(argp4);
6188 }
6189 {
6190 if (!wxPyCheckForApp()) SWIG_fail;
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6193 wxPyEndAllowThreads(__tstate);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 {
6197 #if wxUSE_UNICODE
6198 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6199 #else
6200 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6201 #endif
6202 }
6203 {
6204 if (temp1)
6205 delete arg1;
6206 }
6207 {
6208 if (temp2)
6209 delete arg2;
6210 }
6211 {
6212 if (temp3)
6213 delete arg3;
6214 }
6215 return resultobj;
6216 fail:
6217 {
6218 if (temp1)
6219 delete arg1;
6220 }
6221 {
6222 if (temp2)
6223 delete arg2;
6224 }
6225 {
6226 if (temp3)
6227 delete arg3;
6228 }
6229 return NULL;
6230 }
6231
6232
6233 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6234 PyObject *resultobj = 0;
6235 wxString *arg1 = 0 ;
6236 wxString *arg2 = 0 ;
6237 int arg3 ;
6238 wxString *arg4 = (wxString *) 0 ;
6239 wxWindow *arg5 = (wxWindow *) NULL ;
6240 int arg6 = (int) -1 ;
6241 int arg7 = (int) -1 ;
6242 bool arg8 = (bool) true ;
6243 int arg9 = (int) 150 ;
6244 int arg10 = (int) 200 ;
6245 wxString result;
6246 bool temp1 = false ;
6247 bool temp2 = false ;
6248 void *argp5 = 0 ;
6249 int res5 = 0 ;
6250 int val6 ;
6251 int ecode6 = 0 ;
6252 int val7 ;
6253 int ecode7 = 0 ;
6254 bool val8 ;
6255 int ecode8 = 0 ;
6256 int val9 ;
6257 int ecode9 = 0 ;
6258 int val10 ;
6259 int ecode10 = 0 ;
6260 PyObject * obj0 = 0 ;
6261 PyObject * obj1 = 0 ;
6262 PyObject * obj2 = 0 ;
6263 PyObject * obj3 = 0 ;
6264 PyObject * obj4 = 0 ;
6265 PyObject * obj5 = 0 ;
6266 PyObject * obj6 = 0 ;
6267 PyObject * obj7 = 0 ;
6268 PyObject * obj8 = 0 ;
6269 char * kwnames[] = {
6270 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6271 };
6272
6273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6274 {
6275 arg1 = wxString_in_helper(obj0);
6276 if (arg1 == NULL) SWIG_fail;
6277 temp1 = true;
6278 }
6279 {
6280 arg2 = wxString_in_helper(obj1);
6281 if (arg2 == NULL) SWIG_fail;
6282 temp2 = true;
6283 }
6284 {
6285 arg3 = PyList_Size(obj2);
6286 arg4 = wxString_LIST_helper(obj2);
6287 if (arg4 == NULL) SWIG_fail;
6288 }
6289 if (obj3) {
6290 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6291 if (!SWIG_IsOK(res5)) {
6292 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6293 }
6294 arg5 = reinterpret_cast< wxWindow * >(argp5);
6295 }
6296 if (obj4) {
6297 ecode6 = SWIG_AsVal_int(obj4, &val6);
6298 if (!SWIG_IsOK(ecode6)) {
6299 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6300 }
6301 arg6 = static_cast< int >(val6);
6302 }
6303 if (obj5) {
6304 ecode7 = SWIG_AsVal_int(obj5, &val7);
6305 if (!SWIG_IsOK(ecode7)) {
6306 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6307 }
6308 arg7 = static_cast< int >(val7);
6309 }
6310 if (obj6) {
6311 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6312 if (!SWIG_IsOK(ecode8)) {
6313 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6314 }
6315 arg8 = static_cast< bool >(val8);
6316 }
6317 if (obj7) {
6318 ecode9 = SWIG_AsVal_int(obj7, &val9);
6319 if (!SWIG_IsOK(ecode9)) {
6320 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6321 }
6322 arg9 = static_cast< int >(val9);
6323 }
6324 if (obj8) {
6325 ecode10 = SWIG_AsVal_int(obj8, &val10);
6326 if (!SWIG_IsOK(ecode10)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6328 }
6329 arg10 = static_cast< int >(val10);
6330 }
6331 {
6332 if (!wxPyCheckForApp()) SWIG_fail;
6333 PyThreadState* __tstate = wxPyBeginAllowThreads();
6334 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6335 wxPyEndAllowThreads(__tstate);
6336 if (PyErr_Occurred()) SWIG_fail;
6337 }
6338 {
6339 #if wxUSE_UNICODE
6340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6341 #else
6342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6343 #endif
6344 }
6345 {
6346 if (temp1)
6347 delete arg1;
6348 }
6349 {
6350 if (temp2)
6351 delete arg2;
6352 }
6353 {
6354 if (arg4) delete [] arg4;
6355 }
6356 return resultobj;
6357 fail:
6358 {
6359 if (temp1)
6360 delete arg1;
6361 }
6362 {
6363 if (temp2)
6364 delete arg2;
6365 }
6366 {
6367 if (arg4) delete [] arg4;
6368 }
6369 return NULL;
6370 }
6371
6372
6373 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6374 PyObject *resultobj = 0;
6375 wxString *arg1 = 0 ;
6376 wxString *arg2 = 0 ;
6377 int arg3 ;
6378 wxString *arg4 = (wxString *) 0 ;
6379 wxWindow *arg5 = (wxWindow *) NULL ;
6380 int arg6 = (int) -1 ;
6381 int arg7 = (int) -1 ;
6382 bool arg8 = (bool) true ;
6383 int arg9 = (int) 150 ;
6384 int arg10 = (int) 200 ;
6385 int result;
6386 bool temp1 = false ;
6387 bool temp2 = false ;
6388 void *argp5 = 0 ;
6389 int res5 = 0 ;
6390 int val6 ;
6391 int ecode6 = 0 ;
6392 int val7 ;
6393 int ecode7 = 0 ;
6394 bool val8 ;
6395 int ecode8 = 0 ;
6396 int val9 ;
6397 int ecode9 = 0 ;
6398 int val10 ;
6399 int ecode10 = 0 ;
6400 PyObject * obj0 = 0 ;
6401 PyObject * obj1 = 0 ;
6402 PyObject * obj2 = 0 ;
6403 PyObject * obj3 = 0 ;
6404 PyObject * obj4 = 0 ;
6405 PyObject * obj5 = 0 ;
6406 PyObject * obj6 = 0 ;
6407 PyObject * obj7 = 0 ;
6408 PyObject * obj8 = 0 ;
6409 char * kwnames[] = {
6410 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6411 };
6412
6413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6414 {
6415 arg1 = wxString_in_helper(obj0);
6416 if (arg1 == NULL) SWIG_fail;
6417 temp1 = true;
6418 }
6419 {
6420 arg2 = wxString_in_helper(obj1);
6421 if (arg2 == NULL) SWIG_fail;
6422 temp2 = true;
6423 }
6424 {
6425 arg3 = PyList_Size(obj2);
6426 arg4 = wxString_LIST_helper(obj2);
6427 if (arg4 == NULL) SWIG_fail;
6428 }
6429 if (obj3) {
6430 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6431 if (!SWIG_IsOK(res5)) {
6432 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6433 }
6434 arg5 = reinterpret_cast< wxWindow * >(argp5);
6435 }
6436 if (obj4) {
6437 ecode6 = SWIG_AsVal_int(obj4, &val6);
6438 if (!SWIG_IsOK(ecode6)) {
6439 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6440 }
6441 arg6 = static_cast< int >(val6);
6442 }
6443 if (obj5) {
6444 ecode7 = SWIG_AsVal_int(obj5, &val7);
6445 if (!SWIG_IsOK(ecode7)) {
6446 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6447 }
6448 arg7 = static_cast< int >(val7);
6449 }
6450 if (obj6) {
6451 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6452 if (!SWIG_IsOK(ecode8)) {
6453 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6454 }
6455 arg8 = static_cast< bool >(val8);
6456 }
6457 if (obj7) {
6458 ecode9 = SWIG_AsVal_int(obj7, &val9);
6459 if (!SWIG_IsOK(ecode9)) {
6460 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6461 }
6462 arg9 = static_cast< int >(val9);
6463 }
6464 if (obj8) {
6465 ecode10 = SWIG_AsVal_int(obj8, &val10);
6466 if (!SWIG_IsOK(ecode10)) {
6467 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6468 }
6469 arg10 = static_cast< int >(val10);
6470 }
6471 {
6472 if (!wxPyCheckForApp()) SWIG_fail;
6473 PyThreadState* __tstate = wxPyBeginAllowThreads();
6474 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6475 wxPyEndAllowThreads(__tstate);
6476 if (PyErr_Occurred()) SWIG_fail;
6477 }
6478 resultobj = SWIG_From_int(static_cast< int >(result));
6479 {
6480 if (temp1)
6481 delete arg1;
6482 }
6483 {
6484 if (temp2)
6485 delete arg2;
6486 }
6487 {
6488 if (arg4) delete [] arg4;
6489 }
6490 return resultobj;
6491 fail:
6492 {
6493 if (temp1)
6494 delete arg1;
6495 }
6496 {
6497 if (temp2)
6498 delete arg2;
6499 }
6500 {
6501 if (arg4) delete [] arg4;
6502 }
6503 return NULL;
6504 }
6505
6506
6507 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj = 0;
6509 wxString *arg1 = 0 ;
6510 wxString const &arg2_defvalue = wxPyEmptyString ;
6511 wxString *arg2 = (wxString *) &arg2_defvalue ;
6512 int arg3 = (int) wxOK|wxCENTRE ;
6513 wxWindow *arg4 = (wxWindow *) NULL ;
6514 int arg5 = (int) -1 ;
6515 int arg6 = (int) -1 ;
6516 int result;
6517 bool temp1 = false ;
6518 bool temp2 = false ;
6519 int val3 ;
6520 int ecode3 = 0 ;
6521 void *argp4 = 0 ;
6522 int res4 = 0 ;
6523 int val5 ;
6524 int ecode5 = 0 ;
6525 int val6 ;
6526 int ecode6 = 0 ;
6527 PyObject * obj0 = 0 ;
6528 PyObject * obj1 = 0 ;
6529 PyObject * obj2 = 0 ;
6530 PyObject * obj3 = 0 ;
6531 PyObject * obj4 = 0 ;
6532 PyObject * obj5 = 0 ;
6533 char * kwnames[] = {
6534 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6535 };
6536
6537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6538 {
6539 arg1 = wxString_in_helper(obj0);
6540 if (arg1 == NULL) SWIG_fail;
6541 temp1 = true;
6542 }
6543 if (obj1) {
6544 {
6545 arg2 = wxString_in_helper(obj1);
6546 if (arg2 == NULL) SWIG_fail;
6547 temp2 = true;
6548 }
6549 }
6550 if (obj2) {
6551 ecode3 = SWIG_AsVal_int(obj2, &val3);
6552 if (!SWIG_IsOK(ecode3)) {
6553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6554 }
6555 arg3 = static_cast< int >(val3);
6556 }
6557 if (obj3) {
6558 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6559 if (!SWIG_IsOK(res4)) {
6560 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6561 }
6562 arg4 = reinterpret_cast< wxWindow * >(argp4);
6563 }
6564 if (obj4) {
6565 ecode5 = SWIG_AsVal_int(obj4, &val5);
6566 if (!SWIG_IsOK(ecode5)) {
6567 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6568 }
6569 arg5 = static_cast< int >(val5);
6570 }
6571 if (obj5) {
6572 ecode6 = SWIG_AsVal_int(obj5, &val6);
6573 if (!SWIG_IsOK(ecode6)) {
6574 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6575 }
6576 arg6 = static_cast< int >(val6);
6577 }
6578 {
6579 if (!wxPyCheckForApp()) SWIG_fail;
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6582 wxPyEndAllowThreads(__tstate);
6583 if (PyErr_Occurred()) SWIG_fail;
6584 }
6585 resultobj = SWIG_From_int(static_cast< int >(result));
6586 {
6587 if (temp1)
6588 delete arg1;
6589 }
6590 {
6591 if (temp2)
6592 delete arg2;
6593 }
6594 return resultobj;
6595 fail:
6596 {
6597 if (temp1)
6598 delete arg1;
6599 }
6600 {
6601 if (temp2)
6602 delete arg2;
6603 }
6604 return NULL;
6605 }
6606
6607
6608 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6609 PyObject *resultobj = 0;
6610 wxString *arg1 = 0 ;
6611 wxString *arg2 = 0 ;
6612 wxString *arg3 = 0 ;
6613 long arg4 ;
6614 long arg5 = (long) 0 ;
6615 long arg6 = (long) 100 ;
6616 wxWindow *arg7 = (wxWindow *) NULL ;
6617 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6618 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6619 long result;
6620 bool temp1 = false ;
6621 bool temp2 = false ;
6622 bool temp3 = false ;
6623 long val4 ;
6624 int ecode4 = 0 ;
6625 long val5 ;
6626 int ecode5 = 0 ;
6627 long val6 ;
6628 int ecode6 = 0 ;
6629 void *argp7 = 0 ;
6630 int res7 = 0 ;
6631 wxPoint temp8 ;
6632 PyObject * obj0 = 0 ;
6633 PyObject * obj1 = 0 ;
6634 PyObject * obj2 = 0 ;
6635 PyObject * obj3 = 0 ;
6636 PyObject * obj4 = 0 ;
6637 PyObject * obj5 = 0 ;
6638 PyObject * obj6 = 0 ;
6639 PyObject * obj7 = 0 ;
6640 char * kwnames[] = {
6641 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6642 };
6643
6644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6645 {
6646 arg1 = wxString_in_helper(obj0);
6647 if (arg1 == NULL) SWIG_fail;
6648 temp1 = true;
6649 }
6650 {
6651 arg2 = wxString_in_helper(obj1);
6652 if (arg2 == NULL) SWIG_fail;
6653 temp2 = true;
6654 }
6655 {
6656 arg3 = wxString_in_helper(obj2);
6657 if (arg3 == NULL) SWIG_fail;
6658 temp3 = true;
6659 }
6660 ecode4 = SWIG_AsVal_long(obj3, &val4);
6661 if (!SWIG_IsOK(ecode4)) {
6662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6663 }
6664 arg4 = static_cast< long >(val4);
6665 if (obj4) {
6666 ecode5 = SWIG_AsVal_long(obj4, &val5);
6667 if (!SWIG_IsOK(ecode5)) {
6668 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6669 }
6670 arg5 = static_cast< long >(val5);
6671 }
6672 if (obj5) {
6673 ecode6 = SWIG_AsVal_long(obj5, &val6);
6674 if (!SWIG_IsOK(ecode6)) {
6675 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6676 }
6677 arg6 = static_cast< long >(val6);
6678 }
6679 if (obj6) {
6680 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6681 if (!SWIG_IsOK(res7)) {
6682 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6683 }
6684 arg7 = reinterpret_cast< wxWindow * >(argp7);
6685 }
6686 if (obj7) {
6687 {
6688 arg8 = &temp8;
6689 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6690 }
6691 }
6692 {
6693 if (!wxPyCheckForApp()) SWIG_fail;
6694 PyThreadState* __tstate = wxPyBeginAllowThreads();
6695 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6696 wxPyEndAllowThreads(__tstate);
6697 if (PyErr_Occurred()) SWIG_fail;
6698 }
6699 resultobj = SWIG_From_long(static_cast< long >(result));
6700 {
6701 if (temp1)
6702 delete arg1;
6703 }
6704 {
6705 if (temp2)
6706 delete arg2;
6707 }
6708 {
6709 if (temp3)
6710 delete arg3;
6711 }
6712 return resultobj;
6713 fail:
6714 {
6715 if (temp1)
6716 delete arg1;
6717 }
6718 {
6719 if (temp2)
6720 delete arg2;
6721 }
6722 {
6723 if (temp3)
6724 delete arg3;
6725 }
6726 return NULL;
6727 }
6728
6729
6730 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6731 PyObject *resultobj = 0;
6732 bool result;
6733
6734 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6735 {
6736 if (!wxPyCheckForApp()) SWIG_fail;
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 result = (bool)wxColourDisplay();
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 {
6743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6744 }
6745 return resultobj;
6746 fail:
6747 return NULL;
6748 }
6749
6750
6751 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6752 PyObject *resultobj = 0;
6753 int result;
6754
6755 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6756 {
6757 if (!wxPyCheckForApp()) SWIG_fail;
6758 PyThreadState* __tstate = wxPyBeginAllowThreads();
6759 result = (int)wxDisplayDepth();
6760 wxPyEndAllowThreads(__tstate);
6761 if (PyErr_Occurred()) SWIG_fail;
6762 }
6763 resultobj = SWIG_From_int(static_cast< int >(result));
6764 return resultobj;
6765 fail:
6766 return NULL;
6767 }
6768
6769
6770 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 PyObject *resultobj = 0;
6772 int result;
6773
6774 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6775 {
6776 if (!wxPyCheckForApp()) SWIG_fail;
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (int)wxGetDisplayDepth();
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 resultobj = SWIG_From_int(static_cast< int >(result));
6783 return resultobj;
6784 fail:
6785 return NULL;
6786 }
6787
6788
6789 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6790 PyObject *resultobj = 0;
6791 int *arg1 = (int *) 0 ;
6792 int *arg2 = (int *) 0 ;
6793 int temp1 ;
6794 int res1 = SWIG_TMPOBJ ;
6795 int temp2 ;
6796 int res2 = SWIG_TMPOBJ ;
6797
6798 arg1 = &temp1;
6799 arg2 = &temp2;
6800 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6801 {
6802 if (!wxPyCheckForApp()) SWIG_fail;
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 wxDisplaySize(arg1,arg2);
6805 wxPyEndAllowThreads(__tstate);
6806 if (PyErr_Occurred()) SWIG_fail;
6807 }
6808 resultobj = SWIG_Py_Void();
6809 if (SWIG_IsTmpObj(res1)) {
6810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6811 } else {
6812 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6814 }
6815 if (SWIG_IsTmpObj(res2)) {
6816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6817 } else {
6818 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6820 }
6821 return resultobj;
6822 fail:
6823 return NULL;
6824 }
6825
6826
6827 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6828 PyObject *resultobj = 0;
6829 wxSize result;
6830
6831 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6832 {
6833 if (!wxPyCheckForApp()) SWIG_fail;
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 result = wxGetDisplaySize();
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6847 PyObject *resultobj = 0;
6848 int *arg1 = (int *) 0 ;
6849 int *arg2 = (int *) 0 ;
6850 int temp1 ;
6851 int res1 = SWIG_TMPOBJ ;
6852 int temp2 ;
6853 int res2 = SWIG_TMPOBJ ;
6854
6855 arg1 = &temp1;
6856 arg2 = &temp2;
6857 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6858 {
6859 if (!wxPyCheckForApp()) SWIG_fail;
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 wxDisplaySizeMM(arg1,arg2);
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 resultobj = SWIG_Py_Void();
6866 if (SWIG_IsTmpObj(res1)) {
6867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6868 } else {
6869 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6871 }
6872 if (SWIG_IsTmpObj(res2)) {
6873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6874 } else {
6875 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6877 }
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxSize result;
6887
6888 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6889 {
6890 if (!wxPyCheckForApp()) SWIG_fail;
6891 PyThreadState* __tstate = wxPyBeginAllowThreads();
6892 result = wxGetDisplaySizeMM();
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6904 PyObject *resultobj = 0;
6905 int *arg1 = (int *) 0 ;
6906 int *arg2 = (int *) 0 ;
6907 int *arg3 = (int *) 0 ;
6908 int *arg4 = (int *) 0 ;
6909 int temp1 ;
6910 int res1 = SWIG_TMPOBJ ;
6911 int temp2 ;
6912 int res2 = SWIG_TMPOBJ ;
6913 int temp3 ;
6914 int res3 = SWIG_TMPOBJ ;
6915 int temp4 ;
6916 int res4 = SWIG_TMPOBJ ;
6917
6918 arg1 = &temp1;
6919 arg2 = &temp2;
6920 arg3 = &temp3;
6921 arg4 = &temp4;
6922 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6923 {
6924 if (!wxPyCheckForApp()) SWIG_fail;
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 resultobj = SWIG_Py_Void();
6931 if (SWIG_IsTmpObj(res1)) {
6932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6933 } else {
6934 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6936 }
6937 if (SWIG_IsTmpObj(res2)) {
6938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6939 } else {
6940 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6942 }
6943 if (SWIG_IsTmpObj(res3)) {
6944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6945 } else {
6946 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6948 }
6949 if (SWIG_IsTmpObj(res4)) {
6950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6951 } else {
6952 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6953 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6954 }
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6962 PyObject *resultobj = 0;
6963 wxRect result;
6964
6965 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6966 {
6967 if (!wxPyCheckForApp()) SWIG_fail;
6968 PyThreadState* __tstate = wxPyBeginAllowThreads();
6969 result = wxGetClientDisplayRect();
6970 wxPyEndAllowThreads(__tstate);
6971 if (PyErr_Occurred()) SWIG_fail;
6972 }
6973 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6974 return resultobj;
6975 fail:
6976 return NULL;
6977 }
6978
6979
6980 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6981 PyObject *resultobj = 0;
6982 wxCursor *arg1 = 0 ;
6983 void *argp1 = 0 ;
6984 int res1 = 0 ;
6985 PyObject * obj0 = 0 ;
6986 char * kwnames[] = {
6987 (char *) "cursor", NULL
6988 };
6989
6990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6991 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6992 if (!SWIG_IsOK(res1)) {
6993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6994 }
6995 if (!argp1) {
6996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6997 }
6998 arg1 = reinterpret_cast< wxCursor * >(argp1);
6999 {
7000 if (!wxPyCheckForApp()) SWIG_fail;
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 wxSetCursor(*arg1);
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_Py_Void();
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7014 PyObject *resultobj = 0;
7015 void *result = 0 ;
7016
7017 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7018 {
7019 if (!wxPyCheckForApp()) SWIG_fail;
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = (void *)wxGetXDisplay();
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7026 return resultobj;
7027 fail:
7028 return NULL;
7029 }
7030
7031
7032 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7033 PyObject *resultobj = 0;
7034 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7035 void *argp1 = 0 ;
7036 int res1 = 0 ;
7037 PyObject * obj0 = 0 ;
7038 char * kwnames[] = {
7039 (char *) "cursor", NULL
7040 };
7041
7042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7043 if (obj0) {
7044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7047 }
7048 arg1 = reinterpret_cast< wxCursor * >(argp1);
7049 }
7050 {
7051 if (!wxPyCheckForApp()) SWIG_fail;
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 wxBeginBusyCursor(arg1);
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_Py_Void();
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7065 PyObject *resultobj = 0;
7066 wxPoint result;
7067
7068 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7069 {
7070 if (!wxPyCheckForApp()) SWIG_fail;
7071 PyThreadState* __tstate = wxPyBeginAllowThreads();
7072 result = wxGetMousePosition();
7073 wxPyEndAllowThreads(__tstate);
7074 if (PyErr_Occurred()) SWIG_fail;
7075 }
7076 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7077 return resultobj;
7078 fail:
7079 return NULL;
7080 }
7081
7082
7083 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7084 PyObject *resultobj = 0;
7085 wxWindow *result = 0 ;
7086
7087 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7088 {
7089 if (!wxPyCheckForApp()) SWIG_fail;
7090 PyThreadState* __tstate = wxPyBeginAllowThreads();
7091 result = (wxWindow *)FindWindowAtPointer();
7092 wxPyEndAllowThreads(__tstate);
7093 if (PyErr_Occurred()) SWIG_fail;
7094 }
7095 {
7096 resultobj = wxPyMake_wxObject(result, 0);
7097 }
7098 return resultobj;
7099 fail:
7100 return NULL;
7101 }
7102
7103
7104 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7105 PyObject *resultobj = 0;
7106 wxWindow *result = 0 ;
7107
7108 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7109 {
7110 if (!wxPyCheckForApp()) SWIG_fail;
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = (wxWindow *)wxGetActiveWindow();
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 {
7117 resultobj = wxPyMake_wxObject(result, 0);
7118 }
7119 return resultobj;
7120 fail:
7121 return NULL;
7122 }
7123
7124
7125 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7126 PyObject *resultobj = 0;
7127 wxPoint *arg1 = 0 ;
7128 wxWindow *result = 0 ;
7129 wxPoint temp1 ;
7130 PyObject * obj0 = 0 ;
7131 char * kwnames[] = {
7132 (char *) "pt", NULL
7133 };
7134
7135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7136 {
7137 arg1 = &temp1;
7138 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7139 }
7140 {
7141 if (!wxPyCheckForApp()) SWIG_fail;
7142 PyThreadState* __tstate = wxPyBeginAllowThreads();
7143 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7144 wxPyEndAllowThreads(__tstate);
7145 if (PyErr_Occurred()) SWIG_fail;
7146 }
7147 {
7148 resultobj = wxPyMake_wxObject(result, 0);
7149 }
7150 return resultobj;
7151 fail:
7152 return NULL;
7153 }
7154
7155
7156 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7157 PyObject *resultobj = 0;
7158 wxPoint *arg1 = 0 ;
7159 wxWindow *result = 0 ;
7160 wxPoint temp1 ;
7161 PyObject * obj0 = 0 ;
7162 char * kwnames[] = {
7163 (char *) "pt", NULL
7164 };
7165
7166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7167 {
7168 arg1 = &temp1;
7169 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7170 }
7171 {
7172 if (!wxPyCheckForApp()) SWIG_fail;
7173 PyThreadState* __tstate = wxPyBeginAllowThreads();
7174 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7175 wxPyEndAllowThreads(__tstate);
7176 if (PyErr_Occurred()) SWIG_fail;
7177 }
7178 {
7179 resultobj = wxPyMake_wxObject(result, 0);
7180 }
7181 return resultobj;
7182 fail:
7183 return NULL;
7184 }
7185
7186
7187 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7188 PyObject *resultobj = 0;
7189 wxWindow *arg1 = (wxWindow *) 0 ;
7190 wxWindow *result = 0 ;
7191 void *argp1 = 0 ;
7192 int res1 = 0 ;
7193 PyObject * obj0 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "win", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7200 if (!SWIG_IsOK(res1)) {
7201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7202 }
7203 arg1 = reinterpret_cast< wxWindow * >(argp1);
7204 {
7205 if (!wxPyCheckForApp()) SWIG_fail;
7206 PyThreadState* __tstate = wxPyBeginAllowThreads();
7207 result = (wxWindow *)wxGetTopLevelParent(arg1);
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 {
7212 resultobj = wxPyMake_wxObject(result, 0);
7213 }
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = 0;
7222 wxString *arg1 = 0 ;
7223 bool result;
7224 bool temp1 = false ;
7225 PyObject * obj0 = 0 ;
7226 char * kwnames[] = {
7227 (char *) "url", NULL
7228 };
7229
7230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7231 {
7232 arg1 = wxString_in_helper(obj0);
7233 if (arg1 == NULL) SWIG_fail;
7234 temp1 = true;
7235 }
7236 {
7237 PyThreadState* __tstate = wxPyBeginAllowThreads();
7238 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7239 wxPyEndAllowThreads(__tstate);
7240 if (PyErr_Occurred()) SWIG_fail;
7241 }
7242 {
7243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7244 }
7245 {
7246 if (temp1)
7247 delete arg1;
7248 }
7249 return resultobj;
7250 fail:
7251 {
7252 if (temp1)
7253 delete arg1;
7254 }
7255 return NULL;
7256 }
7257
7258
7259 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj = 0;
7261 wxKeyCode arg1 ;
7262 bool result;
7263 int val1 ;
7264 int ecode1 = 0 ;
7265 PyObject * obj0 = 0 ;
7266 char * kwnames[] = {
7267 (char *) "key", NULL
7268 };
7269
7270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7271 ecode1 = SWIG_AsVal_int(obj0, &val1);
7272 if (!SWIG_IsOK(ecode1)) {
7273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7274 }
7275 arg1 = static_cast< wxKeyCode >(val1);
7276 {
7277 if (!wxPyCheckForApp()) SWIG_fail;
7278 PyThreadState* __tstate = wxPyBeginAllowThreads();
7279 result = (bool)wxGetKeyState(arg1);
7280 wxPyEndAllowThreads(__tstate);
7281 if (PyErr_Occurred()) SWIG_fail;
7282 }
7283 {
7284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7285 }
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7293 PyObject *resultobj = 0;
7294 wxMouseState *result = 0 ;
7295
7296 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7297 {
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 result = (wxMouseState *)new wxMouseState();
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7311 PyObject *resultobj = 0;
7312 wxMouseState *arg1 = (wxMouseState *) 0 ;
7313 void *argp1 = 0 ;
7314 int res1 = 0 ;
7315 PyObject *swig_obj[1] ;
7316
7317 if (!args) SWIG_fail;
7318 swig_obj[0] = args;
7319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7320 if (!SWIG_IsOK(res1)) {
7321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7322 }
7323 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7324 {
7325 PyThreadState* __tstate = wxPyBeginAllowThreads();
7326 delete arg1;
7327
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 resultobj = SWIG_Py_Void();
7332 return resultobj;
7333 fail:
7334 return NULL;
7335 }
7336
7337
7338 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7339 PyObject *resultobj = 0;
7340 wxMouseState *arg1 = (wxMouseState *) 0 ;
7341 int result;
7342 void *argp1 = 0 ;
7343 int res1 = 0 ;
7344 PyObject *swig_obj[1] ;
7345
7346 if (!args) SWIG_fail;
7347 swig_obj[0] = args;
7348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7349 if (!SWIG_IsOK(res1)) {
7350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7351 }
7352 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 result = (int)(arg1)->GetX();
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_From_int(static_cast< int >(result));
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7367 PyObject *resultobj = 0;
7368 wxMouseState *arg1 = (wxMouseState *) 0 ;
7369 int result;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 PyObject *swig_obj[1] ;
7373
7374 if (!args) SWIG_fail;
7375 swig_obj[0] = args;
7376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7377 if (!SWIG_IsOK(res1)) {
7378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7379 }
7380 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 result = (int)(arg1)->GetY();
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_From_int(static_cast< int >(result));
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7395 PyObject *resultobj = 0;
7396 wxMouseState *arg1 = (wxMouseState *) 0 ;
7397 bool result;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 PyObject *swig_obj[1] ;
7401
7402 if (!args) SWIG_fail;
7403 swig_obj[0] = args;
7404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7407 }
7408 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (bool)(arg1)->LeftDown();
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 {
7416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7417 }
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7425 PyObject *resultobj = 0;
7426 wxMouseState *arg1 = (wxMouseState *) 0 ;
7427 bool result;
7428 void *argp1 = 0 ;
7429 int res1 = 0 ;
7430 PyObject *swig_obj[1] ;
7431
7432 if (!args) SWIG_fail;
7433 swig_obj[0] = args;
7434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7435 if (!SWIG_IsOK(res1)) {
7436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7437 }
7438 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 result = (bool)(arg1)->MiddleDown();
7442 wxPyEndAllowThreads(__tstate);
7443 if (PyErr_Occurred()) SWIG_fail;
7444 }
7445 {
7446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7447 }
7448 return resultobj;
7449 fail:
7450 return NULL;
7451 }
7452
7453
7454 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7455 PyObject *resultobj = 0;
7456 wxMouseState *arg1 = (wxMouseState *) 0 ;
7457 bool result;
7458 void *argp1 = 0 ;
7459 int res1 = 0 ;
7460 PyObject *swig_obj[1] ;
7461
7462 if (!args) SWIG_fail;
7463 swig_obj[0] = args;
7464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7465 if (!SWIG_IsOK(res1)) {
7466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7467 }
7468 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7469 {
7470 PyThreadState* __tstate = wxPyBeginAllowThreads();
7471 result = (bool)(arg1)->RightDown();
7472 wxPyEndAllowThreads(__tstate);
7473 if (PyErr_Occurred()) SWIG_fail;
7474 }
7475 {
7476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7477 }
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7485 PyObject *resultobj = 0;
7486 wxMouseState *arg1 = (wxMouseState *) 0 ;
7487 bool result;
7488 void *argp1 = 0 ;
7489 int res1 = 0 ;
7490 PyObject *swig_obj[1] ;
7491
7492 if (!args) SWIG_fail;
7493 swig_obj[0] = args;
7494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7495 if (!SWIG_IsOK(res1)) {
7496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7497 }
7498 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7499 {
7500 PyThreadState* __tstate = wxPyBeginAllowThreads();
7501 result = (bool)(arg1)->ControlDown();
7502 wxPyEndAllowThreads(__tstate);
7503 if (PyErr_Occurred()) SWIG_fail;
7504 }
7505 {
7506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7507 }
7508 return resultobj;
7509 fail:
7510 return NULL;
7511 }
7512
7513
7514 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7515 PyObject *resultobj = 0;
7516 wxMouseState *arg1 = (wxMouseState *) 0 ;
7517 bool result;
7518 void *argp1 = 0 ;
7519 int res1 = 0 ;
7520 PyObject *swig_obj[1] ;
7521
7522 if (!args) SWIG_fail;
7523 swig_obj[0] = args;
7524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7525 if (!SWIG_IsOK(res1)) {
7526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7527 }
7528 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)(arg1)->ShiftDown();
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7545 PyObject *resultobj = 0;
7546 wxMouseState *arg1 = (wxMouseState *) 0 ;
7547 bool result;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 PyObject *swig_obj[1] ;
7551
7552 if (!args) SWIG_fail;
7553 swig_obj[0] = args;
7554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7555 if (!SWIG_IsOK(res1)) {
7556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7557 }
7558 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7559 {
7560 PyThreadState* __tstate = wxPyBeginAllowThreads();
7561 result = (bool)(arg1)->AltDown();
7562 wxPyEndAllowThreads(__tstate);
7563 if (PyErr_Occurred()) SWIG_fail;
7564 }
7565 {
7566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7567 }
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7575 PyObject *resultobj = 0;
7576 wxMouseState *arg1 = (wxMouseState *) 0 ;
7577 bool result;
7578 void *argp1 = 0 ;
7579 int res1 = 0 ;
7580 PyObject *swig_obj[1] ;
7581
7582 if (!args) SWIG_fail;
7583 swig_obj[0] = args;
7584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7585 if (!SWIG_IsOK(res1)) {
7586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7587 }
7588 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7589 {
7590 PyThreadState* __tstate = wxPyBeginAllowThreads();
7591 result = (bool)(arg1)->MetaDown();
7592 wxPyEndAllowThreads(__tstate);
7593 if (PyErr_Occurred()) SWIG_fail;
7594 }
7595 {
7596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7597 }
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7605 PyObject *resultobj = 0;
7606 wxMouseState *arg1 = (wxMouseState *) 0 ;
7607 bool result;
7608 void *argp1 = 0 ;
7609 int res1 = 0 ;
7610 PyObject *swig_obj[1] ;
7611
7612 if (!args) SWIG_fail;
7613 swig_obj[0] = args;
7614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7615 if (!SWIG_IsOK(res1)) {
7616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7617 }
7618 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7619 {
7620 PyThreadState* __tstate = wxPyBeginAllowThreads();
7621 result = (bool)(arg1)->CmdDown();
7622 wxPyEndAllowThreads(__tstate);
7623 if (PyErr_Occurred()) SWIG_fail;
7624 }
7625 {
7626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7627 }
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj = 0;
7636 wxMouseState *arg1 = (wxMouseState *) 0 ;
7637 int arg2 ;
7638 void *argp1 = 0 ;
7639 int res1 = 0 ;
7640 int val2 ;
7641 int ecode2 = 0 ;
7642 PyObject * obj0 = 0 ;
7643 PyObject * obj1 = 0 ;
7644 char * kwnames[] = {
7645 (char *) "self",(char *) "x", NULL
7646 };
7647
7648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7650 if (!SWIG_IsOK(res1)) {
7651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7652 }
7653 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7654 ecode2 = SWIG_AsVal_int(obj1, &val2);
7655 if (!SWIG_IsOK(ecode2)) {
7656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7657 }
7658 arg2 = static_cast< int >(val2);
7659 {
7660 PyThreadState* __tstate = wxPyBeginAllowThreads();
7661 (arg1)->SetX(arg2);
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 resultobj = SWIG_Py_Void();
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7673 PyObject *resultobj = 0;
7674 wxMouseState *arg1 = (wxMouseState *) 0 ;
7675 int arg2 ;
7676 void *argp1 = 0 ;
7677 int res1 = 0 ;
7678 int val2 ;
7679 int ecode2 = 0 ;
7680 PyObject * obj0 = 0 ;
7681 PyObject * obj1 = 0 ;
7682 char * kwnames[] = {
7683 (char *) "self",(char *) "y", NULL
7684 };
7685
7686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7688 if (!SWIG_IsOK(res1)) {
7689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7690 }
7691 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7692 ecode2 = SWIG_AsVal_int(obj1, &val2);
7693 if (!SWIG_IsOK(ecode2)) {
7694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7695 }
7696 arg2 = static_cast< int >(val2);
7697 {
7698 PyThreadState* __tstate = wxPyBeginAllowThreads();
7699 (arg1)->SetY(arg2);
7700 wxPyEndAllowThreads(__tstate);
7701 if (PyErr_Occurred()) SWIG_fail;
7702 }
7703 resultobj = SWIG_Py_Void();
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7711 PyObject *resultobj = 0;
7712 wxMouseState *arg1 = (wxMouseState *) 0 ;
7713 bool arg2 ;
7714 void *argp1 = 0 ;
7715 int res1 = 0 ;
7716 bool val2 ;
7717 int ecode2 = 0 ;
7718 PyObject * obj0 = 0 ;
7719 PyObject * obj1 = 0 ;
7720 char * kwnames[] = {
7721 (char *) "self",(char *) "down", NULL
7722 };
7723
7724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7726 if (!SWIG_IsOK(res1)) {
7727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7728 }
7729 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7730 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7731 if (!SWIG_IsOK(ecode2)) {
7732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7733 }
7734 arg2 = static_cast< bool >(val2);
7735 {
7736 PyThreadState* __tstate = wxPyBeginAllowThreads();
7737 (arg1)->SetLeftDown(arg2);
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 resultobj = SWIG_Py_Void();
7742 return resultobj;
7743 fail:
7744 return NULL;
7745 }
7746
7747
7748 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7749 PyObject *resultobj = 0;
7750 wxMouseState *arg1 = (wxMouseState *) 0 ;
7751 bool arg2 ;
7752 void *argp1 = 0 ;
7753 int res1 = 0 ;
7754 bool val2 ;
7755 int ecode2 = 0 ;
7756 PyObject * obj0 = 0 ;
7757 PyObject * obj1 = 0 ;
7758 char * kwnames[] = {
7759 (char *) "self",(char *) "down", NULL
7760 };
7761
7762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7764 if (!SWIG_IsOK(res1)) {
7765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7766 }
7767 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7768 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7769 if (!SWIG_IsOK(ecode2)) {
7770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7771 }
7772 arg2 = static_cast< bool >(val2);
7773 {
7774 PyThreadState* __tstate = wxPyBeginAllowThreads();
7775 (arg1)->SetMiddleDown(arg2);
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 resultobj = SWIG_Py_Void();
7780 return resultobj;
7781 fail:
7782 return NULL;
7783 }
7784
7785
7786 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7787 PyObject *resultobj = 0;
7788 wxMouseState *arg1 = (wxMouseState *) 0 ;
7789 bool arg2 ;
7790 void *argp1 = 0 ;
7791 int res1 = 0 ;
7792 bool val2 ;
7793 int ecode2 = 0 ;
7794 PyObject * obj0 = 0 ;
7795 PyObject * obj1 = 0 ;
7796 char * kwnames[] = {
7797 (char *) "self",(char *) "down", NULL
7798 };
7799
7800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7802 if (!SWIG_IsOK(res1)) {
7803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7804 }
7805 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7806 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7807 if (!SWIG_IsOK(ecode2)) {
7808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7809 }
7810 arg2 = static_cast< bool >(val2);
7811 {
7812 PyThreadState* __tstate = wxPyBeginAllowThreads();
7813 (arg1)->SetRightDown(arg2);
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 resultobj = SWIG_Py_Void();
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj = 0;
7826 wxMouseState *arg1 = (wxMouseState *) 0 ;
7827 bool arg2 ;
7828 void *argp1 = 0 ;
7829 int res1 = 0 ;
7830 bool val2 ;
7831 int ecode2 = 0 ;
7832 PyObject * obj0 = 0 ;
7833 PyObject * obj1 = 0 ;
7834 char * kwnames[] = {
7835 (char *) "self",(char *) "down", NULL
7836 };
7837
7838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7840 if (!SWIG_IsOK(res1)) {
7841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7842 }
7843 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7845 if (!SWIG_IsOK(ecode2)) {
7846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7847 }
7848 arg2 = static_cast< bool >(val2);
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 (arg1)->SetControlDown(arg2);
7852 wxPyEndAllowThreads(__tstate);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_Py_Void();
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7863 PyObject *resultobj = 0;
7864 wxMouseState *arg1 = (wxMouseState *) 0 ;
7865 bool arg2 ;
7866 void *argp1 = 0 ;
7867 int res1 = 0 ;
7868 bool val2 ;
7869 int ecode2 = 0 ;
7870 PyObject * obj0 = 0 ;
7871 PyObject * obj1 = 0 ;
7872 char * kwnames[] = {
7873 (char *) "self",(char *) "down", NULL
7874 };
7875
7876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7878 if (!SWIG_IsOK(res1)) {
7879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7880 }
7881 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7882 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7883 if (!SWIG_IsOK(ecode2)) {
7884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7885 }
7886 arg2 = static_cast< bool >(val2);
7887 {
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 (arg1)->SetShiftDown(arg2);
7890 wxPyEndAllowThreads(__tstate);
7891 if (PyErr_Occurred()) SWIG_fail;
7892 }
7893 resultobj = SWIG_Py_Void();
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7901 PyObject *resultobj = 0;
7902 wxMouseState *arg1 = (wxMouseState *) 0 ;
7903 bool arg2 ;
7904 void *argp1 = 0 ;
7905 int res1 = 0 ;
7906 bool val2 ;
7907 int ecode2 = 0 ;
7908 PyObject * obj0 = 0 ;
7909 PyObject * obj1 = 0 ;
7910 char * kwnames[] = {
7911 (char *) "self",(char *) "down", NULL
7912 };
7913
7914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7916 if (!SWIG_IsOK(res1)) {
7917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7918 }
7919 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7921 if (!SWIG_IsOK(ecode2)) {
7922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7923 }
7924 arg2 = static_cast< bool >(val2);
7925 {
7926 PyThreadState* __tstate = wxPyBeginAllowThreads();
7927 (arg1)->SetAltDown(arg2);
7928 wxPyEndAllowThreads(__tstate);
7929 if (PyErr_Occurred()) SWIG_fail;
7930 }
7931 resultobj = SWIG_Py_Void();
7932 return resultobj;
7933 fail:
7934 return NULL;
7935 }
7936
7937
7938 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7939 PyObject *resultobj = 0;
7940 wxMouseState *arg1 = (wxMouseState *) 0 ;
7941 bool arg2 ;
7942 void *argp1 = 0 ;
7943 int res1 = 0 ;
7944 bool val2 ;
7945 int ecode2 = 0 ;
7946 PyObject * obj0 = 0 ;
7947 PyObject * obj1 = 0 ;
7948 char * kwnames[] = {
7949 (char *) "self",(char *) "down", NULL
7950 };
7951
7952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7954 if (!SWIG_IsOK(res1)) {
7955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7956 }
7957 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7958 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7959 if (!SWIG_IsOK(ecode2)) {
7960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7961 }
7962 arg2 = static_cast< bool >(val2);
7963 {
7964 PyThreadState* __tstate = wxPyBeginAllowThreads();
7965 (arg1)->SetMetaDown(arg2);
7966 wxPyEndAllowThreads(__tstate);
7967 if (PyErr_Occurred()) SWIG_fail;
7968 }
7969 resultobj = SWIG_Py_Void();
7970 return resultobj;
7971 fail:
7972 return NULL;
7973 }
7974
7975
7976 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7977 PyObject *obj;
7978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7979 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7980 return SWIG_Py_Void();
7981 }
7982
7983 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7984 return SWIG_Python_InitShadowInstance(args);
7985 }
7986
7987 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7988 PyObject *resultobj = 0;
7989 wxMouseState result;
7990
7991 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7992 {
7993 PyThreadState* __tstate = wxPyBeginAllowThreads();
7994 result = wxGetMouseState();
7995 wxPyEndAllowThreads(__tstate);
7996 if (PyErr_Occurred()) SWIG_fail;
7997 }
7998 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7999 return resultobj;
8000 fail:
8001 return NULL;
8002 }
8003
8004
8005 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8006 PyObject *resultobj = 0;
8007
8008 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8009 {
8010 if (!wxPyCheckForApp()) SWIG_fail;
8011 PyThreadState* __tstate = wxPyBeginAllowThreads();
8012 wxWakeUpMainThread();
8013 wxPyEndAllowThreads(__tstate);
8014 if (PyErr_Occurred()) SWIG_fail;
8015 }
8016 resultobj = SWIG_Py_Void();
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025
8026 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8027 {
8028 if (!wxPyCheckForApp()) SWIG_fail;
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 wxMutexGuiEnter();
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_Py_Void();
8035 return resultobj;
8036 fail:
8037 return NULL;
8038 }
8039
8040
8041 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8042 PyObject *resultobj = 0;
8043
8044 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8045 {
8046 if (!wxPyCheckForApp()) SWIG_fail;
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 wxMutexGuiLeave();
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_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8060 PyObject *resultobj = 0;
8061 wxMutexGuiLocker *result = 0 ;
8062
8063 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8064 {
8065 if (!wxPyCheckForApp()) SWIG_fail;
8066 PyThreadState* __tstate = wxPyBeginAllowThreads();
8067 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8068 wxPyEndAllowThreads(__tstate);
8069 if (PyErr_Occurred()) SWIG_fail;
8070 }
8071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8072 return resultobj;
8073 fail:
8074 return NULL;
8075 }
8076
8077
8078 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8079 PyObject *resultobj = 0;
8080 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 PyObject *swig_obj[1] ;
8084
8085 if (!args) SWIG_fail;
8086 swig_obj[0] = args;
8087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8088 if (!SWIG_IsOK(res1)) {
8089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8090 }
8091 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8092 {
8093 PyThreadState* __tstate = wxPyBeginAllowThreads();
8094 delete arg1;
8095
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 resultobj = SWIG_Py_Void();
8100 return resultobj;
8101 fail:
8102 return NULL;
8103 }
8104
8105
8106 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8107 PyObject *obj;
8108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8109 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8110 return SWIG_Py_Void();
8111 }
8112
8113 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8114 return SWIG_Python_InitShadowInstance(args);
8115 }
8116
8117 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8118 PyObject *resultobj = 0;
8119 bool result;
8120
8121 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8122 {
8123 PyThreadState* __tstate = wxPyBeginAllowThreads();
8124 result = (bool)wxThread_IsMain();
8125 wxPyEndAllowThreads(__tstate);
8126 if (PyErr_Occurred()) SWIG_fail;
8127 }
8128 {
8129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8130 }
8131 return resultobj;
8132 fail:
8133 return NULL;
8134 }
8135
8136
8137 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8138 PyObject *resultobj = 0;
8139 wxString *arg1 = 0 ;
8140 wxToolTip *result = 0 ;
8141 bool temp1 = false ;
8142 PyObject * obj0 = 0 ;
8143 char * kwnames[] = {
8144 (char *) "tip", NULL
8145 };
8146
8147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8148 {
8149 arg1 = wxString_in_helper(obj0);
8150 if (arg1 == NULL) SWIG_fail;
8151 temp1 = true;
8152 }
8153 {
8154 if (!wxPyCheckForApp()) SWIG_fail;
8155 PyThreadState* __tstate = wxPyBeginAllowThreads();
8156 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8157 wxPyEndAllowThreads(__tstate);
8158 if (PyErr_Occurred()) SWIG_fail;
8159 }
8160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8161 {
8162 if (temp1)
8163 delete arg1;
8164 }
8165 return resultobj;
8166 fail:
8167 {
8168 if (temp1)
8169 delete arg1;
8170 }
8171 return NULL;
8172 }
8173
8174
8175 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8176 PyObject *resultobj = 0;
8177 wxToolTip *arg1 = (wxToolTip *) 0 ;
8178 void *argp1 = 0 ;
8179 int res1 = 0 ;
8180 PyObject *swig_obj[1] ;
8181
8182 if (!args) SWIG_fail;
8183 swig_obj[0] = args;
8184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8185 if (!SWIG_IsOK(res1)) {
8186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8187 }
8188 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 delete arg1;
8192
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 resultobj = SWIG_Py_Void();
8197 return resultobj;
8198 fail:
8199 return NULL;
8200 }
8201
8202
8203 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8204 PyObject *resultobj = 0;
8205 wxToolTip *arg1 = (wxToolTip *) 0 ;
8206 wxString *arg2 = 0 ;
8207 void *argp1 = 0 ;
8208 int res1 = 0 ;
8209 bool temp2 = false ;
8210 PyObject * obj0 = 0 ;
8211 PyObject * obj1 = 0 ;
8212 char * kwnames[] = {
8213 (char *) "self",(char *) "tip", NULL
8214 };
8215
8216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8220 }
8221 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8222 {
8223 arg2 = wxString_in_helper(obj1);
8224 if (arg2 == NULL) SWIG_fail;
8225 temp2 = true;
8226 }
8227 {
8228 PyThreadState* __tstate = wxPyBeginAllowThreads();
8229 (arg1)->SetTip((wxString const &)*arg2);
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 resultobj = SWIG_Py_Void();
8234 {
8235 if (temp2)
8236 delete arg2;
8237 }
8238 return resultobj;
8239 fail:
8240 {
8241 if (temp2)
8242 delete arg2;
8243 }
8244 return NULL;
8245 }
8246
8247
8248 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8249 PyObject *resultobj = 0;
8250 wxToolTip *arg1 = (wxToolTip *) 0 ;
8251 wxString result;
8252 void *argp1 = 0 ;
8253 int res1 = 0 ;
8254 PyObject *swig_obj[1] ;
8255
8256 if (!args) SWIG_fail;
8257 swig_obj[0] = args;
8258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8259 if (!SWIG_IsOK(res1)) {
8260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8261 }
8262 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 result = (arg1)->GetTip();
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 {
8270 #if wxUSE_UNICODE
8271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8272 #else
8273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8274 #endif
8275 }
8276 return resultobj;
8277 fail:
8278 return NULL;
8279 }
8280
8281
8282 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8283 PyObject *resultobj = 0;
8284 wxToolTip *arg1 = (wxToolTip *) 0 ;
8285 wxWindow *result = 0 ;
8286 void *argp1 = 0 ;
8287 int res1 = 0 ;
8288 PyObject *swig_obj[1] ;
8289
8290 if (!args) SWIG_fail;
8291 swig_obj[0] = args;
8292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8293 if (!SWIG_IsOK(res1)) {
8294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8295 }
8296 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8297 {
8298 PyThreadState* __tstate = wxPyBeginAllowThreads();
8299 result = (wxWindow *)(arg1)->GetWindow();
8300 wxPyEndAllowThreads(__tstate);
8301 if (PyErr_Occurred()) SWIG_fail;
8302 }
8303 {
8304 resultobj = wxPyMake_wxObject(result, 0);
8305 }
8306 return resultobj;
8307 fail:
8308 return NULL;
8309 }
8310
8311
8312 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8313 PyObject *resultobj = 0;
8314 bool arg1 ;
8315 bool val1 ;
8316 int ecode1 = 0 ;
8317 PyObject * obj0 = 0 ;
8318 char * kwnames[] = {
8319 (char *) "flag", NULL
8320 };
8321
8322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8323 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8324 if (!SWIG_IsOK(ecode1)) {
8325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8326 }
8327 arg1 = static_cast< bool >(val1);
8328 {
8329 PyThreadState* __tstate = wxPyBeginAllowThreads();
8330 wxToolTip::Enable(arg1);
8331 wxPyEndAllowThreads(__tstate);
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 resultobj = SWIG_Py_Void();
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8342 PyObject *resultobj = 0;
8343 long arg1 ;
8344 long val1 ;
8345 int ecode1 = 0 ;
8346 PyObject * obj0 = 0 ;
8347 char * kwnames[] = {
8348 (char *) "milliseconds", NULL
8349 };
8350
8351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8352 ecode1 = SWIG_AsVal_long(obj0, &val1);
8353 if (!SWIG_IsOK(ecode1)) {
8354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8355 }
8356 arg1 = static_cast< long >(val1);
8357 {
8358 PyThreadState* __tstate = wxPyBeginAllowThreads();
8359 wxToolTip::SetDelay(arg1);
8360 wxPyEndAllowThreads(__tstate);
8361 if (PyErr_Occurred()) SWIG_fail;
8362 }
8363 resultobj = SWIG_Py_Void();
8364 return resultobj;
8365 fail:
8366 return NULL;
8367 }
8368
8369
8370 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8371 PyObject *obj;
8372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8373 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8374 return SWIG_Py_Void();
8375 }
8376
8377 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8378 return SWIG_Python_InitShadowInstance(args);
8379 }
8380
8381 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj = 0;
8383 wxWindow *arg1 = (wxWindow *) 0 ;
8384 wxSize *arg2 = 0 ;
8385 wxCaret *result = 0 ;
8386 void *argp1 = 0 ;
8387 int res1 = 0 ;
8388 wxSize temp2 ;
8389 PyObject * obj0 = 0 ;
8390 PyObject * obj1 = 0 ;
8391 char * kwnames[] = {
8392 (char *) "window",(char *) "size", NULL
8393 };
8394
8395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8397 if (!SWIG_IsOK(res1)) {
8398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8399 }
8400 arg1 = reinterpret_cast< wxWindow * >(argp1);
8401 {
8402 arg2 = &temp2;
8403 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8404 }
8405 {
8406 if (!wxPyCheckForApp()) SWIG_fail;
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8413 return resultobj;
8414 fail:
8415 return NULL;
8416 }
8417
8418
8419 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8420 PyObject *resultobj = 0;
8421 wxCaret *arg1 = (wxCaret *) 0 ;
8422 void *argp1 = 0 ;
8423 int res1 = 0 ;
8424 PyObject *swig_obj[1] ;
8425
8426 if (!args) SWIG_fail;
8427 swig_obj[0] = args;
8428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8431 }
8432 arg1 = reinterpret_cast< wxCaret * >(argp1);
8433 {
8434 PyThreadState* __tstate = wxPyBeginAllowThreads();
8435 delete arg1;
8436
8437 wxPyEndAllowThreads(__tstate);
8438 if (PyErr_Occurred()) SWIG_fail;
8439 }
8440 resultobj = SWIG_Py_Void();
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8448 PyObject *resultobj = 0;
8449 wxCaret *arg1 = (wxCaret *) 0 ;
8450 void *argp1 = 0 ;
8451 int res1 = 0 ;
8452 PyObject *swig_obj[1] ;
8453
8454 if (!args) SWIG_fail;
8455 swig_obj[0] = args;
8456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8457 if (!SWIG_IsOK(res1)) {
8458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8459 }
8460 arg1 = reinterpret_cast< wxCaret * >(argp1);
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 wxCaret_Destroy(arg1);
8464 wxPyEndAllowThreads(__tstate);
8465 if (PyErr_Occurred()) SWIG_fail;
8466 }
8467 resultobj = SWIG_Py_Void();
8468 return resultobj;
8469 fail:
8470 return NULL;
8471 }
8472
8473
8474 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8475 PyObject *resultobj = 0;
8476 wxCaret *arg1 = (wxCaret *) 0 ;
8477 bool result;
8478 void *argp1 = 0 ;
8479 int res1 = 0 ;
8480 PyObject *swig_obj[1] ;
8481
8482 if (!args) SWIG_fail;
8483 swig_obj[0] = args;
8484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8485 if (!SWIG_IsOK(res1)) {
8486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8487 }
8488 arg1 = reinterpret_cast< wxCaret * >(argp1);
8489 {
8490 PyThreadState* __tstate = wxPyBeginAllowThreads();
8491 result = (bool)(arg1)->IsOk();
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 {
8496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8497 }
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8505 PyObject *resultobj = 0;
8506 wxCaret *arg1 = (wxCaret *) 0 ;
8507 bool result;
8508 void *argp1 = 0 ;
8509 int res1 = 0 ;
8510 PyObject *swig_obj[1] ;
8511
8512 if (!args) SWIG_fail;
8513 swig_obj[0] = args;
8514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8515 if (!SWIG_IsOK(res1)) {
8516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8517 }
8518 arg1 = reinterpret_cast< wxCaret * >(argp1);
8519 {
8520 PyThreadState* __tstate = wxPyBeginAllowThreads();
8521 result = (bool)(arg1)->IsVisible();
8522 wxPyEndAllowThreads(__tstate);
8523 if (PyErr_Occurred()) SWIG_fail;
8524 }
8525 {
8526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8527 }
8528 return resultobj;
8529 fail:
8530 return NULL;
8531 }
8532
8533
8534 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8535 PyObject *resultobj = 0;
8536 wxCaret *arg1 = (wxCaret *) 0 ;
8537 wxPoint result;
8538 void *argp1 = 0 ;
8539 int res1 = 0 ;
8540 PyObject *swig_obj[1] ;
8541
8542 if (!args) SWIG_fail;
8543 swig_obj[0] = args;
8544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8545 if (!SWIG_IsOK(res1)) {
8546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8547 }
8548 arg1 = reinterpret_cast< wxCaret * >(argp1);
8549 {
8550 PyThreadState* __tstate = wxPyBeginAllowThreads();
8551 result = (arg1)->GetPosition();
8552 wxPyEndAllowThreads(__tstate);
8553 if (PyErr_Occurred()) SWIG_fail;
8554 }
8555 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8563 PyObject *resultobj = 0;
8564 wxCaret *arg1 = (wxCaret *) 0 ;
8565 int *arg2 = (int *) 0 ;
8566 int *arg3 = (int *) 0 ;
8567 void *argp1 = 0 ;
8568 int res1 = 0 ;
8569 int temp2 ;
8570 int res2 = SWIG_TMPOBJ ;
8571 int temp3 ;
8572 int res3 = SWIG_TMPOBJ ;
8573 PyObject *swig_obj[1] ;
8574
8575 arg2 = &temp2;
8576 arg3 = &temp3;
8577 if (!args) SWIG_fail;
8578 swig_obj[0] = args;
8579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8580 if (!SWIG_IsOK(res1)) {
8581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8582 }
8583 arg1 = reinterpret_cast< wxCaret * >(argp1);
8584 {
8585 PyThreadState* __tstate = wxPyBeginAllowThreads();
8586 (arg1)->GetPosition(arg2,arg3);
8587 wxPyEndAllowThreads(__tstate);
8588 if (PyErr_Occurred()) SWIG_fail;
8589 }
8590 resultobj = SWIG_Py_Void();
8591 if (SWIG_IsTmpObj(res2)) {
8592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8593 } else {
8594 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8596 }
8597 if (SWIG_IsTmpObj(res3)) {
8598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8599 } else {
8600 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8602 }
8603 return resultobj;
8604 fail:
8605 return NULL;
8606 }
8607
8608
8609 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8610 PyObject *resultobj = 0;
8611 wxCaret *arg1 = (wxCaret *) 0 ;
8612 wxSize result;
8613 void *argp1 = 0 ;
8614 int res1 = 0 ;
8615 PyObject *swig_obj[1] ;
8616
8617 if (!args) SWIG_fail;
8618 swig_obj[0] = args;
8619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8620 if (!SWIG_IsOK(res1)) {
8621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8622 }
8623 arg1 = reinterpret_cast< wxCaret * >(argp1);
8624 {
8625 PyThreadState* __tstate = wxPyBeginAllowThreads();
8626 result = (arg1)->GetSize();
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8631 return resultobj;
8632 fail:
8633 return NULL;
8634 }
8635
8636
8637 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8638 PyObject *resultobj = 0;
8639 wxCaret *arg1 = (wxCaret *) 0 ;
8640 int *arg2 = (int *) 0 ;
8641 int *arg3 = (int *) 0 ;
8642 void *argp1 = 0 ;
8643 int res1 = 0 ;
8644 int temp2 ;
8645 int res2 = SWIG_TMPOBJ ;
8646 int temp3 ;
8647 int res3 = SWIG_TMPOBJ ;
8648 PyObject *swig_obj[1] ;
8649
8650 arg2 = &temp2;
8651 arg3 = &temp3;
8652 if (!args) SWIG_fail;
8653 swig_obj[0] = args;
8654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8655 if (!SWIG_IsOK(res1)) {
8656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8657 }
8658 arg1 = reinterpret_cast< wxCaret * >(argp1);
8659 {
8660 PyThreadState* __tstate = wxPyBeginAllowThreads();
8661 (arg1)->GetSize(arg2,arg3);
8662 wxPyEndAllowThreads(__tstate);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 resultobj = SWIG_Py_Void();
8666 if (SWIG_IsTmpObj(res2)) {
8667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8668 } else {
8669 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8670 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8671 }
8672 if (SWIG_IsTmpObj(res3)) {
8673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8674 } else {
8675 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8677 }
8678 return resultobj;
8679 fail:
8680 return NULL;
8681 }
8682
8683
8684 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8685 PyObject *resultobj = 0;
8686 wxCaret *arg1 = (wxCaret *) 0 ;
8687 wxWindow *result = 0 ;
8688 void *argp1 = 0 ;
8689 int res1 = 0 ;
8690 PyObject *swig_obj[1] ;
8691
8692 if (!args) SWIG_fail;
8693 swig_obj[0] = args;
8694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8697 }
8698 arg1 = reinterpret_cast< wxCaret * >(argp1);
8699 {
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 result = (wxWindow *)(arg1)->GetWindow();
8702 wxPyEndAllowThreads(__tstate);
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 {
8706 resultobj = wxPyMake_wxObject(result, 0);
8707 }
8708 return resultobj;
8709 fail:
8710 return NULL;
8711 }
8712
8713
8714 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8715 PyObject *resultobj = 0;
8716 wxCaret *arg1 = (wxCaret *) 0 ;
8717 int arg2 ;
8718 int arg3 ;
8719 void *argp1 = 0 ;
8720 int res1 = 0 ;
8721 int val2 ;
8722 int ecode2 = 0 ;
8723 int val3 ;
8724 int ecode3 = 0 ;
8725 PyObject * obj0 = 0 ;
8726 PyObject * obj1 = 0 ;
8727 PyObject * obj2 = 0 ;
8728 char * kwnames[] = {
8729 (char *) "self",(char *) "x",(char *) "y", NULL
8730 };
8731
8732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8734 if (!SWIG_IsOK(res1)) {
8735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8736 }
8737 arg1 = reinterpret_cast< wxCaret * >(argp1);
8738 ecode2 = SWIG_AsVal_int(obj1, &val2);
8739 if (!SWIG_IsOK(ecode2)) {
8740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8741 }
8742 arg2 = static_cast< int >(val2);
8743 ecode3 = SWIG_AsVal_int(obj2, &val3);
8744 if (!SWIG_IsOK(ecode3)) {
8745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8746 }
8747 arg3 = static_cast< int >(val3);
8748 {
8749 PyThreadState* __tstate = wxPyBeginAllowThreads();
8750 (arg1)->Move(arg2,arg3);
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 resultobj = SWIG_Py_Void();
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj = 0;
8763 wxCaret *arg1 = (wxCaret *) 0 ;
8764 wxPoint *arg2 = 0 ;
8765 void *argp1 = 0 ;
8766 int res1 = 0 ;
8767 wxPoint temp2 ;
8768 PyObject * obj0 = 0 ;
8769 PyObject * obj1 = 0 ;
8770 char * kwnames[] = {
8771 (char *) "self",(char *) "pt", NULL
8772 };
8773
8774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8778 }
8779 arg1 = reinterpret_cast< wxCaret * >(argp1);
8780 {
8781 arg2 = &temp2;
8782 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8783 }
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 (arg1)->Move((wxPoint const &)*arg2);
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_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxCaret *arg1 = (wxCaret *) 0 ;
8800 int arg2 ;
8801 int arg3 ;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 int val2 ;
8805 int ecode2 = 0 ;
8806 int val3 ;
8807 int ecode3 = 0 ;
8808 PyObject * obj0 = 0 ;
8809 PyObject * obj1 = 0 ;
8810 PyObject * obj2 = 0 ;
8811 char * kwnames[] = {
8812 (char *) "self",(char *) "width",(char *) "height", NULL
8813 };
8814
8815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8817 if (!SWIG_IsOK(res1)) {
8818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8819 }
8820 arg1 = reinterpret_cast< wxCaret * >(argp1);
8821 ecode2 = SWIG_AsVal_int(obj1, &val2);
8822 if (!SWIG_IsOK(ecode2)) {
8823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8824 }
8825 arg2 = static_cast< int >(val2);
8826 ecode3 = SWIG_AsVal_int(obj2, &val3);
8827 if (!SWIG_IsOK(ecode3)) {
8828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8829 }
8830 arg3 = static_cast< int >(val3);
8831 {
8832 PyThreadState* __tstate = wxPyBeginAllowThreads();
8833 (arg1)->SetSize(arg2,arg3);
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 resultobj = SWIG_Py_Void();
8838 return resultobj;
8839 fail:
8840 return NULL;
8841 }
8842
8843
8844 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8845 PyObject *resultobj = 0;
8846 wxCaret *arg1 = (wxCaret *) 0 ;
8847 wxSize *arg2 = 0 ;
8848 void *argp1 = 0 ;
8849 int res1 = 0 ;
8850 wxSize temp2 ;
8851 PyObject * obj0 = 0 ;
8852 PyObject * obj1 = 0 ;
8853 char * kwnames[] = {
8854 (char *) "self",(char *) "size", NULL
8855 };
8856
8857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8859 if (!SWIG_IsOK(res1)) {
8860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8861 }
8862 arg1 = reinterpret_cast< wxCaret * >(argp1);
8863 {
8864 arg2 = &temp2;
8865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8866 }
8867 {
8868 PyThreadState* __tstate = wxPyBeginAllowThreads();
8869 (arg1)->SetSize((wxSize const &)*arg2);
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_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj = 0;
8882 wxCaret *arg1 = (wxCaret *) 0 ;
8883 int arg2 = (int) true ;
8884 void *argp1 = 0 ;
8885 int res1 = 0 ;
8886 int val2 ;
8887 int ecode2 = 0 ;
8888 PyObject * obj0 = 0 ;
8889 PyObject * obj1 = 0 ;
8890 char * kwnames[] = {
8891 (char *) "self",(char *) "show", NULL
8892 };
8893
8894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8896 if (!SWIG_IsOK(res1)) {
8897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8898 }
8899 arg1 = reinterpret_cast< wxCaret * >(argp1);
8900 if (obj1) {
8901 ecode2 = SWIG_AsVal_int(obj1, &val2);
8902 if (!SWIG_IsOK(ecode2)) {
8903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8904 }
8905 arg2 = static_cast< int >(val2);
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 (arg1)->Show(arg2);
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 resultobj = SWIG_Py_Void();
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8921 PyObject *resultobj = 0;
8922 wxCaret *arg1 = (wxCaret *) 0 ;
8923 void *argp1 = 0 ;
8924 int res1 = 0 ;
8925 PyObject *swig_obj[1] ;
8926
8927 if (!args) SWIG_fail;
8928 swig_obj[0] = args;
8929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8930 if (!SWIG_IsOK(res1)) {
8931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8932 }
8933 arg1 = reinterpret_cast< wxCaret * >(argp1);
8934 {
8935 PyThreadState* __tstate = wxPyBeginAllowThreads();
8936 (arg1)->Hide();
8937 wxPyEndAllowThreads(__tstate);
8938 if (PyErr_Occurred()) SWIG_fail;
8939 }
8940 resultobj = SWIG_Py_Void();
8941 return resultobj;
8942 fail:
8943 return NULL;
8944 }
8945
8946
8947 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8948 PyObject *resultobj = 0;
8949 int result;
8950
8951 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = (int)wxCaret::GetBlinkTime();
8955 wxPyEndAllowThreads(__tstate);
8956 if (PyErr_Occurred()) SWIG_fail;
8957 }
8958 resultobj = SWIG_From_int(static_cast< int >(result));
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8966 PyObject *resultobj = 0;
8967 int arg1 ;
8968 int val1 ;
8969 int ecode1 = 0 ;
8970 PyObject * obj0 = 0 ;
8971 char * kwnames[] = {
8972 (char *) "milliseconds", NULL
8973 };
8974
8975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8976 ecode1 = SWIG_AsVal_int(obj0, &val1);
8977 if (!SWIG_IsOK(ecode1)) {
8978 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8979 }
8980 arg1 = static_cast< int >(val1);
8981 {
8982 PyThreadState* __tstate = wxPyBeginAllowThreads();
8983 wxCaret::SetBlinkTime(arg1);
8984 wxPyEndAllowThreads(__tstate);
8985 if (PyErr_Occurred()) SWIG_fail;
8986 }
8987 resultobj = SWIG_Py_Void();
8988 return resultobj;
8989 fail:
8990 return NULL;
8991 }
8992
8993
8994 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8995 PyObject *obj;
8996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8997 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8998 return SWIG_Py_Void();
8999 }
9000
9001 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9002 return SWIG_Python_InitShadowInstance(args);
9003 }
9004
9005 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9006 PyObject *resultobj = 0;
9007 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9008 wxBusyCursor *result = 0 ;
9009 void *argp1 = 0 ;
9010 int res1 = 0 ;
9011 PyObject * obj0 = 0 ;
9012 char * kwnames[] = {
9013 (char *) "cursor", NULL
9014 };
9015
9016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9017 if (obj0) {
9018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9019 if (!SWIG_IsOK(res1)) {
9020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9021 }
9022 arg1 = reinterpret_cast< wxCursor * >(argp1);
9023 }
9024 {
9025 if (!wxPyCheckForApp()) SWIG_fail;
9026 PyThreadState* __tstate = wxPyBeginAllowThreads();
9027 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9028 wxPyEndAllowThreads(__tstate);
9029 if (PyErr_Occurred()) SWIG_fail;
9030 }
9031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9032 return resultobj;
9033 fail:
9034 return NULL;
9035 }
9036
9037
9038 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9039 PyObject *resultobj = 0;
9040 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9041 void *argp1 = 0 ;
9042 int res1 = 0 ;
9043 PyObject *swig_obj[1] ;
9044
9045 if (!args) SWIG_fail;
9046 swig_obj[0] = args;
9047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9048 if (!SWIG_IsOK(res1)) {
9049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9050 }
9051 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9052 {
9053 PyThreadState* __tstate = wxPyBeginAllowThreads();
9054 delete arg1;
9055
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 resultobj = SWIG_Py_Void();
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067 PyObject *obj;
9068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9069 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9070 return SWIG_Py_Void();
9071 }
9072
9073 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9074 return SWIG_Python_InitShadowInstance(args);
9075 }
9076
9077 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9078 PyObject *resultobj = 0;
9079 wxWindow *arg1 = (wxWindow *) NULL ;
9080 wxWindowDisabler *result = 0 ;
9081 void *argp1 = 0 ;
9082 int res1 = 0 ;
9083 PyObject * obj0 = 0 ;
9084 char * kwnames[] = {
9085 (char *) "winToSkip", NULL
9086 };
9087
9088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9089 if (obj0) {
9090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9091 if (!SWIG_IsOK(res1)) {
9092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9093 }
9094 arg1 = reinterpret_cast< wxWindow * >(argp1);
9095 }
9096 {
9097 if (!wxPyCheckForApp()) SWIG_fail;
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9111 PyObject *resultobj = 0;
9112 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9113 void *argp1 = 0 ;
9114 int res1 = 0 ;
9115 PyObject *swig_obj[1] ;
9116
9117 if (!args) SWIG_fail;
9118 swig_obj[0] = args;
9119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9120 if (!SWIG_IsOK(res1)) {
9121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9122 }
9123 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 delete arg1;
9127
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 resultobj = SWIG_Py_Void();
9132 return resultobj;
9133 fail:
9134 return NULL;
9135 }
9136
9137
9138 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9139 PyObject *obj;
9140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9141 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9142 return SWIG_Py_Void();
9143 }
9144
9145 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9146 return SWIG_Python_InitShadowInstance(args);
9147 }
9148
9149 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9150 PyObject *resultobj = 0;
9151 wxString *arg1 = 0 ;
9152 wxWindow *arg2 = (wxWindow *) NULL ;
9153 wxBusyInfo *result = 0 ;
9154 bool temp1 = false ;
9155 void *argp2 = 0 ;
9156 int res2 = 0 ;
9157 PyObject * obj0 = 0 ;
9158 PyObject * obj1 = 0 ;
9159 char * kwnames[] = {
9160 (char *) "message",(char *) "parent", NULL
9161 };
9162
9163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9164 {
9165 arg1 = wxString_in_helper(obj0);
9166 if (arg1 == NULL) SWIG_fail;
9167 temp1 = true;
9168 }
9169 if (obj1) {
9170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9171 if (!SWIG_IsOK(res2)) {
9172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9173 }
9174 arg2 = reinterpret_cast< wxWindow * >(argp2);
9175 }
9176 {
9177 if (!wxPyCheckForApp()) SWIG_fail;
9178 PyThreadState* __tstate = wxPyBeginAllowThreads();
9179 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9180 wxPyEndAllowThreads(__tstate);
9181 if (PyErr_Occurred()) SWIG_fail;
9182 }
9183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9184 {
9185 if (temp1)
9186 delete arg1;
9187 }
9188 return resultobj;
9189 fail:
9190 {
9191 if (temp1)
9192 delete arg1;
9193 }
9194 return NULL;
9195 }
9196
9197
9198 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9199 PyObject *resultobj = 0;
9200 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9201 void *argp1 = 0 ;
9202 int res1 = 0 ;
9203 PyObject *swig_obj[1] ;
9204
9205 if (!args) SWIG_fail;
9206 swig_obj[0] = args;
9207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9208 if (!SWIG_IsOK(res1)) {
9209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9210 }
9211 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 delete arg1;
9215
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_Py_Void();
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *obj;
9228 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9229 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9230 return SWIG_Py_Void();
9231 }
9232
9233 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234 return SWIG_Python_InitShadowInstance(args);
9235 }
9236
9237 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *resultobj = 0;
9239 wxStopWatch *result = 0 ;
9240
9241 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9242 {
9243 PyThreadState* __tstate = wxPyBeginAllowThreads();
9244 result = (wxStopWatch *)new wxStopWatch();
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9249 return resultobj;
9250 fail:
9251 return NULL;
9252 }
9253
9254
9255 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9256 PyObject *resultobj = 0;
9257 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9258 void *argp1 = 0 ;
9259 int res1 = 0 ;
9260 PyObject *swig_obj[1] ;
9261
9262 if (!args) SWIG_fail;
9263 swig_obj[0] = args;
9264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9265 if (!SWIG_IsOK(res1)) {
9266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9267 }
9268 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 delete arg1;
9272
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = SWIG_Py_Void();
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9284 PyObject *resultobj = 0;
9285 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9286 long arg2 = (long) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 long val2 ;
9290 int ecode2 = 0 ;
9291 PyObject * obj0 = 0 ;
9292 PyObject * obj1 = 0 ;
9293 char * kwnames[] = {
9294 (char *) "self",(char *) "t0", NULL
9295 };
9296
9297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9299 if (!SWIG_IsOK(res1)) {
9300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9301 }
9302 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9303 if (obj1) {
9304 ecode2 = SWIG_AsVal_long(obj1, &val2);
9305 if (!SWIG_IsOK(ecode2)) {
9306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9307 }
9308 arg2 = static_cast< long >(val2);
9309 }
9310 {
9311 PyThreadState* __tstate = wxPyBeginAllowThreads();
9312 (arg1)->Start(arg2);
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 resultobj = SWIG_Py_Void();
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9324 PyObject *resultobj = 0;
9325 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9326 void *argp1 = 0 ;
9327 int res1 = 0 ;
9328 PyObject *swig_obj[1] ;
9329
9330 if (!args) SWIG_fail;
9331 swig_obj[0] = args;
9332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9333 if (!SWIG_IsOK(res1)) {
9334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9335 }
9336 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9337 {
9338 PyThreadState* __tstate = wxPyBeginAllowThreads();
9339 (arg1)->Pause();
9340 wxPyEndAllowThreads(__tstate);
9341 if (PyErr_Occurred()) SWIG_fail;
9342 }
9343 resultobj = SWIG_Py_Void();
9344 return resultobj;
9345 fail:
9346 return NULL;
9347 }
9348
9349
9350 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9351 PyObject *resultobj = 0;
9352 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9353 void *argp1 = 0 ;
9354 int res1 = 0 ;
9355 PyObject *swig_obj[1] ;
9356
9357 if (!args) SWIG_fail;
9358 swig_obj[0] = args;
9359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9360 if (!SWIG_IsOK(res1)) {
9361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9362 }
9363 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9364 {
9365 PyThreadState* __tstate = wxPyBeginAllowThreads();
9366 (arg1)->Resume();
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 resultobj = SWIG_Py_Void();
9371 return resultobj;
9372 fail:
9373 return NULL;
9374 }
9375
9376
9377 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9378 PyObject *resultobj = 0;
9379 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9380 long result;
9381 void *argp1 = 0 ;
9382 int res1 = 0 ;
9383 PyObject *swig_obj[1] ;
9384
9385 if (!args) SWIG_fail;
9386 swig_obj[0] = args;
9387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9388 if (!SWIG_IsOK(res1)) {
9389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9390 }
9391 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9392 {
9393 PyThreadState* __tstate = wxPyBeginAllowThreads();
9394 result = (long)((wxStopWatch const *)arg1)->Time();
9395 wxPyEndAllowThreads(__tstate);
9396 if (PyErr_Occurred()) SWIG_fail;
9397 }
9398 resultobj = SWIG_From_long(static_cast< long >(result));
9399 return resultobj;
9400 fail:
9401 return NULL;
9402 }
9403
9404
9405 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9406 PyObject *obj;
9407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9408 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9409 return SWIG_Py_Void();
9410 }
9411
9412 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9413 return SWIG_Python_InitShadowInstance(args);
9414 }
9415
9416 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9417 PyObject *resultobj = 0;
9418 int arg1 = (int) 9 ;
9419 int arg2 = (int) wxID_FILE1 ;
9420 wxFileHistory *result = 0 ;
9421 int val1 ;
9422 int ecode1 = 0 ;
9423 int val2 ;
9424 int ecode2 = 0 ;
9425 PyObject * obj0 = 0 ;
9426 PyObject * obj1 = 0 ;
9427 char * kwnames[] = {
9428 (char *) "maxFiles",(char *) "idBase", NULL
9429 };
9430
9431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9432 if (obj0) {
9433 ecode1 = SWIG_AsVal_int(obj0, &val1);
9434 if (!SWIG_IsOK(ecode1)) {
9435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9436 }
9437 arg1 = static_cast< int >(val1);
9438 }
9439 if (obj1) {
9440 ecode2 = SWIG_AsVal_int(obj1, &val2);
9441 if (!SWIG_IsOK(ecode2)) {
9442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9443 }
9444 arg2 = static_cast< int >(val2);
9445 }
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9449 wxPyEndAllowThreads(__tstate);
9450 if (PyErr_Occurred()) SWIG_fail;
9451 }
9452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9453 return resultobj;
9454 fail:
9455 return NULL;
9456 }
9457
9458
9459 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9460 PyObject *resultobj = 0;
9461 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9462 void *argp1 = 0 ;
9463 int res1 = 0 ;
9464 PyObject *swig_obj[1] ;
9465
9466 if (!args) SWIG_fail;
9467 swig_obj[0] = args;
9468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9471 }
9472 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9473 {
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 delete arg1;
9476
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 resultobj = SWIG_Py_Void();
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9488 PyObject *resultobj = 0;
9489 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9490 wxString *arg2 = 0 ;
9491 void *argp1 = 0 ;
9492 int res1 = 0 ;
9493 bool temp2 = false ;
9494 PyObject * obj0 = 0 ;
9495 PyObject * obj1 = 0 ;
9496 char * kwnames[] = {
9497 (char *) "self",(char *) "file", NULL
9498 };
9499
9500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9502 if (!SWIG_IsOK(res1)) {
9503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9504 }
9505 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9506 {
9507 arg2 = wxString_in_helper(obj1);
9508 if (arg2 == NULL) SWIG_fail;
9509 temp2 = true;
9510 }
9511 {
9512 PyThreadState* __tstate = wxPyBeginAllowThreads();
9513 (arg1)->AddFileToHistory((wxString const &)*arg2);
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 resultobj = SWIG_Py_Void();
9518 {
9519 if (temp2)
9520 delete arg2;
9521 }
9522 return resultobj;
9523 fail:
9524 {
9525 if (temp2)
9526 delete arg2;
9527 }
9528 return NULL;
9529 }
9530
9531
9532 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9533 PyObject *resultobj = 0;
9534 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9535 int arg2 ;
9536 void *argp1 = 0 ;
9537 int res1 = 0 ;
9538 int val2 ;
9539 int ecode2 = 0 ;
9540 PyObject * obj0 = 0 ;
9541 PyObject * obj1 = 0 ;
9542 char * kwnames[] = {
9543 (char *) "self",(char *) "i", NULL
9544 };
9545
9546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9548 if (!SWIG_IsOK(res1)) {
9549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9550 }
9551 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9552 ecode2 = SWIG_AsVal_int(obj1, &val2);
9553 if (!SWIG_IsOK(ecode2)) {
9554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9555 }
9556 arg2 = static_cast< int >(val2);
9557 {
9558 PyThreadState* __tstate = wxPyBeginAllowThreads();
9559 (arg1)->RemoveFileFromHistory(arg2);
9560 wxPyEndAllowThreads(__tstate);
9561 if (PyErr_Occurred()) SWIG_fail;
9562 }
9563 resultobj = SWIG_Py_Void();
9564 return resultobj;
9565 fail:
9566 return NULL;
9567 }
9568
9569
9570 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9571 PyObject *resultobj = 0;
9572 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9573 int result;
9574 void *argp1 = 0 ;
9575 int res1 = 0 ;
9576 PyObject *swig_obj[1] ;
9577
9578 if (!args) SWIG_fail;
9579 swig_obj[0] = args;
9580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9581 if (!SWIG_IsOK(res1)) {
9582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9583 }
9584 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9585 {
9586 PyThreadState* __tstate = wxPyBeginAllowThreads();
9587 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9588 wxPyEndAllowThreads(__tstate);
9589 if (PyErr_Occurred()) SWIG_fail;
9590 }
9591 resultobj = SWIG_From_int(static_cast< int >(result));
9592 return resultobj;
9593 fail:
9594 return NULL;
9595 }
9596
9597
9598 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj = 0;
9600 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9601 wxMenu *arg2 = (wxMenu *) 0 ;
9602 void *argp1 = 0 ;
9603 int res1 = 0 ;
9604 void *argp2 = 0 ;
9605 int res2 = 0 ;
9606 PyObject * obj0 = 0 ;
9607 PyObject * obj1 = 0 ;
9608 char * kwnames[] = {
9609 (char *) "self",(char *) "menu", NULL
9610 };
9611
9612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9614 if (!SWIG_IsOK(res1)) {
9615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9616 }
9617 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9618 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9619 if (!SWIG_IsOK(res2)) {
9620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9621 }
9622 arg2 = reinterpret_cast< wxMenu * >(argp2);
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 (arg1)->UseMenu(arg2);
9626 wxPyEndAllowThreads(__tstate);
9627 if (PyErr_Occurred()) SWIG_fail;
9628 }
9629 resultobj = SWIG_Py_Void();
9630 return resultobj;
9631 fail:
9632 return NULL;
9633 }
9634
9635
9636 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9637 PyObject *resultobj = 0;
9638 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9639 wxMenu *arg2 = (wxMenu *) 0 ;
9640 void *argp1 = 0 ;
9641 int res1 = 0 ;
9642 void *argp2 = 0 ;
9643 int res2 = 0 ;
9644 PyObject * obj0 = 0 ;
9645 PyObject * obj1 = 0 ;
9646 char * kwnames[] = {
9647 (char *) "self",(char *) "menu", NULL
9648 };
9649
9650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9652 if (!SWIG_IsOK(res1)) {
9653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9654 }
9655 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9657 if (!SWIG_IsOK(res2)) {
9658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9659 }
9660 arg2 = reinterpret_cast< wxMenu * >(argp2);
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 (arg1)->RemoveMenu(arg2);
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 resultobj = SWIG_Py_Void();
9668 return resultobj;
9669 fail:
9670 return NULL;
9671 }
9672
9673
9674 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9675 PyObject *resultobj = 0;
9676 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9677 wxConfigBase *arg2 = 0 ;
9678 void *argp1 = 0 ;
9679 int res1 = 0 ;
9680 void *argp2 = 0 ;
9681 int res2 = 0 ;
9682 PyObject * obj0 = 0 ;
9683 PyObject * obj1 = 0 ;
9684 char * kwnames[] = {
9685 (char *) "self",(char *) "config", NULL
9686 };
9687
9688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9690 if (!SWIG_IsOK(res1)) {
9691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9692 }
9693 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9695 if (!SWIG_IsOK(res2)) {
9696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9697 }
9698 if (!argp2) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9700 }
9701 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9702 {
9703 PyThreadState* __tstate = wxPyBeginAllowThreads();
9704 (arg1)->Load(*arg2);
9705 wxPyEndAllowThreads(__tstate);
9706 if (PyErr_Occurred()) SWIG_fail;
9707 }
9708 resultobj = SWIG_Py_Void();
9709 return resultobj;
9710 fail:
9711 return NULL;
9712 }
9713
9714
9715 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9716 PyObject *resultobj = 0;
9717 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9718 wxConfigBase *arg2 = 0 ;
9719 void *argp1 = 0 ;
9720 int res1 = 0 ;
9721 void *argp2 = 0 ;
9722 int res2 = 0 ;
9723 PyObject * obj0 = 0 ;
9724 PyObject * obj1 = 0 ;
9725 char * kwnames[] = {
9726 (char *) "self",(char *) "config", NULL
9727 };
9728
9729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9731 if (!SWIG_IsOK(res1)) {
9732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9733 }
9734 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9735 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9736 if (!SWIG_IsOK(res2)) {
9737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9738 }
9739 if (!argp2) {
9740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9741 }
9742 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9743 {
9744 PyThreadState* __tstate = wxPyBeginAllowThreads();
9745 (arg1)->Save(*arg2);
9746 wxPyEndAllowThreads(__tstate);
9747 if (PyErr_Occurred()) SWIG_fail;
9748 }
9749 resultobj = SWIG_Py_Void();
9750 return resultobj;
9751 fail:
9752 return NULL;
9753 }
9754
9755
9756 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9757 PyObject *resultobj = 0;
9758 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 PyObject *swig_obj[1] ;
9762
9763 if (!args) SWIG_fail;
9764 swig_obj[0] = args;
9765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9766 if (!SWIG_IsOK(res1)) {
9767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9768 }
9769 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 (arg1)->AddFilesToMenu();
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 resultobj = SWIG_Py_Void();
9777 return resultobj;
9778 fail:
9779 return NULL;
9780 }
9781
9782
9783 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj = 0;
9785 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9786 wxMenu *arg2 = (wxMenu *) 0 ;
9787 void *argp1 = 0 ;
9788 int res1 = 0 ;
9789 void *argp2 = 0 ;
9790 int res2 = 0 ;
9791 PyObject * obj0 = 0 ;
9792 PyObject * obj1 = 0 ;
9793 char * kwnames[] = {
9794 (char *) "self",(char *) "menu", NULL
9795 };
9796
9797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9799 if (!SWIG_IsOK(res1)) {
9800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9801 }
9802 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9803 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9804 if (!SWIG_IsOK(res2)) {
9805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9806 }
9807 arg2 = reinterpret_cast< wxMenu * >(argp2);
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 (arg1)->AddFilesToMenu(arg2);
9811 wxPyEndAllowThreads(__tstate);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 resultobj = SWIG_Py_Void();
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9822 PyObject *resultobj = 0;
9823 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9824 int arg2 ;
9825 wxString result;
9826 void *argp1 = 0 ;
9827 int res1 = 0 ;
9828 int val2 ;
9829 int ecode2 = 0 ;
9830 PyObject * obj0 = 0 ;
9831 PyObject * obj1 = 0 ;
9832 char * kwnames[] = {
9833 (char *) "self",(char *) "i", NULL
9834 };
9835
9836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9838 if (!SWIG_IsOK(res1)) {
9839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9840 }
9841 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9842 ecode2 = SWIG_AsVal_int(obj1, &val2);
9843 if (!SWIG_IsOK(ecode2)) {
9844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9845 }
9846 arg2 = static_cast< int >(val2);
9847 {
9848 PyThreadState* __tstate = wxPyBeginAllowThreads();
9849 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 {
9854 #if wxUSE_UNICODE
9855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9856 #else
9857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9858 #endif
9859 }
9860 return resultobj;
9861 fail:
9862 return NULL;
9863 }
9864
9865
9866 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 PyObject *resultobj = 0;
9868 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9869 int result;
9870 void *argp1 = 0 ;
9871 int res1 = 0 ;
9872 PyObject *swig_obj[1] ;
9873
9874 if (!args) SWIG_fail;
9875 swig_obj[0] = args;
9876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9877 if (!SWIG_IsOK(res1)) {
9878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9879 }
9880 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (int)((wxFileHistory const *)arg1)->GetCount();
9884 wxPyEndAllowThreads(__tstate);
9885 if (PyErr_Occurred()) SWIG_fail;
9886 }
9887 resultobj = SWIG_From_int(static_cast< int >(result));
9888 return resultobj;
9889 fail:
9890 return NULL;
9891 }
9892
9893
9894 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9895 PyObject *obj;
9896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9897 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9898 return SWIG_Py_Void();
9899 }
9900
9901 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 return SWIG_Python_InitShadowInstance(args);
9903 }
9904
9905 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9906 PyObject *resultobj = 0;
9907 wxString *arg1 = 0 ;
9908 wxString const &arg2_defvalue = wxPyEmptyString ;
9909 wxString *arg2 = (wxString *) &arg2_defvalue ;
9910 wxSingleInstanceChecker *result = 0 ;
9911 bool temp1 = false ;
9912 bool temp2 = false ;
9913 PyObject * obj0 = 0 ;
9914 PyObject * obj1 = 0 ;
9915 char * kwnames[] = {
9916 (char *) "name",(char *) "path", NULL
9917 };
9918
9919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9920 {
9921 arg1 = wxString_in_helper(obj0);
9922 if (arg1 == NULL) SWIG_fail;
9923 temp1 = true;
9924 }
9925 if (obj1) {
9926 {
9927 arg2 = wxString_in_helper(obj1);
9928 if (arg2 == NULL) SWIG_fail;
9929 temp2 = true;
9930 }
9931 }
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9939 {
9940 if (temp1)
9941 delete arg1;
9942 }
9943 {
9944 if (temp2)
9945 delete arg2;
9946 }
9947 return resultobj;
9948 fail:
9949 {
9950 if (temp1)
9951 delete arg1;
9952 }
9953 {
9954 if (temp2)
9955 delete arg2;
9956 }
9957 return NULL;
9958 }
9959
9960
9961 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9962 PyObject *resultobj = 0;
9963 wxSingleInstanceChecker *result = 0 ;
9964
9965 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9966 {
9967 PyThreadState* __tstate = wxPyBeginAllowThreads();
9968 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9969 wxPyEndAllowThreads(__tstate);
9970 if (PyErr_Occurred()) SWIG_fail;
9971 }
9972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9980 PyObject *resultobj = 0;
9981 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9982 void *argp1 = 0 ;
9983 int res1 = 0 ;
9984 PyObject *swig_obj[1] ;
9985
9986 if (!args) SWIG_fail;
9987 swig_obj[0] = args;
9988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9991 }
9992 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9993 {
9994 PyThreadState* __tstate = wxPyBeginAllowThreads();
9995 delete arg1;
9996
9997 wxPyEndAllowThreads(__tstate);
9998 if (PyErr_Occurred()) SWIG_fail;
9999 }
10000 resultobj = SWIG_Py_Void();
10001 return resultobj;
10002 fail:
10003 return NULL;
10004 }
10005
10006
10007 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10008 PyObject *resultobj = 0;
10009 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10010 wxString *arg2 = 0 ;
10011 wxString const &arg3_defvalue = wxPyEmptyString ;
10012 wxString *arg3 = (wxString *) &arg3_defvalue ;
10013 bool result;
10014 void *argp1 = 0 ;
10015 int res1 = 0 ;
10016 bool temp2 = false ;
10017 bool temp3 = false ;
10018 PyObject * obj0 = 0 ;
10019 PyObject * obj1 = 0 ;
10020 PyObject * obj2 = 0 ;
10021 char * kwnames[] = {
10022 (char *) "self",(char *) "name",(char *) "path", NULL
10023 };
10024
10025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10027 if (!SWIG_IsOK(res1)) {
10028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10029 }
10030 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10031 {
10032 arg2 = wxString_in_helper(obj1);
10033 if (arg2 == NULL) SWIG_fail;
10034 temp2 = true;
10035 }
10036 if (obj2) {
10037 {
10038 arg3 = wxString_in_helper(obj2);
10039 if (arg3 == NULL) SWIG_fail;
10040 temp3 = true;
10041 }
10042 }
10043 {
10044 PyThreadState* __tstate = wxPyBeginAllowThreads();
10045 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 {
10050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10051 }
10052 {
10053 if (temp2)
10054 delete arg2;
10055 }
10056 {
10057 if (temp3)
10058 delete arg3;
10059 }
10060 return resultobj;
10061 fail:
10062 {
10063 if (temp2)
10064 delete arg2;
10065 }
10066 {
10067 if (temp3)
10068 delete arg3;
10069 }
10070 return NULL;
10071 }
10072
10073
10074 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10075 PyObject *resultobj = 0;
10076 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10077 bool result;
10078 void *argp1 = 0 ;
10079 int res1 = 0 ;
10080 PyObject *swig_obj[1] ;
10081
10082 if (!args) SWIG_fail;
10083 swig_obj[0] = args;
10084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10085 if (!SWIG_IsOK(res1)) {
10086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10087 }
10088 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10089 {
10090 PyThreadState* __tstate = wxPyBeginAllowThreads();
10091 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10092 wxPyEndAllowThreads(__tstate);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 {
10096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10097 }
10098 return resultobj;
10099 fail:
10100 return NULL;
10101 }
10102
10103
10104 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10105 PyObject *obj;
10106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10107 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10108 return SWIG_Py_Void();
10109 }
10110
10111 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10112 return SWIG_Python_InitShadowInstance(args);
10113 }
10114
10115 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10116 PyObject *resultobj = 0;
10117 wxPlatformInfo *result = 0 ;
10118
10119 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 result = (wxPlatformInfo *)new wxPlatformInfo();
10123 wxPyEndAllowThreads(__tstate);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj = 0;
10135 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10136 wxPlatformInfo *arg2 = 0 ;
10137 bool result;
10138 void *argp1 = 0 ;
10139 int res1 = 0 ;
10140 void *argp2 = 0 ;
10141 int res2 = 0 ;
10142 PyObject * obj0 = 0 ;
10143 PyObject * obj1 = 0 ;
10144 char * kwnames[] = {
10145 (char *) "self",(char *) "t", NULL
10146 };
10147
10148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10150 if (!SWIG_IsOK(res1)) {
10151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10152 }
10153 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10154 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10155 if (!SWIG_IsOK(res2)) {
10156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10157 }
10158 if (!argp2) {
10159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10160 }
10161 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10162 {
10163 PyThreadState* __tstate = wxPyBeginAllowThreads();
10164 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10165 wxPyEndAllowThreads(__tstate);
10166 if (PyErr_Occurred()) SWIG_fail;
10167 }
10168 {
10169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10170 }
10171 return resultobj;
10172 fail:
10173 return NULL;
10174 }
10175
10176
10177 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10178 PyObject *resultobj = 0;
10179 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10180 wxPlatformInfo *arg2 = 0 ;
10181 bool result;
10182 void *argp1 = 0 ;
10183 int res1 = 0 ;
10184 void *argp2 = 0 ;
10185 int res2 = 0 ;
10186 PyObject * obj0 = 0 ;
10187 PyObject * obj1 = 0 ;
10188 char * kwnames[] = {
10189 (char *) "self",(char *) "t", NULL
10190 };
10191
10192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10194 if (!SWIG_IsOK(res1)) {
10195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10196 }
10197 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10198 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10199 if (!SWIG_IsOK(res2)) {
10200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10201 }
10202 if (!argp2) {
10203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10204 }
10205 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10206 {
10207 PyThreadState* __tstate = wxPyBeginAllowThreads();
10208 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10209 wxPyEndAllowThreads(__tstate);
10210 if (PyErr_Occurred()) SWIG_fail;
10211 }
10212 {
10213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10214 }
10215 return resultobj;
10216 fail:
10217 return NULL;
10218 }
10219
10220
10221 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10222 PyObject *resultobj = 0;
10223 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10224 int result;
10225 void *argp1 = 0 ;
10226 int res1 = 0 ;
10227 PyObject *swig_obj[1] ;
10228
10229 if (!args) SWIG_fail;
10230 swig_obj[0] = args;
10231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10232 if (!SWIG_IsOK(res1)) {
10233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10234 }
10235 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10236 {
10237 PyThreadState* __tstate = wxPyBeginAllowThreads();
10238 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10239 wxPyEndAllowThreads(__tstate);
10240 if (PyErr_Occurred()) SWIG_fail;
10241 }
10242 resultobj = SWIG_From_int(static_cast< int >(result));
10243 return resultobj;
10244 fail:
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10250 PyObject *resultobj = 0;
10251 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10252 int result;
10253 void *argp1 = 0 ;
10254 int res1 = 0 ;
10255 PyObject *swig_obj[1] ;
10256
10257 if (!args) SWIG_fail;
10258 swig_obj[0] = args;
10259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10260 if (!SWIG_IsOK(res1)) {
10261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10262 }
10263 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10264 {
10265 PyThreadState* __tstate = wxPyBeginAllowThreads();
10266 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10267 wxPyEndAllowThreads(__tstate);
10268 if (PyErr_Occurred()) SWIG_fail;
10269 }
10270 resultobj = SWIG_From_int(static_cast< int >(result));
10271 return resultobj;
10272 fail:
10273 return NULL;
10274 }
10275
10276
10277 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10278 PyObject *resultobj = 0;
10279 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10280 int arg2 ;
10281 int arg3 ;
10282 bool result;
10283 void *argp1 = 0 ;
10284 int res1 = 0 ;
10285 int val2 ;
10286 int ecode2 = 0 ;
10287 int val3 ;
10288 int ecode3 = 0 ;
10289 PyObject * obj0 = 0 ;
10290 PyObject * obj1 = 0 ;
10291 PyObject * obj2 = 0 ;
10292 char * kwnames[] = {
10293 (char *) "self",(char *) "major",(char *) "minor", NULL
10294 };
10295
10296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10298 if (!SWIG_IsOK(res1)) {
10299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10300 }
10301 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10302 ecode2 = SWIG_AsVal_int(obj1, &val2);
10303 if (!SWIG_IsOK(ecode2)) {
10304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10305 }
10306 arg2 = static_cast< int >(val2);
10307 ecode3 = SWIG_AsVal_int(obj2, &val3);
10308 if (!SWIG_IsOK(ecode3)) {
10309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10310 }
10311 arg3 = static_cast< int >(val3);
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10315 wxPyEndAllowThreads(__tstate);
10316 if (PyErr_Occurred()) SWIG_fail;
10317 }
10318 {
10319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10320 }
10321 return resultobj;
10322 fail:
10323 return NULL;
10324 }
10325
10326
10327 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10328 PyObject *resultobj = 0;
10329 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10330 int result;
10331 void *argp1 = 0 ;
10332 int res1 = 0 ;
10333 PyObject *swig_obj[1] ;
10334
10335 if (!args) SWIG_fail;
10336 swig_obj[0] = args;
10337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10338 if (!SWIG_IsOK(res1)) {
10339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10340 }
10341 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10342 {
10343 PyThreadState* __tstate = wxPyBeginAllowThreads();
10344 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10345 wxPyEndAllowThreads(__tstate);
10346 if (PyErr_Occurred()) SWIG_fail;
10347 }
10348 resultobj = SWIG_From_int(static_cast< int >(result));
10349 return resultobj;
10350 fail:
10351 return NULL;
10352 }
10353
10354
10355 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10356 PyObject *resultobj = 0;
10357 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10358 int result;
10359 void *argp1 = 0 ;
10360 int res1 = 0 ;
10361 PyObject *swig_obj[1] ;
10362
10363 if (!args) SWIG_fail;
10364 swig_obj[0] = args;
10365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10366 if (!SWIG_IsOK(res1)) {
10367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10368 }
10369 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10370 {
10371 PyThreadState* __tstate = wxPyBeginAllowThreads();
10372 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10373 wxPyEndAllowThreads(__tstate);
10374 if (PyErr_Occurred()) SWIG_fail;
10375 }
10376 resultobj = SWIG_From_int(static_cast< int >(result));
10377 return resultobj;
10378 fail:
10379 return NULL;
10380 }
10381
10382
10383 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10384 PyObject *resultobj = 0;
10385 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10386 int arg2 ;
10387 int arg3 ;
10388 bool result;
10389 void *argp1 = 0 ;
10390 int res1 = 0 ;
10391 int val2 ;
10392 int ecode2 = 0 ;
10393 int val3 ;
10394 int ecode3 = 0 ;
10395 PyObject * obj0 = 0 ;
10396 PyObject * obj1 = 0 ;
10397 PyObject * obj2 = 0 ;
10398 char * kwnames[] = {
10399 (char *) "self",(char *) "major",(char *) "minor", NULL
10400 };
10401
10402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10404 if (!SWIG_IsOK(res1)) {
10405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10406 }
10407 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10408 ecode2 = SWIG_AsVal_int(obj1, &val2);
10409 if (!SWIG_IsOK(ecode2)) {
10410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10411 }
10412 arg2 = static_cast< int >(val2);
10413 ecode3 = SWIG_AsVal_int(obj2, &val3);
10414 if (!SWIG_IsOK(ecode3)) {
10415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10416 }
10417 arg3 = static_cast< int >(val3);
10418 {
10419 PyThreadState* __tstate = wxPyBeginAllowThreads();
10420 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10421 wxPyEndAllowThreads(__tstate);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 {
10425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10426 }
10427 return resultobj;
10428 fail:
10429 return NULL;
10430 }
10431
10432
10433 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10434 PyObject *resultobj = 0;
10435 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10436 bool result;
10437 void *argp1 = 0 ;
10438 int res1 = 0 ;
10439 PyObject *swig_obj[1] ;
10440
10441 if (!args) SWIG_fail;
10442 swig_obj[0] = args;
10443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10444 if (!SWIG_IsOK(res1)) {
10445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10446 }
10447 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10451 wxPyEndAllowThreads(__tstate);
10452 if (PyErr_Occurred()) SWIG_fail;
10453 }
10454 {
10455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10456 }
10457 return resultobj;
10458 fail:
10459 return NULL;
10460 }
10461
10462
10463 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10464 PyObject *resultobj = 0;
10465 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10466 wxOperatingSystemId result;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 PyObject *swig_obj[1] ;
10470
10471 if (!args) SWIG_fail;
10472 swig_obj[0] = args;
10473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10474 if (!SWIG_IsOK(res1)) {
10475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10476 }
10477 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10478 {
10479 PyThreadState* __tstate = wxPyBeginAllowThreads();
10480 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 resultobj = SWIG_From_int(static_cast< int >(result));
10485 return resultobj;
10486 fail:
10487 return NULL;
10488 }
10489
10490
10491 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10492 PyObject *resultobj = 0;
10493 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10494 wxPortId result;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 PyObject *swig_obj[1] ;
10498
10499 if (!args) SWIG_fail;
10500 swig_obj[0] = args;
10501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10502 if (!SWIG_IsOK(res1)) {
10503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10504 }
10505 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10509 wxPyEndAllowThreads(__tstate);
10510 if (PyErr_Occurred()) SWIG_fail;
10511 }
10512 resultobj = SWIG_From_int(static_cast< int >(result));
10513 return resultobj;
10514 fail:
10515 return NULL;
10516 }
10517
10518
10519 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10520 PyObject *resultobj = 0;
10521 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10522 wxArchitecture result;
10523 void *argp1 = 0 ;
10524 int res1 = 0 ;
10525 PyObject *swig_obj[1] ;
10526
10527 if (!args) SWIG_fail;
10528 swig_obj[0] = args;
10529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10530 if (!SWIG_IsOK(res1)) {
10531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10532 }
10533 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10534 {
10535 PyThreadState* __tstate = wxPyBeginAllowThreads();
10536 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10537 wxPyEndAllowThreads(__tstate);
10538 if (PyErr_Occurred()) SWIG_fail;
10539 }
10540 resultobj = SWIG_From_int(static_cast< int >(result));
10541 return resultobj;
10542 fail:
10543 return NULL;
10544 }
10545
10546
10547 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10548 PyObject *resultobj = 0;
10549 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10550 wxEndianness result;
10551 void *argp1 = 0 ;
10552 int res1 = 0 ;
10553 PyObject *swig_obj[1] ;
10554
10555 if (!args) SWIG_fail;
10556 swig_obj[0] = args;
10557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10558 if (!SWIG_IsOK(res1)) {
10559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10560 }
10561 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10562 {
10563 PyThreadState* __tstate = wxPyBeginAllowThreads();
10564 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10565 wxPyEndAllowThreads(__tstate);
10566 if (PyErr_Occurred()) SWIG_fail;
10567 }
10568 resultobj = SWIG_From_int(static_cast< int >(result));
10569 return resultobj;
10570 fail:
10571 return NULL;
10572 }
10573
10574
10575 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10576 PyObject *resultobj = 0;
10577 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10578 wxString result;
10579 void *argp1 = 0 ;
10580 int res1 = 0 ;
10581 PyObject *swig_obj[1] ;
10582
10583 if (!args) SWIG_fail;
10584 swig_obj[0] = args;
10585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10586 if (!SWIG_IsOK(res1)) {
10587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10588 }
10589 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10590 {
10591 PyThreadState* __tstate = wxPyBeginAllowThreads();
10592 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10593 wxPyEndAllowThreads(__tstate);
10594 if (PyErr_Occurred()) SWIG_fail;
10595 }
10596 {
10597 #if wxUSE_UNICODE
10598 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10599 #else
10600 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10601 #endif
10602 }
10603 return resultobj;
10604 fail:
10605 return NULL;
10606 }
10607
10608
10609 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10610 PyObject *resultobj = 0;
10611 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10612 wxString result;
10613 void *argp1 = 0 ;
10614 int res1 = 0 ;
10615 PyObject *swig_obj[1] ;
10616
10617 if (!args) SWIG_fail;
10618 swig_obj[0] = args;
10619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10620 if (!SWIG_IsOK(res1)) {
10621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10622 }
10623 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 {
10631 #if wxUSE_UNICODE
10632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10633 #else
10634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10635 #endif
10636 }
10637 return resultobj;
10638 fail:
10639 return NULL;
10640 }
10641
10642
10643 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10644 PyObject *resultobj = 0;
10645 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10646 wxString result;
10647 void *argp1 = 0 ;
10648 int res1 = 0 ;
10649 PyObject *swig_obj[1] ;
10650
10651 if (!args) SWIG_fail;
10652 swig_obj[0] = args;
10653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10654 if (!SWIG_IsOK(res1)) {
10655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10656 }
10657 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10658 {
10659 PyThreadState* __tstate = wxPyBeginAllowThreads();
10660 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10661 wxPyEndAllowThreads(__tstate);
10662 if (PyErr_Occurred()) SWIG_fail;
10663 }
10664 {
10665 #if wxUSE_UNICODE
10666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10667 #else
10668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10669 #endif
10670 }
10671 return resultobj;
10672 fail:
10673 return NULL;
10674 }
10675
10676
10677 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10678 PyObject *resultobj = 0;
10679 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10680 wxString result;
10681 void *argp1 = 0 ;
10682 int res1 = 0 ;
10683 PyObject *swig_obj[1] ;
10684
10685 if (!args) SWIG_fail;
10686 swig_obj[0] = args;
10687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10688 if (!SWIG_IsOK(res1)) {
10689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10690 }
10691 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10692 {
10693 PyThreadState* __tstate = wxPyBeginAllowThreads();
10694 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10695 wxPyEndAllowThreads(__tstate);
10696 if (PyErr_Occurred()) SWIG_fail;
10697 }
10698 {
10699 #if wxUSE_UNICODE
10700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10701 #else
10702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10703 #endif
10704 }
10705 return resultobj;
10706 fail:
10707 return NULL;
10708 }
10709
10710
10711 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10712 PyObject *resultobj = 0;
10713 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10714 wxString result;
10715 void *argp1 = 0 ;
10716 int res1 = 0 ;
10717 PyObject *swig_obj[1] ;
10718
10719 if (!args) SWIG_fail;
10720 swig_obj[0] = args;
10721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10722 if (!SWIG_IsOK(res1)) {
10723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10724 }
10725 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 {
10733 #if wxUSE_UNICODE
10734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10735 #else
10736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10737 #endif
10738 }
10739 return resultobj;
10740 fail:
10741 return NULL;
10742 }
10743
10744
10745 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10746 PyObject *resultobj = 0;
10747 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10748 wxString result;
10749 void *argp1 = 0 ;
10750 int res1 = 0 ;
10751 PyObject *swig_obj[1] ;
10752
10753 if (!args) SWIG_fail;
10754 swig_obj[0] = args;
10755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10756 if (!SWIG_IsOK(res1)) {
10757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10758 }
10759 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 {
10767 #if wxUSE_UNICODE
10768 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10769 #else
10770 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10771 #endif
10772 }
10773 return resultobj;
10774 fail:
10775 return NULL;
10776 }
10777
10778
10779 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj = 0;
10781 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10782 int arg2 ;
10783 int arg3 ;
10784 void *argp1 = 0 ;
10785 int res1 = 0 ;
10786 int val2 ;
10787 int ecode2 = 0 ;
10788 int val3 ;
10789 int ecode3 = 0 ;
10790 PyObject * obj0 = 0 ;
10791 PyObject * obj1 = 0 ;
10792 PyObject * obj2 = 0 ;
10793 char * kwnames[] = {
10794 (char *) "self",(char *) "major",(char *) "minor", NULL
10795 };
10796
10797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10799 if (!SWIG_IsOK(res1)) {
10800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10801 }
10802 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10803 ecode2 = SWIG_AsVal_int(obj1, &val2);
10804 if (!SWIG_IsOK(ecode2)) {
10805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10806 }
10807 arg2 = static_cast< int >(val2);
10808 ecode3 = SWIG_AsVal_int(obj2, &val3);
10809 if (!SWIG_IsOK(ecode3)) {
10810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10811 }
10812 arg3 = static_cast< int >(val3);
10813 {
10814 PyThreadState* __tstate = wxPyBeginAllowThreads();
10815 (arg1)->SetOSVersion(arg2,arg3);
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 resultobj = SWIG_Py_Void();
10820 return resultobj;
10821 fail:
10822 return NULL;
10823 }
10824
10825
10826 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10827 PyObject *resultobj = 0;
10828 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10829 int arg2 ;
10830 int arg3 ;
10831 void *argp1 = 0 ;
10832 int res1 = 0 ;
10833 int val2 ;
10834 int ecode2 = 0 ;
10835 int val3 ;
10836 int ecode3 = 0 ;
10837 PyObject * obj0 = 0 ;
10838 PyObject * obj1 = 0 ;
10839 PyObject * obj2 = 0 ;
10840 char * kwnames[] = {
10841 (char *) "self",(char *) "major",(char *) "minor", NULL
10842 };
10843
10844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10846 if (!SWIG_IsOK(res1)) {
10847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10848 }
10849 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10850 ecode2 = SWIG_AsVal_int(obj1, &val2);
10851 if (!SWIG_IsOK(ecode2)) {
10852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10853 }
10854 arg2 = static_cast< int >(val2);
10855 ecode3 = SWIG_AsVal_int(obj2, &val3);
10856 if (!SWIG_IsOK(ecode3)) {
10857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10858 }
10859 arg3 = static_cast< int >(val3);
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 (arg1)->SetToolkitVersion(arg2,arg3);
10863 wxPyEndAllowThreads(__tstate);
10864 if (PyErr_Occurred()) SWIG_fail;
10865 }
10866 resultobj = SWIG_Py_Void();
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10874 PyObject *resultobj = 0;
10875 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10876 wxOperatingSystemId arg2 ;
10877 void *argp1 = 0 ;
10878 int res1 = 0 ;
10879 int val2 ;
10880 int ecode2 = 0 ;
10881 PyObject * obj0 = 0 ;
10882 PyObject * obj1 = 0 ;
10883 char * kwnames[] = {
10884 (char *) "self",(char *) "n", NULL
10885 };
10886
10887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10889 if (!SWIG_IsOK(res1)) {
10890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10891 }
10892 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10893 ecode2 = SWIG_AsVal_int(obj1, &val2);
10894 if (!SWIG_IsOK(ecode2)) {
10895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10896 }
10897 arg2 = static_cast< wxOperatingSystemId >(val2);
10898 {
10899 PyThreadState* __tstate = wxPyBeginAllowThreads();
10900 (arg1)->SetOperatingSystemId(arg2);
10901 wxPyEndAllowThreads(__tstate);
10902 if (PyErr_Occurred()) SWIG_fail;
10903 }
10904 resultobj = SWIG_Py_Void();
10905 return resultobj;
10906 fail:
10907 return NULL;
10908 }
10909
10910
10911 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10912 PyObject *resultobj = 0;
10913 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10914 wxPortId arg2 ;
10915 void *argp1 = 0 ;
10916 int res1 = 0 ;
10917 int val2 ;
10918 int ecode2 = 0 ;
10919 PyObject * obj0 = 0 ;
10920 PyObject * obj1 = 0 ;
10921 char * kwnames[] = {
10922 (char *) "self",(char *) "n", NULL
10923 };
10924
10925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10927 if (!SWIG_IsOK(res1)) {
10928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10929 }
10930 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10931 ecode2 = SWIG_AsVal_int(obj1, &val2);
10932 if (!SWIG_IsOK(ecode2)) {
10933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10934 }
10935 arg2 = static_cast< wxPortId >(val2);
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 (arg1)->SetPortId(arg2);
10939 wxPyEndAllowThreads(__tstate);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 resultobj = SWIG_Py_Void();
10943 return resultobj;
10944 fail:
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10950 PyObject *resultobj = 0;
10951 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10952 wxArchitecture arg2 ;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 int val2 ;
10956 int ecode2 = 0 ;
10957 PyObject * obj0 = 0 ;
10958 PyObject * obj1 = 0 ;
10959 char * kwnames[] = {
10960 (char *) "self",(char *) "n", NULL
10961 };
10962
10963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10965 if (!SWIG_IsOK(res1)) {
10966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10967 }
10968 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10969 ecode2 = SWIG_AsVal_int(obj1, &val2);
10970 if (!SWIG_IsOK(ecode2)) {
10971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10972 }
10973 arg2 = static_cast< wxArchitecture >(val2);
10974 {
10975 PyThreadState* __tstate = wxPyBeginAllowThreads();
10976 (arg1)->SetArchitecture(arg2);
10977 wxPyEndAllowThreads(__tstate);
10978 if (PyErr_Occurred()) SWIG_fail;
10979 }
10980 resultobj = SWIG_Py_Void();
10981 return resultobj;
10982 fail:
10983 return NULL;
10984 }
10985
10986
10987 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10988 PyObject *resultobj = 0;
10989 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10990 wxEndianness arg2 ;
10991 void *argp1 = 0 ;
10992 int res1 = 0 ;
10993 int val2 ;
10994 int ecode2 = 0 ;
10995 PyObject * obj0 = 0 ;
10996 PyObject * obj1 = 0 ;
10997 char * kwnames[] = {
10998 (char *) "self",(char *) "n", NULL
10999 };
11000
11001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11003 if (!SWIG_IsOK(res1)) {
11004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11005 }
11006 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11007 ecode2 = SWIG_AsVal_int(obj1, &val2);
11008 if (!SWIG_IsOK(ecode2)) {
11009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11010 }
11011 arg2 = static_cast< wxEndianness >(val2);
11012 {
11013 PyThreadState* __tstate = wxPyBeginAllowThreads();
11014 (arg1)->SetEndianness(arg2);
11015 wxPyEndAllowThreads(__tstate);
11016 if (PyErr_Occurred()) SWIG_fail;
11017 }
11018 resultobj = SWIG_Py_Void();
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11026 PyObject *resultobj = 0;
11027 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11028 bool result;
11029 void *argp1 = 0 ;
11030 int res1 = 0 ;
11031 PyObject *swig_obj[1] ;
11032
11033 if (!args) SWIG_fail;
11034 swig_obj[0] = args;
11035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11036 if (!SWIG_IsOK(res1)) {
11037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11038 }
11039 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11040 {
11041 PyThreadState* __tstate = wxPyBeginAllowThreads();
11042 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11043 wxPyEndAllowThreads(__tstate);
11044 if (PyErr_Occurred()) SWIG_fail;
11045 }
11046 {
11047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11048 }
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 PyObject *obj;
11057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11058 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11059 return SWIG_Py_Void();
11060 }
11061
11062 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11063 return SWIG_Python_InitShadowInstance(args);
11064 }
11065
11066 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11067 PyObject *resultobj = 0;
11068 wxWindow *arg1 = (wxWindow *) 0 ;
11069 wxDC *arg2 = 0 ;
11070 bool result;
11071 void *argp1 = 0 ;
11072 int res1 = 0 ;
11073 void *argp2 = 0 ;
11074 int res2 = 0 ;
11075 PyObject * obj0 = 0 ;
11076 PyObject * obj1 = 0 ;
11077 char * kwnames[] = {
11078 (char *) "window",(char *) "dc", NULL
11079 };
11080
11081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11083 if (!SWIG_IsOK(res1)) {
11084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11085 }
11086 arg1 = reinterpret_cast< wxWindow * >(argp1);
11087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11088 if (!SWIG_IsOK(res2)) {
11089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11090 }
11091 if (!argp2) {
11092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11093 }
11094 arg2 = reinterpret_cast< wxDC * >(argp2);
11095 {
11096 PyThreadState* __tstate = wxPyBeginAllowThreads();
11097 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11098 wxPyEndAllowThreads(__tstate);
11099 if (PyErr_Occurred()) SWIG_fail;
11100 }
11101 {
11102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11103 }
11104 return resultobj;
11105 fail:
11106 return NULL;
11107 }
11108
11109
11110 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11111 PyObject *resultobj = 0;
11112 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11113 void *argp1 = 0 ;
11114 int res1 = 0 ;
11115 PyObject *swig_obj[1] ;
11116
11117 if (!args) SWIG_fail;
11118 swig_obj[0] = args;
11119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11120 if (!SWIG_IsOK(res1)) {
11121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11122 }
11123 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 delete arg1;
11127
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 resultobj = SWIG_Py_Void();
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11139 PyObject *resultobj = 0;
11140 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11141 wxString result;
11142 void *argp1 = 0 ;
11143 int res1 = 0 ;
11144 PyObject *swig_obj[1] ;
11145
11146 if (!args) SWIG_fail;
11147 swig_obj[0] = args;
11148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11149 if (!SWIG_IsOK(res1)) {
11150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11151 }
11152 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11153 {
11154 PyThreadState* __tstate = wxPyBeginAllowThreads();
11155 result = (arg1)->GetTip();
11156 wxPyEndAllowThreads(__tstate);
11157 if (PyErr_Occurred()) SWIG_fail;
11158 }
11159 {
11160 #if wxUSE_UNICODE
11161 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11162 #else
11163 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11164 #endif
11165 }
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11173 PyObject *resultobj = 0;
11174 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11175 size_t result;
11176 void *argp1 = 0 ;
11177 int res1 = 0 ;
11178 PyObject *swig_obj[1] ;
11179
11180 if (!args) SWIG_fail;
11181 swig_obj[0] = args;
11182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11183 if (!SWIG_IsOK(res1)) {
11184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11185 }
11186 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (size_t)(arg1)->GetCurrentTip();
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11201 PyObject *resultobj = 0;
11202 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11203 wxString *arg2 = 0 ;
11204 wxString result;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 bool temp2 = false ;
11208 PyObject * obj0 = 0 ;
11209 PyObject * obj1 = 0 ;
11210 char * kwnames[] = {
11211 (char *) "self",(char *) "tip", NULL
11212 };
11213
11214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11216 if (!SWIG_IsOK(res1)) {
11217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11218 }
11219 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11220 {
11221 arg2 = wxString_in_helper(obj1);
11222 if (arg2 == NULL) SWIG_fail;
11223 temp2 = true;
11224 }
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11228 wxPyEndAllowThreads(__tstate);
11229 if (PyErr_Occurred()) SWIG_fail;
11230 }
11231 {
11232 #if wxUSE_UNICODE
11233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11234 #else
11235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11236 #endif
11237 }
11238 {
11239 if (temp2)
11240 delete arg2;
11241 }
11242 return resultobj;
11243 fail:
11244 {
11245 if (temp2)
11246 delete arg2;
11247 }
11248 return NULL;
11249 }
11250
11251
11252 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11253 PyObject *obj;
11254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11255 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11256 return SWIG_Py_Void();
11257 }
11258
11259 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj = 0;
11261 size_t arg1 ;
11262 wxPyTipProvider *result = 0 ;
11263 size_t val1 ;
11264 int ecode1 = 0 ;
11265 PyObject * obj0 = 0 ;
11266 char * kwnames[] = {
11267 (char *) "currentTip", NULL
11268 };
11269
11270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11271 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11272 if (!SWIG_IsOK(ecode1)) {
11273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11274 }
11275 arg1 = static_cast< size_t >(val1);
11276 {
11277 PyThreadState* __tstate = wxPyBeginAllowThreads();
11278 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11279 wxPyEndAllowThreads(__tstate);
11280 if (PyErr_Occurred()) SWIG_fail;
11281 }
11282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11283 return resultobj;
11284 fail:
11285 return NULL;
11286 }
11287
11288
11289 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11290 PyObject *resultobj = 0;
11291 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11292 PyObject *arg2 = (PyObject *) 0 ;
11293 PyObject *arg3 = (PyObject *) 0 ;
11294 void *argp1 = 0 ;
11295 int res1 = 0 ;
11296 PyObject * obj0 = 0 ;
11297 PyObject * obj1 = 0 ;
11298 PyObject * obj2 = 0 ;
11299 char * kwnames[] = {
11300 (char *) "self",(char *) "self",(char *) "_class", NULL
11301 };
11302
11303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11305 if (!SWIG_IsOK(res1)) {
11306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11307 }
11308 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11309 arg2 = obj1;
11310 arg3 = obj2;
11311 {
11312 PyThreadState* __tstate = wxPyBeginAllowThreads();
11313 (arg1)->_setCallbackInfo(arg2,arg3);
11314 wxPyEndAllowThreads(__tstate);
11315 if (PyErr_Occurred()) SWIG_fail;
11316 }
11317 resultobj = SWIG_Py_Void();
11318 return resultobj;
11319 fail:
11320 return NULL;
11321 }
11322
11323
11324 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11325 PyObject *obj;
11326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11327 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11328 return SWIG_Py_Void();
11329 }
11330
11331 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11332 return SWIG_Python_InitShadowInstance(args);
11333 }
11334
11335 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11336 PyObject *resultobj = 0;
11337 wxWindow *arg1 = (wxWindow *) 0 ;
11338 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11339 bool arg3 = (bool) true ;
11340 bool result;
11341 void *argp1 = 0 ;
11342 int res1 = 0 ;
11343 void *argp2 = 0 ;
11344 int res2 = 0 ;
11345 bool val3 ;
11346 int ecode3 = 0 ;
11347 PyObject * obj0 = 0 ;
11348 PyObject * obj1 = 0 ;
11349 PyObject * obj2 = 0 ;
11350 char * kwnames[] = {
11351 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11352 };
11353
11354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11356 if (!SWIG_IsOK(res1)) {
11357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11358 }
11359 arg1 = reinterpret_cast< wxWindow * >(argp1);
11360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11361 if (!SWIG_IsOK(res2)) {
11362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11363 }
11364 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11365 if (obj2) {
11366 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11367 if (!SWIG_IsOK(ecode3)) {
11368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11369 }
11370 arg3 = static_cast< bool >(val3);
11371 }
11372 {
11373 if (!wxPyCheckForApp()) SWIG_fail;
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 result = (bool)wxShowTip(arg1,arg2,arg3);
11376 wxPyEndAllowThreads(__tstate);
11377 if (PyErr_Occurred()) SWIG_fail;
11378 }
11379 {
11380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11381 }
11382 return resultobj;
11383 fail:
11384 return NULL;
11385 }
11386
11387
11388 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11389 PyObject *resultobj = 0;
11390 wxString *arg1 = 0 ;
11391 size_t arg2 ;
11392 wxTipProvider *result = 0 ;
11393 bool temp1 = false ;
11394 size_t val2 ;
11395 int ecode2 = 0 ;
11396 PyObject * obj0 = 0 ;
11397 PyObject * obj1 = 0 ;
11398 char * kwnames[] = {
11399 (char *) "filename",(char *) "currentTip", NULL
11400 };
11401
11402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11403 {
11404 arg1 = wxString_in_helper(obj0);
11405 if (arg1 == NULL) SWIG_fail;
11406 temp1 = true;
11407 }
11408 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11409 if (!SWIG_IsOK(ecode2)) {
11410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11411 }
11412 arg2 = static_cast< size_t >(val2);
11413 {
11414 if (!wxPyCheckForApp()) SWIG_fail;
11415 PyThreadState* __tstate = wxPyBeginAllowThreads();
11416 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11421 {
11422 if (temp1)
11423 delete arg1;
11424 }
11425 return resultobj;
11426 fail:
11427 {
11428 if (temp1)
11429 delete arg1;
11430 }
11431 return NULL;
11432 }
11433
11434
11435 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj = 0;
11437 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11438 int arg2 = (int) wxID_ANY ;
11439 wxPyTimer *result = 0 ;
11440 void *argp1 = 0 ;
11441 int res1 = 0 ;
11442 int val2 ;
11443 int ecode2 = 0 ;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 char * kwnames[] = {
11447 (char *) "owner",(char *) "id", NULL
11448 };
11449
11450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11451 if (obj0) {
11452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11453 if (!SWIG_IsOK(res1)) {
11454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11455 }
11456 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11457 }
11458 if (obj1) {
11459 ecode2 = SWIG_AsVal_int(obj1, &val2);
11460 if (!SWIG_IsOK(ecode2)) {
11461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11462 }
11463 arg2 = static_cast< int >(val2);
11464 }
11465 {
11466 if (!wxPyCheckForApp()) SWIG_fail;
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11473 return resultobj;
11474 fail:
11475 return NULL;
11476 }
11477
11478
11479 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11480 PyObject *resultobj = 0;
11481 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11482 void *argp1 = 0 ;
11483 int res1 = 0 ;
11484 PyObject *swig_obj[1] ;
11485
11486 if (!args) SWIG_fail;
11487 swig_obj[0] = args;
11488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11489 if (!SWIG_IsOK(res1)) {
11490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11491 }
11492 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11493 {
11494 PyThreadState* __tstate = wxPyBeginAllowThreads();
11495 delete arg1;
11496
11497 wxPyEndAllowThreads(__tstate);
11498 if (PyErr_Occurred()) SWIG_fail;
11499 }
11500 resultobj = SWIG_Py_Void();
11501 return resultobj;
11502 fail:
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj = 0;
11509 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11510 PyObject *arg2 = (PyObject *) 0 ;
11511 PyObject *arg3 = (PyObject *) 0 ;
11512 int arg4 = (int) 0 ;
11513 void *argp1 = 0 ;
11514 int res1 = 0 ;
11515 int val4 ;
11516 int ecode4 = 0 ;
11517 PyObject * obj0 = 0 ;
11518 PyObject * obj1 = 0 ;
11519 PyObject * obj2 = 0 ;
11520 PyObject * obj3 = 0 ;
11521 char * kwnames[] = {
11522 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11523 };
11524
11525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11527 if (!SWIG_IsOK(res1)) {
11528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11529 }
11530 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11531 arg2 = obj1;
11532 arg3 = obj2;
11533 if (obj3) {
11534 ecode4 = SWIG_AsVal_int(obj3, &val4);
11535 if (!SWIG_IsOK(ecode4)) {
11536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11537 }
11538 arg4 = static_cast< int >(val4);
11539 }
11540 {
11541 PyThreadState* __tstate = wxPyBeginAllowThreads();
11542 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 resultobj = SWIG_Py_Void();
11547 return resultobj;
11548 fail:
11549 return NULL;
11550 }
11551
11552
11553 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11554 PyObject *resultobj = 0;
11555 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11556 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11557 int arg3 = (int) wxID_ANY ;
11558 void *argp1 = 0 ;
11559 int res1 = 0 ;
11560 void *argp2 = 0 ;
11561 int res2 = 0 ;
11562 int val3 ;
11563 int ecode3 = 0 ;
11564 PyObject * obj0 = 0 ;
11565 PyObject * obj1 = 0 ;
11566 PyObject * obj2 = 0 ;
11567 char * kwnames[] = {
11568 (char *) "self",(char *) "owner",(char *) "id", NULL
11569 };
11570
11571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11573 if (!SWIG_IsOK(res1)) {
11574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11575 }
11576 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11578 if (!SWIG_IsOK(res2)) {
11579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11580 }
11581 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11582 if (obj2) {
11583 ecode3 = SWIG_AsVal_int(obj2, &val3);
11584 if (!SWIG_IsOK(ecode3)) {
11585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11586 }
11587 arg3 = static_cast< int >(val3);
11588 }
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 (arg1)->SetOwner(arg2,arg3);
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 resultobj = SWIG_Py_Void();
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11603 PyObject *resultobj = 0;
11604 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11605 wxEvtHandler *result = 0 ;
11606 void *argp1 = 0 ;
11607 int res1 = 0 ;
11608 PyObject *swig_obj[1] ;
11609
11610 if (!args) SWIG_fail;
11611 swig_obj[0] = args;
11612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11613 if (!SWIG_IsOK(res1)) {
11614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11615 }
11616 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 result = (wxEvtHandler *)(arg1)->GetOwner();
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 {
11624 resultobj = wxPyMake_wxObject(result, 0);
11625 }
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj = 0;
11634 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11635 int arg2 = (int) -1 ;
11636 bool arg3 = (bool) false ;
11637 bool result;
11638 void *argp1 = 0 ;
11639 int res1 = 0 ;
11640 int val2 ;
11641 int ecode2 = 0 ;
11642 bool val3 ;
11643 int ecode3 = 0 ;
11644 PyObject * obj0 = 0 ;
11645 PyObject * obj1 = 0 ;
11646 PyObject * obj2 = 0 ;
11647 char * kwnames[] = {
11648 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11649 };
11650
11651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11655 }
11656 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11657 if (obj1) {
11658 ecode2 = SWIG_AsVal_int(obj1, &val2);
11659 if (!SWIG_IsOK(ecode2)) {
11660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11661 }
11662 arg2 = static_cast< int >(val2);
11663 }
11664 if (obj2) {
11665 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11666 if (!SWIG_IsOK(ecode3)) {
11667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11668 }
11669 arg3 = static_cast< bool >(val3);
11670 }
11671 {
11672 PyThreadState* __tstate = wxPyBeginAllowThreads();
11673 result = (bool)(arg1)->Start(arg2,arg3);
11674 wxPyEndAllowThreads(__tstate);
11675 if (PyErr_Occurred()) SWIG_fail;
11676 }
11677 {
11678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11679 }
11680 return resultobj;
11681 fail:
11682 return NULL;
11683 }
11684
11685
11686 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11687 PyObject *resultobj = 0;
11688 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11689 void *argp1 = 0 ;
11690 int res1 = 0 ;
11691 PyObject *swig_obj[1] ;
11692
11693 if (!args) SWIG_fail;
11694 swig_obj[0] = args;
11695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11696 if (!SWIG_IsOK(res1)) {
11697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11698 }
11699 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 (arg1)->Stop();
11703 wxPyEndAllowThreads(__tstate);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 resultobj = SWIG_Py_Void();
11707 return resultobj;
11708 fail:
11709 return NULL;
11710 }
11711
11712
11713 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11714 PyObject *resultobj = 0;
11715 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11716 void *argp1 = 0 ;
11717 int res1 = 0 ;
11718 PyObject *swig_obj[1] ;
11719
11720 if (!args) SWIG_fail;
11721 swig_obj[0] = args;
11722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11723 if (!SWIG_IsOK(res1)) {
11724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11725 }
11726 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 (arg1)->Notify();
11730 wxPyEndAllowThreads(__tstate);
11731 if (PyErr_Occurred()) SWIG_fail;
11732 }
11733 resultobj = SWIG_Py_Void();
11734 return resultobj;
11735 fail:
11736 return NULL;
11737 }
11738
11739
11740 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11741 PyObject *resultobj = 0;
11742 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11743 bool result;
11744 void *argp1 = 0 ;
11745 int res1 = 0 ;
11746 PyObject *swig_obj[1] ;
11747
11748 if (!args) SWIG_fail;
11749 swig_obj[0] = args;
11750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11751 if (!SWIG_IsOK(res1)) {
11752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11753 }
11754 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11755 {
11756 PyThreadState* __tstate = wxPyBeginAllowThreads();
11757 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11758 wxPyEndAllowThreads(__tstate);
11759 if (PyErr_Occurred()) SWIG_fail;
11760 }
11761 {
11762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11763 }
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11771 PyObject *resultobj = 0;
11772 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11773 int result;
11774 void *argp1 = 0 ;
11775 int res1 = 0 ;
11776 PyObject *swig_obj[1] ;
11777
11778 if (!args) SWIG_fail;
11779 swig_obj[0] = args;
11780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11781 if (!SWIG_IsOK(res1)) {
11782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11783 }
11784 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11788 wxPyEndAllowThreads(__tstate);
11789 if (PyErr_Occurred()) SWIG_fail;
11790 }
11791 resultobj = SWIG_From_int(static_cast< int >(result));
11792 return resultobj;
11793 fail:
11794 return NULL;
11795 }
11796
11797
11798 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11799 PyObject *resultobj = 0;
11800 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11801 int result;
11802 void *argp1 = 0 ;
11803 int res1 = 0 ;
11804 PyObject *swig_obj[1] ;
11805
11806 if (!args) SWIG_fail;
11807 swig_obj[0] = args;
11808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11809 if (!SWIG_IsOK(res1)) {
11810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11811 }
11812 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 result = (int)((wxPyTimer const *)arg1)->GetId();
11816 wxPyEndAllowThreads(__tstate);
11817 if (PyErr_Occurred()) SWIG_fail;
11818 }
11819 resultobj = SWIG_From_int(static_cast< int >(result));
11820 return resultobj;
11821 fail:
11822 return NULL;
11823 }
11824
11825
11826 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11827 PyObject *resultobj = 0;
11828 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11829 bool result;
11830 void *argp1 = 0 ;
11831 int res1 = 0 ;
11832 PyObject *swig_obj[1] ;
11833
11834 if (!args) SWIG_fail;
11835 swig_obj[0] = args;
11836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11837 if (!SWIG_IsOK(res1)) {
11838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11839 }
11840 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11841 {
11842 PyThreadState* __tstate = wxPyBeginAllowThreads();
11843 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 {
11848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11849 }
11850 return resultobj;
11851 fail:
11852 return NULL;
11853 }
11854
11855
11856 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11857 PyObject *obj;
11858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11859 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11860 return SWIG_Py_Void();
11861 }
11862
11863 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11864 return SWIG_Python_InitShadowInstance(args);
11865 }
11866
11867 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11868 PyObject *resultobj = 0;
11869 int arg1 = (int) 0 ;
11870 int arg2 = (int) 0 ;
11871 wxTimerEvent *result = 0 ;
11872 int val1 ;
11873 int ecode1 = 0 ;
11874 int val2 ;
11875 int ecode2 = 0 ;
11876 PyObject * obj0 = 0 ;
11877 PyObject * obj1 = 0 ;
11878 char * kwnames[] = {
11879 (char *) "timerid",(char *) "interval", NULL
11880 };
11881
11882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11883 if (obj0) {
11884 ecode1 = SWIG_AsVal_int(obj0, &val1);
11885 if (!SWIG_IsOK(ecode1)) {
11886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11887 }
11888 arg1 = static_cast< int >(val1);
11889 }
11890 if (obj1) {
11891 ecode2 = SWIG_AsVal_int(obj1, &val2);
11892 if (!SWIG_IsOK(ecode2)) {
11893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11894 }
11895 arg2 = static_cast< int >(val2);
11896 }
11897 {
11898 PyThreadState* __tstate = wxPyBeginAllowThreads();
11899 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11900 wxPyEndAllowThreads(__tstate);
11901 if (PyErr_Occurred()) SWIG_fail;
11902 }
11903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11904 return resultobj;
11905 fail:
11906 return NULL;
11907 }
11908
11909
11910 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11911 PyObject *resultobj = 0;
11912 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11913 int result;
11914 void *argp1 = 0 ;
11915 int res1 = 0 ;
11916 PyObject *swig_obj[1] ;
11917
11918 if (!args) SWIG_fail;
11919 swig_obj[0] = args;
11920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11921 if (!SWIG_IsOK(res1)) {
11922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11923 }
11924 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11925 {
11926 PyThreadState* __tstate = wxPyBeginAllowThreads();
11927 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11928 wxPyEndAllowThreads(__tstate);
11929 if (PyErr_Occurred()) SWIG_fail;
11930 }
11931 resultobj = SWIG_From_int(static_cast< int >(result));
11932 return resultobj;
11933 fail:
11934 return NULL;
11935 }
11936
11937
11938 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11939 PyObject *obj;
11940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11941 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11942 return SWIG_Py_Void();
11943 }
11944
11945 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11946 return SWIG_Python_InitShadowInstance(args);
11947 }
11948
11949 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11950 PyObject *resultobj = 0;
11951 wxTimer *arg1 = 0 ;
11952 wxTimerRunner *result = 0 ;
11953 void *argp1 = 0 ;
11954 int res1 = 0 ;
11955
11956 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11958 if (!SWIG_IsOK(res1)) {
11959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11960 }
11961 if (!argp1) {
11962 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11963 }
11964 arg1 = reinterpret_cast< wxTimer * >(argp1);
11965 {
11966 if (!wxPyCheckForApp()) SWIG_fail;
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11973 return resultobj;
11974 fail:
11975 return NULL;
11976 }
11977
11978
11979 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11980 PyObject *resultobj = 0;
11981 wxTimer *arg1 = 0 ;
11982 int arg2 ;
11983 bool arg3 = (bool) false ;
11984 wxTimerRunner *result = 0 ;
11985 void *argp1 = 0 ;
11986 int res1 = 0 ;
11987 int val2 ;
11988 int ecode2 = 0 ;
11989 bool val3 ;
11990 int ecode3 = 0 ;
11991
11992 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11994 if (!SWIG_IsOK(res1)) {
11995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11996 }
11997 if (!argp1) {
11998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11999 }
12000 arg1 = reinterpret_cast< wxTimer * >(argp1);
12001 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12002 if (!SWIG_IsOK(ecode2)) {
12003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12004 }
12005 arg2 = static_cast< int >(val2);
12006 if (swig_obj[2]) {
12007 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12008 if (!SWIG_IsOK(ecode3)) {
12009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12010 }
12011 arg3 = static_cast< bool >(val3);
12012 }
12013 {
12014 if (!wxPyCheckForApp()) SWIG_fail;
12015 PyThreadState* __tstate = wxPyBeginAllowThreads();
12016 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12028 int argc;
12029 PyObject *argv[4];
12030
12031 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12032 --argc;
12033 if (argc == 1) {
12034 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12035 }
12036 if ((argc >= 2) && (argc <= 3)) {
12037 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12038 }
12039
12040 fail:
12041 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12042 return NULL;
12043 }
12044
12045
12046 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12047 PyObject *resultobj = 0;
12048 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12049 void *argp1 = 0 ;
12050 int res1 = 0 ;
12051 PyObject *swig_obj[1] ;
12052
12053 if (!args) SWIG_fail;
12054 swig_obj[0] = args;
12055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12058 }
12059 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 delete arg1;
12063
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 resultobj = SWIG_Py_Void();
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12075 PyObject *resultobj = 0;
12076 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12077 int arg2 ;
12078 bool arg3 = (bool) false ;
12079 void *argp1 = 0 ;
12080 int res1 = 0 ;
12081 int val2 ;
12082 int ecode2 = 0 ;
12083 bool val3 ;
12084 int ecode3 = 0 ;
12085 PyObject * obj0 = 0 ;
12086 PyObject * obj1 = 0 ;
12087 PyObject * obj2 = 0 ;
12088 char * kwnames[] = {
12089 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12090 };
12091
12092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12094 if (!SWIG_IsOK(res1)) {
12095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12096 }
12097 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12098 ecode2 = SWIG_AsVal_int(obj1, &val2);
12099 if (!SWIG_IsOK(ecode2)) {
12100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12101 }
12102 arg2 = static_cast< int >(val2);
12103 if (obj2) {
12104 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12105 if (!SWIG_IsOK(ecode3)) {
12106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12107 }
12108 arg3 = static_cast< bool >(val3);
12109 }
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 (arg1)->Start(arg2,arg3);
12113 wxPyEndAllowThreads(__tstate);
12114 if (PyErr_Occurred()) SWIG_fail;
12115 }
12116 resultobj = SWIG_Py_Void();
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12124 PyObject *obj;
12125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12126 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12127 return SWIG_Py_Void();
12128 }
12129
12130 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12131 return SWIG_Python_InitShadowInstance(args);
12132 }
12133
12134 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12135 PyObject *resultobj = 0;
12136 wxLog *result = 0 ;
12137
12138 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (wxLog *)new wxLog();
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 PyObject *resultobj = 0;
12154 wxLog *arg1 = (wxLog *) 0 ;
12155 void *argp1 = 0 ;
12156 int res1 = 0 ;
12157 PyObject *swig_obj[1] ;
12158
12159 if (!args) SWIG_fail;
12160 swig_obj[0] = args;
12161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12162 if (!SWIG_IsOK(res1)) {
12163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12164 }
12165 arg1 = reinterpret_cast< wxLog * >(argp1);
12166 {
12167 PyThreadState* __tstate = wxPyBeginAllowThreads();
12168 delete arg1;
12169
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 resultobj = SWIG_Py_Void();
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12181 PyObject *resultobj = 0;
12182 bool result;
12183
12184 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12185 {
12186 PyThreadState* __tstate = wxPyBeginAllowThreads();
12187 result = (bool)wxLog::IsEnabled();
12188 wxPyEndAllowThreads(__tstate);
12189 if (PyErr_Occurred()) SWIG_fail;
12190 }
12191 {
12192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12193 }
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12201 PyObject *resultobj = 0;
12202 bool arg1 = (bool) true ;
12203 bool result;
12204 bool val1 ;
12205 int ecode1 = 0 ;
12206 PyObject * obj0 = 0 ;
12207 char * kwnames[] = {
12208 (char *) "doIt", NULL
12209 };
12210
12211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12212 if (obj0) {
12213 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12214 if (!SWIG_IsOK(ecode1)) {
12215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12216 }
12217 arg1 = static_cast< bool >(val1);
12218 }
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (bool)wxLog::EnableLogging(arg1);
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 {
12226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12227 }
12228 return resultobj;
12229 fail:
12230 return NULL;
12231 }
12232
12233
12234 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12235 PyObject *resultobj = 0;
12236 wxLogLevel arg1 ;
12237 wxChar *arg2 = (wxChar *) 0 ;
12238 time_t arg3 ;
12239 unsigned long val1 ;
12240 int ecode1 = 0 ;
12241 void *argp2 = 0 ;
12242 int res2 = 0 ;
12243 unsigned int val3 ;
12244 int ecode3 = 0 ;
12245 PyObject * obj0 = 0 ;
12246 PyObject * obj1 = 0 ;
12247 PyObject * obj2 = 0 ;
12248 char * kwnames[] = {
12249 (char *) "level",(char *) "szString",(char *) "t", NULL
12250 };
12251
12252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12253 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12254 if (!SWIG_IsOK(ecode1)) {
12255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12256 }
12257 arg1 = static_cast< wxLogLevel >(val1);
12258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12259 if (!SWIG_IsOK(res2)) {
12260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12261 }
12262 arg2 = reinterpret_cast< wxChar * >(argp2);
12263 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12264 if (!SWIG_IsOK(ecode3)) {
12265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12266 }
12267 arg3 = static_cast< time_t >(val3);
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 resultobj = SWIG_Py_Void();
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12282 PyObject *resultobj = 0;
12283 wxLog *arg1 = (wxLog *) 0 ;
12284 void *argp1 = 0 ;
12285 int res1 = 0 ;
12286 PyObject *swig_obj[1] ;
12287
12288 if (!args) SWIG_fail;
12289 swig_obj[0] = args;
12290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12291 if (!SWIG_IsOK(res1)) {
12292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12293 }
12294 arg1 = reinterpret_cast< wxLog * >(argp1);
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 (arg1)->Flush();
12298 wxPyEndAllowThreads(__tstate);
12299 if (PyErr_Occurred()) SWIG_fail;
12300 }
12301 resultobj = SWIG_Py_Void();
12302 return resultobj;
12303 fail:
12304 return NULL;
12305 }
12306
12307
12308 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12309 PyObject *resultobj = 0;
12310
12311 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 wxLog::FlushActive();
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 resultobj = SWIG_Py_Void();
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12326 PyObject *resultobj = 0;
12327 wxLog *result = 0 ;
12328
12329 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 result = (wxLog *)wxLog::GetActiveTarget();
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj = 0;
12345 wxLog *arg1 = (wxLog *) 0 ;
12346 wxLog *result = 0 ;
12347 int res1 = 0 ;
12348 PyObject * obj0 = 0 ;
12349 char * kwnames[] = {
12350 (char *) "pLogger", NULL
12351 };
12352
12353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12354 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12355 if (!SWIG_IsOK(res1)) {
12356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12357 }
12358 {
12359 PyThreadState* __tstate = wxPyBeginAllowThreads();
12360 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12361 wxPyEndAllowThreads(__tstate);
12362 if (PyErr_Occurred()) SWIG_fail;
12363 }
12364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12372 PyObject *resultobj = 0;
12373
12374 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12375 {
12376 PyThreadState* __tstate = wxPyBeginAllowThreads();
12377 wxLog::Suspend();
12378 wxPyEndAllowThreads(__tstate);
12379 if (PyErr_Occurred()) SWIG_fail;
12380 }
12381 resultobj = SWIG_Py_Void();
12382 return resultobj;
12383 fail:
12384 return NULL;
12385 }
12386
12387
12388 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12389 PyObject *resultobj = 0;
12390
12391 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12392 {
12393 PyThreadState* __tstate = wxPyBeginAllowThreads();
12394 wxLog::Resume();
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 resultobj = SWIG_Py_Void();
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj = 0;
12407 bool arg1 = (bool) true ;
12408 bool val1 ;
12409 int ecode1 = 0 ;
12410 PyObject * obj0 = 0 ;
12411 char * kwnames[] = {
12412 (char *) "bVerbose", NULL
12413 };
12414
12415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12416 if (obj0) {
12417 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12418 if (!SWIG_IsOK(ecode1)) {
12419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12420 }
12421 arg1 = static_cast< bool >(val1);
12422 }
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 wxLog::SetVerbose(arg1);
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 resultobj = SWIG_Py_Void();
12430 return resultobj;
12431 fail:
12432 return NULL;
12433 }
12434
12435
12436 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12437 PyObject *resultobj = 0;
12438 wxLogLevel arg1 ;
12439 unsigned long val1 ;
12440 int ecode1 = 0 ;
12441 PyObject * obj0 = 0 ;
12442 char * kwnames[] = {
12443 (char *) "logLevel", NULL
12444 };
12445
12446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12447 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12448 if (!SWIG_IsOK(ecode1)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12450 }
12451 arg1 = static_cast< wxLogLevel >(val1);
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 wxLog::SetLogLevel(arg1);
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 resultobj = SWIG_Py_Void();
12459 return resultobj;
12460 fail:
12461 return NULL;
12462 }
12463
12464
12465 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12466 PyObject *resultobj = 0;
12467
12468 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12469 {
12470 PyThreadState* __tstate = wxPyBeginAllowThreads();
12471 wxLog::DontCreateOnDemand();
12472 wxPyEndAllowThreads(__tstate);
12473 if (PyErr_Occurred()) SWIG_fail;
12474 }
12475 resultobj = SWIG_Py_Void();
12476 return resultobj;
12477 fail:
12478 return NULL;
12479 }
12480
12481
12482 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12483 PyObject *resultobj = 0;
12484 bool arg1 = (bool) true ;
12485 bool val1 ;
12486 int ecode1 = 0 ;
12487 PyObject * obj0 = 0 ;
12488 char * kwnames[] = {
12489 (char *) "bRepetCounting", NULL
12490 };
12491
12492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12493 if (obj0) {
12494 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12495 if (!SWIG_IsOK(ecode1)) {
12496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12497 }
12498 arg1 = static_cast< bool >(val1);
12499 }
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 wxLog::SetRepetitionCounting(arg1);
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 resultobj = SWIG_Py_Void();
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12514 PyObject *resultobj = 0;
12515 bool result;
12516
12517 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 result = (bool)wxLog::GetRepetitionCounting();
12521 wxPyEndAllowThreads(__tstate);
12522 if (PyErr_Occurred()) SWIG_fail;
12523 }
12524 {
12525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12526 }
12527 return resultobj;
12528 fail:
12529 return NULL;
12530 }
12531
12532
12533 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12534 PyObject *resultobj = 0;
12535 wxTraceMask arg1 ;
12536 unsigned long val1 ;
12537 int ecode1 = 0 ;
12538 PyObject * obj0 = 0 ;
12539 char * kwnames[] = {
12540 (char *) "ulMask", NULL
12541 };
12542
12543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12544 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12545 if (!SWIG_IsOK(ecode1)) {
12546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12547 }
12548 arg1 = static_cast< wxTraceMask >(val1);
12549 {
12550 PyThreadState* __tstate = wxPyBeginAllowThreads();
12551 wxLog::SetTraceMask(arg1);
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 resultobj = SWIG_Py_Void();
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj = 0;
12564 wxString *arg1 = 0 ;
12565 bool temp1 = false ;
12566 PyObject * obj0 = 0 ;
12567 char * kwnames[] = {
12568 (char *) "str", NULL
12569 };
12570
12571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12572 {
12573 arg1 = wxString_in_helper(obj0);
12574 if (arg1 == NULL) SWIG_fail;
12575 temp1 = true;
12576 }
12577 {
12578 PyThreadState* __tstate = wxPyBeginAllowThreads();
12579 wxLog::AddTraceMask((wxString const &)*arg1);
12580 wxPyEndAllowThreads(__tstate);
12581 if (PyErr_Occurred()) SWIG_fail;
12582 }
12583 resultobj = SWIG_Py_Void();
12584 {
12585 if (temp1)
12586 delete arg1;
12587 }
12588 return resultobj;
12589 fail:
12590 {
12591 if (temp1)
12592 delete arg1;
12593 }
12594 return NULL;
12595 }
12596
12597
12598 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12599 PyObject *resultobj = 0;
12600 wxString *arg1 = 0 ;
12601 bool temp1 = false ;
12602 PyObject * obj0 = 0 ;
12603 char * kwnames[] = {
12604 (char *) "str", NULL
12605 };
12606
12607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12608 {
12609 arg1 = wxString_in_helper(obj0);
12610 if (arg1 == NULL) SWIG_fail;
12611 temp1 = true;
12612 }
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 wxLog::RemoveTraceMask((wxString const &)*arg1);
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 resultobj = SWIG_Py_Void();
12620 {
12621 if (temp1)
12622 delete arg1;
12623 }
12624 return resultobj;
12625 fail:
12626 {
12627 if (temp1)
12628 delete arg1;
12629 }
12630 return NULL;
12631 }
12632
12633
12634 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12635 PyObject *resultobj = 0;
12636
12637 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12638 {
12639 PyThreadState* __tstate = wxPyBeginAllowThreads();
12640 wxLog::ClearTraceMasks();
12641 wxPyEndAllowThreads(__tstate);
12642 if (PyErr_Occurred()) SWIG_fail;
12643 }
12644 resultobj = SWIG_Py_Void();
12645 return resultobj;
12646 fail:
12647 return NULL;
12648 }
12649
12650
12651 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12652 PyObject *resultobj = 0;
12653 wxArrayString *result = 0 ;
12654
12655 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 {
12659 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12660 result = (wxArrayString *) &_result_ref;
12661 }
12662 wxPyEndAllowThreads(__tstate);
12663 if (PyErr_Occurred()) SWIG_fail;
12664 }
12665 {
12666 resultobj = wxArrayString2PyList_helper(*result);
12667 }
12668 return resultobj;
12669 fail:
12670 return NULL;
12671 }
12672
12673
12674 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12675 PyObject *resultobj = 0;
12676 wxChar *arg1 = (wxChar *) 0 ;
12677 void *argp1 = 0 ;
12678 int res1 = 0 ;
12679 PyObject * obj0 = 0 ;
12680 char * kwnames[] = {
12681 (char *) "ts", NULL
12682 };
12683
12684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12686 if (!SWIG_IsOK(res1)) {
12687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12688 }
12689 arg1 = reinterpret_cast< wxChar * >(argp1);
12690 {
12691 PyThreadState* __tstate = wxPyBeginAllowThreads();
12692 wxLog::SetTimestamp((wxChar const *)arg1);
12693 wxPyEndAllowThreads(__tstate);
12694 if (PyErr_Occurred()) SWIG_fail;
12695 }
12696 resultobj = SWIG_Py_Void();
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12704 PyObject *resultobj = 0;
12705 bool result;
12706
12707 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12708 {
12709 PyThreadState* __tstate = wxPyBeginAllowThreads();
12710 result = (bool)wxLog::GetVerbose();
12711 wxPyEndAllowThreads(__tstate);
12712 if (PyErr_Occurred()) SWIG_fail;
12713 }
12714 {
12715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12716 }
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 PyObject *resultobj = 0;
12725 wxTraceMask result;
12726
12727 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12728 {
12729 PyThreadState* __tstate = wxPyBeginAllowThreads();
12730 result = (wxTraceMask)wxLog::GetTraceMask();
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj = 0;
12743 wxChar *arg1 = (wxChar *) 0 ;
12744 bool result;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 PyObject * obj0 = 0 ;
12748 char * kwnames[] = {
12749 (char *) "mask", NULL
12750 };
12751
12752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12754 if (!SWIG_IsOK(res1)) {
12755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12756 }
12757 arg1 = reinterpret_cast< wxChar * >(argp1);
12758 {
12759 PyThreadState* __tstate = wxPyBeginAllowThreads();
12760 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12761 wxPyEndAllowThreads(__tstate);
12762 if (PyErr_Occurred()) SWIG_fail;
12763 }
12764 {
12765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12766 }
12767 return resultobj;
12768 fail:
12769 return NULL;
12770 }
12771
12772
12773 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12774 PyObject *resultobj = 0;
12775 wxLogLevel result;
12776
12777 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12778 {
12779 PyThreadState* __tstate = wxPyBeginAllowThreads();
12780 result = (wxLogLevel)wxLog::GetLogLevel();
12781 wxPyEndAllowThreads(__tstate);
12782 if (PyErr_Occurred()) SWIG_fail;
12783 }
12784 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12792 PyObject *resultobj = 0;
12793 wxChar *result = 0 ;
12794
12795 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 result = (wxChar *)wxLog::GetTimestamp();
12799 wxPyEndAllowThreads(__tstate);
12800 if (PyErr_Occurred()) SWIG_fail;
12801 }
12802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12810 PyObject *resultobj = 0;
12811 wxString result;
12812
12813 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 result = wxLog_TimeStamp();
12817 wxPyEndAllowThreads(__tstate);
12818 if (PyErr_Occurred()) SWIG_fail;
12819 }
12820 {
12821 #if wxUSE_UNICODE
12822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12823 #else
12824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12825 #endif
12826 }
12827 return resultobj;
12828 fail:
12829 return NULL;
12830 }
12831
12832
12833 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12834 PyObject *resultobj = 0;
12835 wxLog *arg1 = (wxLog *) 0 ;
12836 void *argp1 = 0 ;
12837 int res1 = 0 ;
12838 PyObject *swig_obj[1] ;
12839
12840 if (!args) SWIG_fail;
12841 swig_obj[0] = args;
12842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12843 if (!SWIG_IsOK(res1)) {
12844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12845 }
12846 arg1 = reinterpret_cast< wxLog * >(argp1);
12847 {
12848 PyThreadState* __tstate = wxPyBeginAllowThreads();
12849 wxLog_Destroy(arg1);
12850 wxPyEndAllowThreads(__tstate);
12851 if (PyErr_Occurred()) SWIG_fail;
12852 }
12853 resultobj = SWIG_Py_Void();
12854 return resultobj;
12855 fail:
12856 return NULL;
12857 }
12858
12859
12860 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12861 PyObject *obj;
12862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12863 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12864 return SWIG_Py_Void();
12865 }
12866
12867 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12868 return SWIG_Python_InitShadowInstance(args);
12869 }
12870
12871 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12872 PyObject *resultobj = 0;
12873 wxLogStderr *result = 0 ;
12874
12875 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12876 {
12877 PyThreadState* __tstate = wxPyBeginAllowThreads();
12878 result = (wxLogStderr *)new wxLogStderr();
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12883 return resultobj;
12884 fail:
12885 return NULL;
12886 }
12887
12888
12889 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12890 PyObject *obj;
12891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12892 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12893 return SWIG_Py_Void();
12894 }
12895
12896 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12897 return SWIG_Python_InitShadowInstance(args);
12898 }
12899
12900 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12901 PyObject *resultobj = 0;
12902 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12903 wxLogTextCtrl *result = 0 ;
12904 void *argp1 = 0 ;
12905 int res1 = 0 ;
12906 PyObject * obj0 = 0 ;
12907 char * kwnames[] = {
12908 (char *) "pTextCtrl", NULL
12909 };
12910
12911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12913 if (!SWIG_IsOK(res1)) {
12914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12915 }
12916 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12917 {
12918 PyThreadState* __tstate = wxPyBeginAllowThreads();
12919 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12920 wxPyEndAllowThreads(__tstate);
12921 if (PyErr_Occurred()) SWIG_fail;
12922 }
12923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12924 return resultobj;
12925 fail:
12926 return NULL;
12927 }
12928
12929
12930 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12931 PyObject *obj;
12932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12933 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12934 return SWIG_Py_Void();
12935 }
12936
12937 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 return SWIG_Python_InitShadowInstance(args);
12939 }
12940
12941 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12942 PyObject *resultobj = 0;
12943 wxLogGui *result = 0 ;
12944
12945 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12946 {
12947 PyThreadState* __tstate = wxPyBeginAllowThreads();
12948 result = (wxLogGui *)new wxLogGui();
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12953 return resultobj;
12954 fail:
12955 return NULL;
12956 }
12957
12958
12959 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12960 PyObject *obj;
12961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12962 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12963 return SWIG_Py_Void();
12964 }
12965
12966 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 return SWIG_Python_InitShadowInstance(args);
12968 }
12969
12970 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12971 PyObject *resultobj = 0;
12972 wxFrame *arg1 = (wxFrame *) 0 ;
12973 wxString *arg2 = 0 ;
12974 bool arg3 = (bool) true ;
12975 bool arg4 = (bool) true ;
12976 wxLogWindow *result = 0 ;
12977 void *argp1 = 0 ;
12978 int res1 = 0 ;
12979 bool temp2 = false ;
12980 bool val3 ;
12981 int ecode3 = 0 ;
12982 bool val4 ;
12983 int ecode4 = 0 ;
12984 PyObject * obj0 = 0 ;
12985 PyObject * obj1 = 0 ;
12986 PyObject * obj2 = 0 ;
12987 PyObject * obj3 = 0 ;
12988 char * kwnames[] = {
12989 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12990 };
12991
12992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12994 if (!SWIG_IsOK(res1)) {
12995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12996 }
12997 arg1 = reinterpret_cast< wxFrame * >(argp1);
12998 {
12999 arg2 = wxString_in_helper(obj1);
13000 if (arg2 == NULL) SWIG_fail;
13001 temp2 = true;
13002 }
13003 if (obj2) {
13004 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13005 if (!SWIG_IsOK(ecode3)) {
13006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13007 }
13008 arg3 = static_cast< bool >(val3);
13009 }
13010 if (obj3) {
13011 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13012 if (!SWIG_IsOK(ecode4)) {
13013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13014 }
13015 arg4 = static_cast< bool >(val4);
13016 }
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13024 {
13025 if (temp2)
13026 delete arg2;
13027 }
13028 return resultobj;
13029 fail:
13030 {
13031 if (temp2)
13032 delete arg2;
13033 }
13034 return NULL;
13035 }
13036
13037
13038 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13039 PyObject *resultobj = 0;
13040 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13041 bool arg2 = (bool) true ;
13042 void *argp1 = 0 ;
13043 int res1 = 0 ;
13044 bool val2 ;
13045 int ecode2 = 0 ;
13046 PyObject * obj0 = 0 ;
13047 PyObject * obj1 = 0 ;
13048 char * kwnames[] = {
13049 (char *) "self",(char *) "bShow", NULL
13050 };
13051
13052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13054 if (!SWIG_IsOK(res1)) {
13055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13056 }
13057 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13058 if (obj1) {
13059 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13060 if (!SWIG_IsOK(ecode2)) {
13061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13062 }
13063 arg2 = static_cast< bool >(val2);
13064 }
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 (arg1)->Show(arg2);
13068 wxPyEndAllowThreads(__tstate);
13069 if (PyErr_Occurred()) SWIG_fail;
13070 }
13071 resultobj = SWIG_Py_Void();
13072 return resultobj;
13073 fail:
13074 return NULL;
13075 }
13076
13077
13078 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13079 PyObject *resultobj = 0;
13080 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13081 wxFrame *result = 0 ;
13082 void *argp1 = 0 ;
13083 int res1 = 0 ;
13084 PyObject *swig_obj[1] ;
13085
13086 if (!args) SWIG_fail;
13087 swig_obj[0] = args;
13088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13089 if (!SWIG_IsOK(res1)) {
13090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13091 }
13092 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 {
13100 resultobj = wxPyMake_wxObject(result, (bool)0);
13101 }
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13109 PyObject *resultobj = 0;
13110 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13111 wxLog *result = 0 ;
13112 void *argp1 = 0 ;
13113 int res1 = 0 ;
13114 PyObject *swig_obj[1] ;
13115
13116 if (!args) SWIG_fail;
13117 swig_obj[0] = args;
13118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13119 if (!SWIG_IsOK(res1)) {
13120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13121 }
13122 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13126 wxPyEndAllowThreads(__tstate);
13127 if (PyErr_Occurred()) SWIG_fail;
13128 }
13129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13130 return resultobj;
13131 fail:
13132 return NULL;
13133 }
13134
13135
13136 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13137 PyObject *resultobj = 0;
13138 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13139 bool result;
13140 void *argp1 = 0 ;
13141 int res1 = 0 ;
13142 PyObject *swig_obj[1] ;
13143
13144 if (!args) SWIG_fail;
13145 swig_obj[0] = args;
13146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13147 if (!SWIG_IsOK(res1)) {
13148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13149 }
13150 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13154 wxPyEndAllowThreads(__tstate);
13155 if (PyErr_Occurred()) SWIG_fail;
13156 }
13157 {
13158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13159 }
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13167 PyObject *resultobj = 0;
13168 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13169 bool arg2 ;
13170 void *argp1 = 0 ;
13171 int res1 = 0 ;
13172 bool val2 ;
13173 int ecode2 = 0 ;
13174 PyObject * obj0 = 0 ;
13175 PyObject * obj1 = 0 ;
13176 char * kwnames[] = {
13177 (char *) "self",(char *) "bDoPass", NULL
13178 };
13179
13180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13182 if (!SWIG_IsOK(res1)) {
13183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13184 }
13185 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13186 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13187 if (!SWIG_IsOK(ecode2)) {
13188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13189 }
13190 arg2 = static_cast< bool >(val2);
13191 {
13192 PyThreadState* __tstate = wxPyBeginAllowThreads();
13193 (arg1)->PassMessages(arg2);
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 resultobj = SWIG_Py_Void();
13198 return resultobj;
13199 fail:
13200 return NULL;
13201 }
13202
13203
13204 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13205 PyObject *obj;
13206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13207 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13208 return SWIG_Py_Void();
13209 }
13210
13211 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13212 return SWIG_Python_InitShadowInstance(args);
13213 }
13214
13215 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13216 PyObject *resultobj = 0;
13217 wxLog *arg1 = (wxLog *) 0 ;
13218 wxLogChain *result = 0 ;
13219 void *argp1 = 0 ;
13220 int res1 = 0 ;
13221 PyObject * obj0 = 0 ;
13222 char * kwnames[] = {
13223 (char *) "logger", NULL
13224 };
13225
13226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13228 if (!SWIG_IsOK(res1)) {
13229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13230 }
13231 arg1 = reinterpret_cast< wxLog * >(argp1);
13232 {
13233 PyThreadState* __tstate = wxPyBeginAllowThreads();
13234 result = (wxLogChain *)new wxLogChain(arg1);
13235 wxPyEndAllowThreads(__tstate);
13236 if (PyErr_Occurred()) SWIG_fail;
13237 }
13238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13239 return resultobj;
13240 fail:
13241 return NULL;
13242 }
13243
13244
13245 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13246 PyObject *resultobj = 0;
13247 wxLogChain *arg1 = (wxLogChain *) 0 ;
13248 wxLog *arg2 = (wxLog *) 0 ;
13249 void *argp1 = 0 ;
13250 int res1 = 0 ;
13251 void *argp2 = 0 ;
13252 int res2 = 0 ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 char * kwnames[] = {
13256 (char *) "self",(char *) "logger", NULL
13257 };
13258
13259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13261 if (!SWIG_IsOK(res1)) {
13262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13263 }
13264 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13265 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13266 if (!SWIG_IsOK(res2)) {
13267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13268 }
13269 arg2 = reinterpret_cast< wxLog * >(argp2);
13270 {
13271 PyThreadState* __tstate = wxPyBeginAllowThreads();
13272 (arg1)->SetLog(arg2);
13273 wxPyEndAllowThreads(__tstate);
13274 if (PyErr_Occurred()) SWIG_fail;
13275 }
13276 resultobj = SWIG_Py_Void();
13277 return resultobj;
13278 fail:
13279 return NULL;
13280 }
13281
13282
13283 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13284 PyObject *resultobj = 0;
13285 wxLogChain *arg1 = (wxLogChain *) 0 ;
13286 bool arg2 ;
13287 void *argp1 = 0 ;
13288 int res1 = 0 ;
13289 bool val2 ;
13290 int ecode2 = 0 ;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 char * kwnames[] = {
13294 (char *) "self",(char *) "bDoPass", NULL
13295 };
13296
13297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13299 if (!SWIG_IsOK(res1)) {
13300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13301 }
13302 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13303 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13304 if (!SWIG_IsOK(ecode2)) {
13305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13306 }
13307 arg2 = static_cast< bool >(val2);
13308 {
13309 PyThreadState* __tstate = wxPyBeginAllowThreads();
13310 (arg1)->PassMessages(arg2);
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 resultobj = SWIG_Py_Void();
13315 return resultobj;
13316 fail:
13317 return NULL;
13318 }
13319
13320
13321 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13322 PyObject *resultobj = 0;
13323 wxLogChain *arg1 = (wxLogChain *) 0 ;
13324 bool result;
13325 void *argp1 = 0 ;
13326 int res1 = 0 ;
13327 PyObject *swig_obj[1] ;
13328
13329 if (!args) SWIG_fail;
13330 swig_obj[0] = args;
13331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13332 if (!SWIG_IsOK(res1)) {
13333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13334 }
13335 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 result = (bool)(arg1)->IsPassingMessages();
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 {
13343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13344 }
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13352 PyObject *resultobj = 0;
13353 wxLogChain *arg1 = (wxLogChain *) 0 ;
13354 wxLog *result = 0 ;
13355 void *argp1 = 0 ;
13356 int res1 = 0 ;
13357 PyObject *swig_obj[1] ;
13358
13359 if (!args) SWIG_fail;
13360 swig_obj[0] = args;
13361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13362 if (!SWIG_IsOK(res1)) {
13363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13364 }
13365 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13366 {
13367 PyThreadState* __tstate = wxPyBeginAllowThreads();
13368 result = (wxLog *)(arg1)->GetOldLog();
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13373 return resultobj;
13374 fail:
13375 return NULL;
13376 }
13377
13378
13379 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13380 PyObject *obj;
13381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13382 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13383 return SWIG_Py_Void();
13384 }
13385
13386 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13387 return SWIG_Python_InitShadowInstance(args);
13388 }
13389
13390 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13391 PyObject *resultobj = 0;
13392 wxLogBuffer *result = 0 ;
13393
13394 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13395 {
13396 PyThreadState* __tstate = wxPyBeginAllowThreads();
13397 result = (wxLogBuffer *)new wxLogBuffer();
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13409 PyObject *resultobj = 0;
13410 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13411 wxString *result = 0 ;
13412 void *argp1 = 0 ;
13413 int res1 = 0 ;
13414 PyObject *swig_obj[1] ;
13415
13416 if (!args) SWIG_fail;
13417 swig_obj[0] = args;
13418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13419 if (!SWIG_IsOK(res1)) {
13420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13421 }
13422 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13423 {
13424 PyThreadState* __tstate = wxPyBeginAllowThreads();
13425 {
13426 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13427 result = (wxString *) &_result_ref;
13428 }
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 #if wxUSE_UNICODE
13434 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13435 #else
13436 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13437 #endif
13438 }
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13446 PyObject *obj;
13447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13448 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13449 return SWIG_Py_Void();
13450 }
13451
13452 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13453 return SWIG_Python_InitShadowInstance(args);
13454 }
13455
13456 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13457 PyObject *resultobj = 0;
13458 unsigned long result;
13459
13460 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13461 {
13462 PyThreadState* __tstate = wxPyBeginAllowThreads();
13463 result = (unsigned long)wxSysErrorCode();
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13475 PyObject *resultobj = 0;
13476 unsigned long arg1 = (unsigned long) 0 ;
13477 wxString result;
13478 unsigned long val1 ;
13479 int ecode1 = 0 ;
13480 PyObject * obj0 = 0 ;
13481 char * kwnames[] = {
13482 (char *) "nErrCode", NULL
13483 };
13484
13485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13486 if (obj0) {
13487 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13488 if (!SWIG_IsOK(ecode1)) {
13489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13490 }
13491 arg1 = static_cast< unsigned long >(val1);
13492 }
13493 {
13494 PyThreadState* __tstate = wxPyBeginAllowThreads();
13495 result = wxSysErrorMsg(arg1);
13496 wxPyEndAllowThreads(__tstate);
13497 if (PyErr_Occurred()) SWIG_fail;
13498 }
13499 {
13500 #if wxUSE_UNICODE
13501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13502 #else
13503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13504 #endif
13505 }
13506 return resultobj;
13507 fail:
13508 return NULL;
13509 }
13510
13511
13512 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13513 PyObject *resultobj = 0;
13514 wxString *arg1 = 0 ;
13515 bool temp1 = false ;
13516 PyObject * obj0 = 0 ;
13517 char * kwnames[] = {
13518 (char *) "msg", NULL
13519 };
13520
13521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13522 {
13523 arg1 = wxString_in_helper(obj0);
13524 if (arg1 == NULL) SWIG_fail;
13525 temp1 = true;
13526 }
13527 {
13528 PyThreadState* __tstate = wxPyBeginAllowThreads();
13529 wxPyLogFatalError((wxString const &)*arg1);
13530 wxPyEndAllowThreads(__tstate);
13531 if (PyErr_Occurred()) SWIG_fail;
13532 }
13533 resultobj = SWIG_Py_Void();
13534 {
13535 if (temp1)
13536 delete arg1;
13537 }
13538 return resultobj;
13539 fail:
13540 {
13541 if (temp1)
13542 delete arg1;
13543 }
13544 return NULL;
13545 }
13546
13547
13548 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13549 PyObject *resultobj = 0;
13550 wxString *arg1 = 0 ;
13551 bool temp1 = false ;
13552 PyObject * obj0 = 0 ;
13553 char * kwnames[] = {
13554 (char *) "msg", NULL
13555 };
13556
13557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13558 {
13559 arg1 = wxString_in_helper(obj0);
13560 if (arg1 == NULL) SWIG_fail;
13561 temp1 = true;
13562 }
13563 {
13564 PyThreadState* __tstate = wxPyBeginAllowThreads();
13565 wxPyLogError((wxString const &)*arg1);
13566 wxPyEndAllowThreads(__tstate);
13567 if (PyErr_Occurred()) SWIG_fail;
13568 }
13569 resultobj = SWIG_Py_Void();
13570 {
13571 if (temp1)
13572 delete arg1;
13573 }
13574 return resultobj;
13575 fail:
13576 {
13577 if (temp1)
13578 delete arg1;
13579 }
13580 return NULL;
13581 }
13582
13583
13584 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj = 0;
13586 wxString *arg1 = 0 ;
13587 bool temp1 = false ;
13588 PyObject * obj0 = 0 ;
13589 char * kwnames[] = {
13590 (char *) "msg", NULL
13591 };
13592
13593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13594 {
13595 arg1 = wxString_in_helper(obj0);
13596 if (arg1 == NULL) SWIG_fail;
13597 temp1 = true;
13598 }
13599 {
13600 PyThreadState* __tstate = wxPyBeginAllowThreads();
13601 wxPyLogWarning((wxString const &)*arg1);
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 resultobj = SWIG_Py_Void();
13606 {
13607 if (temp1)
13608 delete arg1;
13609 }
13610 return resultobj;
13611 fail:
13612 {
13613 if (temp1)
13614 delete arg1;
13615 }
13616 return NULL;
13617 }
13618
13619
13620 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj = 0;
13622 wxString *arg1 = 0 ;
13623 bool temp1 = false ;
13624 PyObject * obj0 = 0 ;
13625 char * kwnames[] = {
13626 (char *) "msg", NULL
13627 };
13628
13629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13630 {
13631 arg1 = wxString_in_helper(obj0);
13632 if (arg1 == NULL) SWIG_fail;
13633 temp1 = true;
13634 }
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 wxPyLogMessage((wxString const &)*arg1);
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_Py_Void();
13642 {
13643 if (temp1)
13644 delete arg1;
13645 }
13646 return resultobj;
13647 fail:
13648 {
13649 if (temp1)
13650 delete arg1;
13651 }
13652 return NULL;
13653 }
13654
13655
13656 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13657 PyObject *resultobj = 0;
13658 wxString *arg1 = 0 ;
13659 bool temp1 = false ;
13660 PyObject * obj0 = 0 ;
13661 char * kwnames[] = {
13662 (char *) "msg", NULL
13663 };
13664
13665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13666 {
13667 arg1 = wxString_in_helper(obj0);
13668 if (arg1 == NULL) SWIG_fail;
13669 temp1 = true;
13670 }
13671 {
13672 PyThreadState* __tstate = wxPyBeginAllowThreads();
13673 wxPyLogInfo((wxString const &)*arg1);
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 resultobj = SWIG_Py_Void();
13678 {
13679 if (temp1)
13680 delete arg1;
13681 }
13682 return resultobj;
13683 fail:
13684 {
13685 if (temp1)
13686 delete arg1;
13687 }
13688 return NULL;
13689 }
13690
13691
13692 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj = 0;
13694 wxString *arg1 = 0 ;
13695 bool temp1 = false ;
13696 PyObject * obj0 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "msg", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13702 {
13703 arg1 = wxString_in_helper(obj0);
13704 if (arg1 == NULL) SWIG_fail;
13705 temp1 = true;
13706 }
13707 {
13708 PyThreadState* __tstate = wxPyBeginAllowThreads();
13709 wxPyLogDebug((wxString const &)*arg1);
13710 wxPyEndAllowThreads(__tstate);
13711 if (PyErr_Occurred()) SWIG_fail;
13712 }
13713 resultobj = SWIG_Py_Void();
13714 {
13715 if (temp1)
13716 delete arg1;
13717 }
13718 return resultobj;
13719 fail:
13720 {
13721 if (temp1)
13722 delete arg1;
13723 }
13724 return NULL;
13725 }
13726
13727
13728 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13729 PyObject *resultobj = 0;
13730 wxString *arg1 = 0 ;
13731 bool temp1 = false ;
13732 PyObject * obj0 = 0 ;
13733 char * kwnames[] = {
13734 (char *) "msg", NULL
13735 };
13736
13737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13738 {
13739 arg1 = wxString_in_helper(obj0);
13740 if (arg1 == NULL) SWIG_fail;
13741 temp1 = true;
13742 }
13743 {
13744 PyThreadState* __tstate = wxPyBeginAllowThreads();
13745 wxPyLogVerbose((wxString const &)*arg1);
13746 wxPyEndAllowThreads(__tstate);
13747 if (PyErr_Occurred()) SWIG_fail;
13748 }
13749 resultobj = SWIG_Py_Void();
13750 {
13751 if (temp1)
13752 delete arg1;
13753 }
13754 return resultobj;
13755 fail:
13756 {
13757 if (temp1)
13758 delete arg1;
13759 }
13760 return NULL;
13761 }
13762
13763
13764 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13765 PyObject *resultobj = 0;
13766 wxString *arg1 = 0 ;
13767 bool temp1 = false ;
13768 PyObject * obj0 = 0 ;
13769 char * kwnames[] = {
13770 (char *) "msg", NULL
13771 };
13772
13773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13774 {
13775 arg1 = wxString_in_helper(obj0);
13776 if (arg1 == NULL) SWIG_fail;
13777 temp1 = true;
13778 }
13779 {
13780 PyThreadState* __tstate = wxPyBeginAllowThreads();
13781 wxPyLogStatus((wxString const &)*arg1);
13782 wxPyEndAllowThreads(__tstate);
13783 if (PyErr_Occurred()) SWIG_fail;
13784 }
13785 resultobj = SWIG_Py_Void();
13786 {
13787 if (temp1)
13788 delete arg1;
13789 }
13790 return resultobj;
13791 fail:
13792 {
13793 if (temp1)
13794 delete arg1;
13795 }
13796 return NULL;
13797 }
13798
13799
13800 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13801 PyObject *resultobj = 0;
13802 wxFrame *arg1 = (wxFrame *) 0 ;
13803 wxString *arg2 = 0 ;
13804 void *argp1 = 0 ;
13805 int res1 = 0 ;
13806 bool temp2 = false ;
13807 PyObject * obj0 = 0 ;
13808 PyObject * obj1 = 0 ;
13809 char * kwnames[] = {
13810 (char *) "pFrame",(char *) "msg", NULL
13811 };
13812
13813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13815 if (!SWIG_IsOK(res1)) {
13816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13817 }
13818 arg1 = reinterpret_cast< wxFrame * >(argp1);
13819 {
13820 arg2 = wxString_in_helper(obj1);
13821 if (arg2 == NULL) SWIG_fail;
13822 temp2 = true;
13823 }
13824 {
13825 PyThreadState* __tstate = wxPyBeginAllowThreads();
13826 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13827 wxPyEndAllowThreads(__tstate);
13828 if (PyErr_Occurred()) SWIG_fail;
13829 }
13830 resultobj = SWIG_Py_Void();
13831 {
13832 if (temp2)
13833 delete arg2;
13834 }
13835 return resultobj;
13836 fail:
13837 {
13838 if (temp2)
13839 delete arg2;
13840 }
13841 return NULL;
13842 }
13843
13844
13845 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13846 PyObject *resultobj = 0;
13847 wxString *arg1 = 0 ;
13848 bool temp1 = false ;
13849 PyObject * obj0 = 0 ;
13850 char * kwnames[] = {
13851 (char *) "msg", NULL
13852 };
13853
13854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13855 {
13856 arg1 = wxString_in_helper(obj0);
13857 if (arg1 == NULL) SWIG_fail;
13858 temp1 = true;
13859 }
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 wxPyLogSysError((wxString const &)*arg1);
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 resultobj = SWIG_Py_Void();
13867 {
13868 if (temp1)
13869 delete arg1;
13870 }
13871 return resultobj;
13872 fail:
13873 {
13874 if (temp1)
13875 delete arg1;
13876 }
13877 return NULL;
13878 }
13879
13880
13881 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13882 PyObject *resultobj = 0;
13883 unsigned long arg1 ;
13884 wxString *arg2 = 0 ;
13885 unsigned long val1 ;
13886 int ecode1 = 0 ;
13887 bool temp2 = false ;
13888 PyObject * obj0 = 0 ;
13889 PyObject * obj1 = 0 ;
13890 char * kwnames[] = {
13891 (char *) "level",(char *) "msg", NULL
13892 };
13893
13894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13895 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13896 if (!SWIG_IsOK(ecode1)) {
13897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13898 }
13899 arg1 = static_cast< unsigned long >(val1);
13900 {
13901 arg2 = wxString_in_helper(obj1);
13902 if (arg2 == NULL) SWIG_fail;
13903 temp2 = true;
13904 }
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13908 wxPyEndAllowThreads(__tstate);
13909 if (PyErr_Occurred()) SWIG_fail;
13910 }
13911 resultobj = SWIG_Py_Void();
13912 {
13913 if (temp2)
13914 delete arg2;
13915 }
13916 return resultobj;
13917 fail:
13918 {
13919 if (temp2)
13920 delete arg2;
13921 }
13922 return NULL;
13923 }
13924
13925
13926 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13927 PyObject *resultobj = 0;
13928 unsigned long arg1 ;
13929 wxString *arg2 = 0 ;
13930 unsigned long val1 ;
13931 int ecode1 = 0 ;
13932 bool temp2 = false ;
13933
13934 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13935 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13936 if (!SWIG_IsOK(ecode1)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13938 }
13939 arg1 = static_cast< unsigned long >(val1);
13940 {
13941 arg2 = wxString_in_helper(swig_obj[1]);
13942 if (arg2 == NULL) SWIG_fail;
13943 temp2 = true;
13944 }
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 wxPyLogTrace(arg1,(wxString const &)*arg2);
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_Py_Void();
13952 {
13953 if (temp2)
13954 delete arg2;
13955 }
13956 return resultobj;
13957 fail:
13958 {
13959 if (temp2)
13960 delete arg2;
13961 }
13962 return NULL;
13963 }
13964
13965
13966 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13967 PyObject *resultobj = 0;
13968 wxString *arg1 = 0 ;
13969 wxString *arg2 = 0 ;
13970 bool temp1 = false ;
13971 bool temp2 = false ;
13972
13973 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13974 {
13975 arg1 = wxString_in_helper(swig_obj[0]);
13976 if (arg1 == NULL) SWIG_fail;
13977 temp1 = true;
13978 }
13979 {
13980 arg2 = wxString_in_helper(swig_obj[1]);
13981 if (arg2 == NULL) SWIG_fail;
13982 temp2 = true;
13983 }
13984 {
13985 PyThreadState* __tstate = wxPyBeginAllowThreads();
13986 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 resultobj = SWIG_Py_Void();
13991 {
13992 if (temp1)
13993 delete arg1;
13994 }
13995 {
13996 if (temp2)
13997 delete arg2;
13998 }
13999 return resultobj;
14000 fail:
14001 {
14002 if (temp1)
14003 delete arg1;
14004 }
14005 {
14006 if (temp2)
14007 delete arg2;
14008 }
14009 return NULL;
14010 }
14011
14012
14013 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14014 int argc;
14015 PyObject *argv[3];
14016
14017 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14018 --argc;
14019 if (argc == 2) {
14020 int _v = 0;
14021 {
14022 {
14023 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14024 }
14025 }
14026 if (!_v) goto check_1;
14027 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14028 }
14029 check_1:
14030
14031 if (argc == 2) {
14032 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14033 }
14034
14035 fail:
14036 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14037 return NULL;
14038 }
14039
14040
14041 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj = 0;
14043 wxString *arg1 = 0 ;
14044 wxString *arg2 = 0 ;
14045 bool temp1 = false ;
14046 bool temp2 = false ;
14047 PyObject * obj0 = 0 ;
14048 PyObject * obj1 = 0 ;
14049 char * kwnames[] = {
14050 (char *) "title",(char *) "text", NULL
14051 };
14052
14053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14054 {
14055 arg1 = wxString_in_helper(obj0);
14056 if (arg1 == NULL) SWIG_fail;
14057 temp1 = true;
14058 }
14059 {
14060 arg2 = wxString_in_helper(obj1);
14061 if (arg2 == NULL) SWIG_fail;
14062 temp2 = true;
14063 }
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 resultobj = SWIG_Py_Void();
14071 {
14072 if (temp1)
14073 delete arg1;
14074 }
14075 {
14076 if (temp2)
14077 delete arg2;
14078 }
14079 return resultobj;
14080 fail:
14081 {
14082 if (temp1)
14083 delete arg1;
14084 }
14085 {
14086 if (temp2)
14087 delete arg2;
14088 }
14089 return NULL;
14090 }
14091
14092
14093 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14094 PyObject *resultobj = 0;
14095 wxLogNull *result = 0 ;
14096
14097 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14098 {
14099 PyThreadState* __tstate = wxPyBeginAllowThreads();
14100 result = (wxLogNull *)new wxLogNull();
14101 wxPyEndAllowThreads(__tstate);
14102 if (PyErr_Occurred()) SWIG_fail;
14103 }
14104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14105 return resultobj;
14106 fail:
14107 return NULL;
14108 }
14109
14110
14111 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14112 PyObject *resultobj = 0;
14113 wxLogNull *arg1 = (wxLogNull *) 0 ;
14114 void *argp1 = 0 ;
14115 int res1 = 0 ;
14116 PyObject *swig_obj[1] ;
14117
14118 if (!args) SWIG_fail;
14119 swig_obj[0] = args;
14120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14121 if (!SWIG_IsOK(res1)) {
14122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14123 }
14124 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 delete arg1;
14128
14129 wxPyEndAllowThreads(__tstate);
14130 if (PyErr_Occurred()) SWIG_fail;
14131 }
14132 resultobj = SWIG_Py_Void();
14133 return resultobj;
14134 fail:
14135 return NULL;
14136 }
14137
14138
14139 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14140 PyObject *obj;
14141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14142 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14143 return SWIG_Py_Void();
14144 }
14145
14146 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14147 return SWIG_Python_InitShadowInstance(args);
14148 }
14149
14150 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14151 PyObject *resultobj = 0;
14152 wxPyLog *result = 0 ;
14153
14154 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14155 {
14156 PyThreadState* __tstate = wxPyBeginAllowThreads();
14157 result = (wxPyLog *)new wxPyLog();
14158 wxPyEndAllowThreads(__tstate);
14159 if (PyErr_Occurred()) SWIG_fail;
14160 }
14161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14169 PyObject *resultobj = 0;
14170 wxPyLog *arg1 = (wxPyLog *) 0 ;
14171 PyObject *arg2 = (PyObject *) 0 ;
14172 PyObject *arg3 = (PyObject *) 0 ;
14173 void *argp1 = 0 ;
14174 int res1 = 0 ;
14175 PyObject * obj0 = 0 ;
14176 PyObject * obj1 = 0 ;
14177 PyObject * obj2 = 0 ;
14178 char * kwnames[] = {
14179 (char *) "self",(char *) "self",(char *) "_class", NULL
14180 };
14181
14182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14184 if (!SWIG_IsOK(res1)) {
14185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14186 }
14187 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14188 arg2 = obj1;
14189 arg3 = obj2;
14190 {
14191 PyThreadState* __tstate = wxPyBeginAllowThreads();
14192 (arg1)->_setCallbackInfo(arg2,arg3);
14193 wxPyEndAllowThreads(__tstate);
14194 if (PyErr_Occurred()) SWIG_fail;
14195 }
14196 resultobj = SWIG_Py_Void();
14197 return resultobj;
14198 fail:
14199 return NULL;
14200 }
14201
14202
14203 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14204 PyObject *obj;
14205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14206 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14207 return SWIG_Py_Void();
14208 }
14209
14210 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14211 return SWIG_Python_InitShadowInstance(args);
14212 }
14213
14214 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14215 PyObject *resultobj = 0;
14216 int arg1 ;
14217 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14218 int arg3 = (int) wxKILL_NOCHILDREN ;
14219 wxKillError result;
14220 int val1 ;
14221 int ecode1 = 0 ;
14222 int val2 ;
14223 int ecode2 = 0 ;
14224 int val3 ;
14225 int ecode3 = 0 ;
14226 PyObject * obj0 = 0 ;
14227 PyObject * obj1 = 0 ;
14228 PyObject * obj2 = 0 ;
14229 char * kwnames[] = {
14230 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14231 };
14232
14233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14234 ecode1 = SWIG_AsVal_int(obj0, &val1);
14235 if (!SWIG_IsOK(ecode1)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14237 }
14238 arg1 = static_cast< int >(val1);
14239 if (obj1) {
14240 ecode2 = SWIG_AsVal_int(obj1, &val2);
14241 if (!SWIG_IsOK(ecode2)) {
14242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14243 }
14244 arg2 = static_cast< wxSignal >(val2);
14245 }
14246 if (obj2) {
14247 ecode3 = SWIG_AsVal_int(obj2, &val3);
14248 if (!SWIG_IsOK(ecode3)) {
14249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14250 }
14251 arg3 = static_cast< int >(val3);
14252 }
14253 {
14254 PyThreadState* __tstate = wxPyBeginAllowThreads();
14255 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 resultobj = SWIG_From_int(static_cast< int >(result));
14260 return resultobj;
14261 fail:
14262 return NULL;
14263 }
14264
14265
14266 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14267 PyObject *resultobj = 0;
14268 int arg1 ;
14269 bool result;
14270 int val1 ;
14271 int ecode1 = 0 ;
14272 PyObject * obj0 = 0 ;
14273 char * kwnames[] = {
14274 (char *) "pid", NULL
14275 };
14276
14277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14278 ecode1 = SWIG_AsVal_int(obj0, &val1);
14279 if (!SWIG_IsOK(ecode1)) {
14280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14281 }
14282 arg1 = static_cast< int >(val1);
14283 {
14284 PyThreadState* __tstate = wxPyBeginAllowThreads();
14285 result = (bool)wxPyProcess::Exists(arg1);
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 {
14290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14291 }
14292 return resultobj;
14293 fail:
14294 return NULL;
14295 }
14296
14297
14298 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14299 PyObject *resultobj = 0;
14300 wxString *arg1 = 0 ;
14301 int arg2 = (int) wxEXEC_ASYNC ;
14302 wxPyProcess *result = 0 ;
14303 bool temp1 = false ;
14304 int val2 ;
14305 int ecode2 = 0 ;
14306 PyObject * obj0 = 0 ;
14307 PyObject * obj1 = 0 ;
14308 char * kwnames[] = {
14309 (char *) "cmd",(char *) "flags", NULL
14310 };
14311
14312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14313 {
14314 arg1 = wxString_in_helper(obj0);
14315 if (arg1 == NULL) SWIG_fail;
14316 temp1 = true;
14317 }
14318 if (obj1) {
14319 ecode2 = SWIG_AsVal_int(obj1, &val2);
14320 if (!SWIG_IsOK(ecode2)) {
14321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14322 }
14323 arg2 = static_cast< int >(val2);
14324 }
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14332 {
14333 if (temp1)
14334 delete arg1;
14335 }
14336 return resultobj;
14337 fail:
14338 {
14339 if (temp1)
14340 delete arg1;
14341 }
14342 return NULL;
14343 }
14344
14345
14346 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj = 0;
14348 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14349 int arg2 = (int) -1 ;
14350 wxPyProcess *result = 0 ;
14351 void *argp1 = 0 ;
14352 int res1 = 0 ;
14353 int val2 ;
14354 int ecode2 = 0 ;
14355 PyObject * obj0 = 0 ;
14356 PyObject * obj1 = 0 ;
14357 char * kwnames[] = {
14358 (char *) "parent",(char *) "id", NULL
14359 };
14360
14361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14362 if (obj0) {
14363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14364 if (!SWIG_IsOK(res1)) {
14365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14366 }
14367 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14368 }
14369 if (obj1) {
14370 ecode2 = SWIG_AsVal_int(obj1, &val2);
14371 if (!SWIG_IsOK(ecode2)) {
14372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14373 }
14374 arg2 = static_cast< int >(val2);
14375 }
14376 {
14377 PyThreadState* __tstate = wxPyBeginAllowThreads();
14378 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14379 wxPyEndAllowThreads(__tstate);
14380 if (PyErr_Occurred()) SWIG_fail;
14381 }
14382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14383 return resultobj;
14384 fail:
14385 return NULL;
14386 }
14387
14388
14389 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14390 PyObject *resultobj = 0;
14391 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 PyObject *swig_obj[1] ;
14395
14396 if (!args) SWIG_fail;
14397 swig_obj[0] = args;
14398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14399 if (!SWIG_IsOK(res1)) {
14400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14401 }
14402 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 delete arg1;
14406
14407 wxPyEndAllowThreads(__tstate);
14408 if (PyErr_Occurred()) SWIG_fail;
14409 }
14410 resultobj = SWIG_Py_Void();
14411 return resultobj;
14412 fail:
14413 return NULL;
14414 }
14415
14416
14417 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14418 PyObject *resultobj = 0;
14419 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14420 PyObject *arg2 = (PyObject *) 0 ;
14421 PyObject *arg3 = (PyObject *) 0 ;
14422 void *argp1 = 0 ;
14423 int res1 = 0 ;
14424 PyObject * obj0 = 0 ;
14425 PyObject * obj1 = 0 ;
14426 PyObject * obj2 = 0 ;
14427 char * kwnames[] = {
14428 (char *) "self",(char *) "self",(char *) "_class", NULL
14429 };
14430
14431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14433 if (!SWIG_IsOK(res1)) {
14434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14435 }
14436 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14437 arg2 = obj1;
14438 arg3 = obj2;
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 (arg1)->_setCallbackInfo(arg2,arg3);
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_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14453 PyObject *resultobj = 0;
14454 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14455 long result;
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_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14465 }
14466 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (long)((wxPyProcess const *)arg1)->GetPid();
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 resultobj = SWIG_From_long(static_cast< long >(result));
14474 return resultobj;
14475 fail:
14476 return NULL;
14477 }
14478
14479
14480 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14481 PyObject *resultobj = 0;
14482 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14483 int arg2 ;
14484 int arg3 ;
14485 void *argp1 = 0 ;
14486 int res1 = 0 ;
14487 int val2 ;
14488 int ecode2 = 0 ;
14489 int val3 ;
14490 int ecode3 = 0 ;
14491 PyObject * obj0 = 0 ;
14492 PyObject * obj1 = 0 ;
14493 PyObject * obj2 = 0 ;
14494 char * kwnames[] = {
14495 (char *) "self",(char *) "pid",(char *) "status", NULL
14496 };
14497
14498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14500 if (!SWIG_IsOK(res1)) {
14501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14502 }
14503 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14504 ecode2 = SWIG_AsVal_int(obj1, &val2);
14505 if (!SWIG_IsOK(ecode2)) {
14506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14507 }
14508 arg2 = static_cast< int >(val2);
14509 ecode3 = SWIG_AsVal_int(obj2, &val3);
14510 if (!SWIG_IsOK(ecode3)) {
14511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14512 }
14513 arg3 = static_cast< int >(val3);
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 (arg1)->OnTerminate(arg2,arg3);
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 resultobj = SWIG_Py_Void();
14521 return resultobj;
14522 fail:
14523 return NULL;
14524 }
14525
14526
14527 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14528 PyObject *resultobj = 0;
14529 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14530 void *argp1 = 0 ;
14531 int res1 = 0 ;
14532 PyObject *swig_obj[1] ;
14533
14534 if (!args) SWIG_fail;
14535 swig_obj[0] = args;
14536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14537 if (!SWIG_IsOK(res1)) {
14538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14539 }
14540 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 (arg1)->Redirect();
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 resultobj = SWIG_Py_Void();
14548 return resultobj;
14549 fail:
14550 return NULL;
14551 }
14552
14553
14554 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14555 PyObject *resultobj = 0;
14556 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14557 bool result;
14558 void *argp1 = 0 ;
14559 int res1 = 0 ;
14560 PyObject *swig_obj[1] ;
14561
14562 if (!args) SWIG_fail;
14563 swig_obj[0] = args;
14564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14565 if (!SWIG_IsOK(res1)) {
14566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14567 }
14568 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 result = (bool)(arg1)->IsRedirected();
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 {
14576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14577 }
14578 return resultobj;
14579 fail:
14580 return NULL;
14581 }
14582
14583
14584 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14585 PyObject *resultobj = 0;
14586 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14587 void *argp1 = 0 ;
14588 int res1 = 0 ;
14589 PyObject *swig_obj[1] ;
14590
14591 if (!args) SWIG_fail;
14592 swig_obj[0] = args;
14593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14594 if (!SWIG_IsOK(res1)) {
14595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14596 }
14597 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 (arg1)->Detach();
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 resultobj = SWIG_Py_Void();
14605 return resultobj;
14606 fail:
14607 return NULL;
14608 }
14609
14610
14611 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14612 PyObject *resultobj = 0;
14613 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14614 wxInputStream *result = 0 ;
14615 void *argp1 = 0 ;
14616 int res1 = 0 ;
14617 PyObject *swig_obj[1] ;
14618
14619 if (!args) SWIG_fail;
14620 swig_obj[0] = args;
14621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14622 if (!SWIG_IsOK(res1)) {
14623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14624 }
14625 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 result = (wxInputStream *)(arg1)->GetInputStream();
14629 wxPyEndAllowThreads(__tstate);
14630 if (PyErr_Occurred()) SWIG_fail;
14631 }
14632 {
14633 wxPyInputStream * _ptr = NULL;
14634
14635 if (result) {
14636 _ptr = new wxPyInputStream(result);
14637 }
14638 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14639 }
14640 return resultobj;
14641 fail:
14642 return NULL;
14643 }
14644
14645
14646 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14647 PyObject *resultobj = 0;
14648 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14649 wxInputStream *result = 0 ;
14650 void *argp1 = 0 ;
14651 int res1 = 0 ;
14652 PyObject *swig_obj[1] ;
14653
14654 if (!args) SWIG_fail;
14655 swig_obj[0] = args;
14656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14657 if (!SWIG_IsOK(res1)) {
14658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14659 }
14660 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (wxInputStream *)(arg1)->GetErrorStream();
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 {
14668 wxPyInputStream * _ptr = NULL;
14669
14670 if (result) {
14671 _ptr = new wxPyInputStream(result);
14672 }
14673 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14674 }
14675 return resultobj;
14676 fail:
14677 return NULL;
14678 }
14679
14680
14681 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14682 PyObject *resultobj = 0;
14683 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14684 wxOutputStream *result = 0 ;
14685 void *argp1 = 0 ;
14686 int res1 = 0 ;
14687 PyObject *swig_obj[1] ;
14688
14689 if (!args) SWIG_fail;
14690 swig_obj[0] = args;
14691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14692 if (!SWIG_IsOK(res1)) {
14693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14694 }
14695 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14696 {
14697 PyThreadState* __tstate = wxPyBeginAllowThreads();
14698 result = (wxOutputStream *)(arg1)->GetOutputStream();
14699 wxPyEndAllowThreads(__tstate);
14700 if (PyErr_Occurred()) SWIG_fail;
14701 }
14702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14703 return resultobj;
14704 fail:
14705 return NULL;
14706 }
14707
14708
14709 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14710 PyObject *resultobj = 0;
14711 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14712 void *argp1 = 0 ;
14713 int res1 = 0 ;
14714 PyObject *swig_obj[1] ;
14715
14716 if (!args) SWIG_fail;
14717 swig_obj[0] = args;
14718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14719 if (!SWIG_IsOK(res1)) {
14720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14721 }
14722 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14723 {
14724 PyThreadState* __tstate = wxPyBeginAllowThreads();
14725 (arg1)->CloseOutput();
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 resultobj = SWIG_Py_Void();
14730 return resultobj;
14731 fail:
14732 return NULL;
14733 }
14734
14735
14736 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14737 PyObject *resultobj = 0;
14738 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14739 bool result;
14740 void *argp1 = 0 ;
14741 int res1 = 0 ;
14742 PyObject *swig_obj[1] ;
14743
14744 if (!args) SWIG_fail;
14745 swig_obj[0] = args;
14746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14747 if (!SWIG_IsOK(res1)) {
14748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14749 }
14750 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14751 {
14752 PyThreadState* __tstate = wxPyBeginAllowThreads();
14753 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14754 wxPyEndAllowThreads(__tstate);
14755 if (PyErr_Occurred()) SWIG_fail;
14756 }
14757 {
14758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14759 }
14760 return resultobj;
14761 fail:
14762 return NULL;
14763 }
14764
14765
14766 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14767 PyObject *resultobj = 0;
14768 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14769 bool result;
14770 void *argp1 = 0 ;
14771 int res1 = 0 ;
14772 PyObject *swig_obj[1] ;
14773
14774 if (!args) SWIG_fail;
14775 swig_obj[0] = args;
14776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14777 if (!SWIG_IsOK(res1)) {
14778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14779 }
14780 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 {
14788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14789 }
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14797 PyObject *resultobj = 0;
14798 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14799 bool result;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 PyObject *swig_obj[1] ;
14803
14804 if (!args) SWIG_fail;
14805 swig_obj[0] = args;
14806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14807 if (!SWIG_IsOK(res1)) {
14808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14809 }
14810 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14811 {
14812 PyThreadState* __tstate = wxPyBeginAllowThreads();
14813 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 {
14818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14819 }
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14827 PyObject *obj;
14828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14829 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14830 return SWIG_Py_Void();
14831 }
14832
14833 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14834 return SWIG_Python_InitShadowInstance(args);
14835 }
14836
14837 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14838 PyObject *resultobj = 0;
14839 int arg1 = (int) 0 ;
14840 int arg2 = (int) 0 ;
14841 int arg3 = (int) 0 ;
14842 wxProcessEvent *result = 0 ;
14843 int val1 ;
14844 int ecode1 = 0 ;
14845 int val2 ;
14846 int ecode2 = 0 ;
14847 int val3 ;
14848 int ecode3 = 0 ;
14849 PyObject * obj0 = 0 ;
14850 PyObject * obj1 = 0 ;
14851 PyObject * obj2 = 0 ;
14852 char * kwnames[] = {
14853 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14854 };
14855
14856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14857 if (obj0) {
14858 ecode1 = SWIG_AsVal_int(obj0, &val1);
14859 if (!SWIG_IsOK(ecode1)) {
14860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14861 }
14862 arg1 = static_cast< int >(val1);
14863 }
14864 if (obj1) {
14865 ecode2 = SWIG_AsVal_int(obj1, &val2);
14866 if (!SWIG_IsOK(ecode2)) {
14867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14868 }
14869 arg2 = static_cast< int >(val2);
14870 }
14871 if (obj2) {
14872 ecode3 = SWIG_AsVal_int(obj2, &val3);
14873 if (!SWIG_IsOK(ecode3)) {
14874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14875 }
14876 arg3 = static_cast< int >(val3);
14877 }
14878 {
14879 PyThreadState* __tstate = wxPyBeginAllowThreads();
14880 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14881 wxPyEndAllowThreads(__tstate);
14882 if (PyErr_Occurred()) SWIG_fail;
14883 }
14884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14885 return resultobj;
14886 fail:
14887 return NULL;
14888 }
14889
14890
14891 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14892 PyObject *resultobj = 0;
14893 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14894 int result;
14895 void *argp1 = 0 ;
14896 int res1 = 0 ;
14897 PyObject *swig_obj[1] ;
14898
14899 if (!args) SWIG_fail;
14900 swig_obj[0] = args;
14901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14902 if (!SWIG_IsOK(res1)) {
14903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14904 }
14905 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14906 {
14907 PyThreadState* __tstate = wxPyBeginAllowThreads();
14908 result = (int)(arg1)->GetPid();
14909 wxPyEndAllowThreads(__tstate);
14910 if (PyErr_Occurred()) SWIG_fail;
14911 }
14912 resultobj = SWIG_From_int(static_cast< int >(result));
14913 return resultobj;
14914 fail:
14915 return NULL;
14916 }
14917
14918
14919 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14920 PyObject *resultobj = 0;
14921 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14922 int result;
14923 void *argp1 = 0 ;
14924 int res1 = 0 ;
14925 PyObject *swig_obj[1] ;
14926
14927 if (!args) SWIG_fail;
14928 swig_obj[0] = args;
14929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14930 if (!SWIG_IsOK(res1)) {
14931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14932 }
14933 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 result = (int)(arg1)->GetExitCode();
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 resultobj = SWIG_From_int(static_cast< int >(result));
14941 return resultobj;
14942 fail:
14943 return NULL;
14944 }
14945
14946
14947 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14948 PyObject *resultobj = 0;
14949 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14950 int arg2 ;
14951 void *argp1 = 0 ;
14952 int res1 = 0 ;
14953 int val2 ;
14954 int ecode2 = 0 ;
14955 PyObject *swig_obj[2] ;
14956
14957 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14959 if (!SWIG_IsOK(res1)) {
14960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14961 }
14962 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14963 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14964 if (!SWIG_IsOK(ecode2)) {
14965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14966 }
14967 arg2 = static_cast< int >(val2);
14968 if (arg1) (arg1)->m_pid = arg2;
14969
14970 resultobj = SWIG_Py_Void();
14971 return resultobj;
14972 fail:
14973 return NULL;
14974 }
14975
14976
14977 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14978 PyObject *resultobj = 0;
14979 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14980 int result;
14981 void *argp1 = 0 ;
14982 int res1 = 0 ;
14983 PyObject *swig_obj[1] ;
14984
14985 if (!args) SWIG_fail;
14986 swig_obj[0] = args;
14987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14988 if (!SWIG_IsOK(res1)) {
14989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14990 }
14991 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14992 result = (int) ((arg1)->m_pid);
14993 resultobj = SWIG_From_int(static_cast< int >(result));
14994 return resultobj;
14995 fail:
14996 return NULL;
14997 }
14998
14999
15000 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15001 PyObject *resultobj = 0;
15002 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15003 int arg2 ;
15004 void *argp1 = 0 ;
15005 int res1 = 0 ;
15006 int val2 ;
15007 int ecode2 = 0 ;
15008 PyObject *swig_obj[2] ;
15009
15010 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15012 if (!SWIG_IsOK(res1)) {
15013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15014 }
15015 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15016 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15017 if (!SWIG_IsOK(ecode2)) {
15018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15019 }
15020 arg2 = static_cast< int >(val2);
15021 if (arg1) (arg1)->m_exitcode = arg2;
15022
15023 resultobj = SWIG_Py_Void();
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15031 PyObject *resultobj = 0;
15032 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15033 int result;
15034 void *argp1 = 0 ;
15035 int res1 = 0 ;
15036 PyObject *swig_obj[1] ;
15037
15038 if (!args) SWIG_fail;
15039 swig_obj[0] = args;
15040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15041 if (!SWIG_IsOK(res1)) {
15042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15043 }
15044 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15045 result = (int) ((arg1)->m_exitcode);
15046 resultobj = SWIG_From_int(static_cast< int >(result));
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15054 PyObject *obj;
15055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15056 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15057 return SWIG_Py_Void();
15058 }
15059
15060 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15061 return SWIG_Python_InitShadowInstance(args);
15062 }
15063
15064 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj = 0;
15066 wxString *arg1 = 0 ;
15067 int arg2 = (int) wxEXEC_ASYNC ;
15068 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15069 long result;
15070 bool temp1 = false ;
15071 int val2 ;
15072 int ecode2 = 0 ;
15073 void *argp3 = 0 ;
15074 int res3 = 0 ;
15075 PyObject * obj0 = 0 ;
15076 PyObject * obj1 = 0 ;
15077 PyObject * obj2 = 0 ;
15078 char * kwnames[] = {
15079 (char *) "command",(char *) "flags",(char *) "process", NULL
15080 };
15081
15082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15083 {
15084 arg1 = wxString_in_helper(obj0);
15085 if (arg1 == NULL) SWIG_fail;
15086 temp1 = true;
15087 }
15088 if (obj1) {
15089 ecode2 = SWIG_AsVal_int(obj1, &val2);
15090 if (!SWIG_IsOK(ecode2)) {
15091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15092 }
15093 arg2 = static_cast< int >(val2);
15094 }
15095 if (obj2) {
15096 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15097 if (!SWIG_IsOK(res3)) {
15098 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15099 }
15100 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15101 }
15102 {
15103 if (!wxPyCheckForApp()) SWIG_fail;
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 resultobj = SWIG_From_long(static_cast< long >(result));
15110 {
15111 if (temp1)
15112 delete arg1;
15113 }
15114 return resultobj;
15115 fail:
15116 {
15117 if (temp1)
15118 delete arg1;
15119 }
15120 return NULL;
15121 }
15122
15123
15124 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj = 0;
15126 long arg1 ;
15127 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15128 wxKillError *arg3 = (wxKillError *) 0 ;
15129 int arg4 = (int) wxKILL_NOCHILDREN ;
15130 int result;
15131 long val1 ;
15132 int ecode1 = 0 ;
15133 int val2 ;
15134 int ecode2 = 0 ;
15135 wxKillError temp3 ;
15136 int val4 ;
15137 int ecode4 = 0 ;
15138 PyObject * obj0 = 0 ;
15139 PyObject * obj1 = 0 ;
15140 PyObject * obj2 = 0 ;
15141 char * kwnames[] = {
15142 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15143 };
15144
15145 {
15146 arg3 = &temp3;
15147 }
15148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15149 ecode1 = SWIG_AsVal_long(obj0, &val1);
15150 if (!SWIG_IsOK(ecode1)) {
15151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15152 }
15153 arg1 = static_cast< long >(val1);
15154 if (obj1) {
15155 ecode2 = SWIG_AsVal_int(obj1, &val2);
15156 if (!SWIG_IsOK(ecode2)) {
15157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15158 }
15159 arg2 = static_cast< wxSignal >(val2);
15160 }
15161 if (obj2) {
15162 ecode4 = SWIG_AsVal_int(obj2, &val4);
15163 if (!SWIG_IsOK(ecode4)) {
15164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15165 }
15166 arg4 = static_cast< int >(val4);
15167 }
15168 {
15169 PyThreadState* __tstate = wxPyBeginAllowThreads();
15170 result = (int)wxKill(arg1,arg2,arg3,arg4);
15171 wxPyEndAllowThreads(__tstate);
15172 if (PyErr_Occurred()) SWIG_fail;
15173 }
15174 resultobj = SWIG_From_int(static_cast< int >(result));
15175 {
15176 PyObject* o;
15177 o = PyInt_FromLong((long) (*arg3));
15178
15179
15180
15181 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15182
15183 }
15184 return resultobj;
15185 fail:
15186 return NULL;
15187 }
15188
15189
15190 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15191 PyObject *resultobj = 0;
15192 int arg1 = (int) wxJOYSTICK1 ;
15193 wxJoystick *result = 0 ;
15194 int val1 ;
15195 int ecode1 = 0 ;
15196 PyObject * obj0 = 0 ;
15197 char * kwnames[] = {
15198 (char *) "joystick", NULL
15199 };
15200
15201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15202 if (obj0) {
15203 ecode1 = SWIG_AsVal_int(obj0, &val1);
15204 if (!SWIG_IsOK(ecode1)) {
15205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15206 }
15207 arg1 = static_cast< int >(val1);
15208 }
15209 {
15210 if (!wxPyCheckForApp()) SWIG_fail;
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 result = (wxJoystick *)new wxJoystick(arg1);
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15224 PyObject *resultobj = 0;
15225 wxJoystick *arg1 = (wxJoystick *) 0 ;
15226 void *argp1 = 0 ;
15227 int res1 = 0 ;
15228 PyObject *swig_obj[1] ;
15229
15230 if (!args) SWIG_fail;
15231 swig_obj[0] = args;
15232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15233 if (!SWIG_IsOK(res1)) {
15234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15235 }
15236 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15237 {
15238 PyThreadState* __tstate = wxPyBeginAllowThreads();
15239 delete arg1;
15240
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 resultobj = SWIG_Py_Void();
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15252 PyObject *resultobj = 0;
15253 wxJoystick *arg1 = (wxJoystick *) 0 ;
15254 wxPoint result;
15255 void *argp1 = 0 ;
15256 int res1 = 0 ;
15257 PyObject *swig_obj[1] ;
15258
15259 if (!args) SWIG_fail;
15260 swig_obj[0] = args;
15261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15262 if (!SWIG_IsOK(res1)) {
15263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15264 }
15265 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 result = (arg1)->GetPosition();
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15273 return resultobj;
15274 fail:
15275 return NULL;
15276 }
15277
15278
15279 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15280 PyObject *resultobj = 0;
15281 wxJoystick *arg1 = (wxJoystick *) 0 ;
15282 int result;
15283 void *argp1 = 0 ;
15284 int res1 = 0 ;
15285 PyObject *swig_obj[1] ;
15286
15287 if (!args) SWIG_fail;
15288 swig_obj[0] = args;
15289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15290 if (!SWIG_IsOK(res1)) {
15291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15292 }
15293 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 result = (int)(arg1)->GetZPosition();
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 resultobj = SWIG_From_int(static_cast< int >(result));
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15308 PyObject *resultobj = 0;
15309 wxJoystick *arg1 = (wxJoystick *) 0 ;
15310 int result;
15311 void *argp1 = 0 ;
15312 int res1 = 0 ;
15313 PyObject *swig_obj[1] ;
15314
15315 if (!args) SWIG_fail;
15316 swig_obj[0] = args;
15317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15318 if (!SWIG_IsOK(res1)) {
15319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15320 }
15321 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15322 {
15323 PyThreadState* __tstate = wxPyBeginAllowThreads();
15324 result = (int)(arg1)->GetButtonState();
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 resultobj = SWIG_From_int(static_cast< int >(result));
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15336 PyObject *resultobj = 0;
15337 wxJoystick *arg1 = (wxJoystick *) 0 ;
15338 int result;
15339 void *argp1 = 0 ;
15340 int res1 = 0 ;
15341 PyObject *swig_obj[1] ;
15342
15343 if (!args) SWIG_fail;
15344 swig_obj[0] = args;
15345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15346 if (!SWIG_IsOK(res1)) {
15347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15348 }
15349 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = (int)(arg1)->GetPOVPosition();
15353 wxPyEndAllowThreads(__tstate);
15354 if (PyErr_Occurred()) SWIG_fail;
15355 }
15356 resultobj = SWIG_From_int(static_cast< int >(result));
15357 return resultobj;
15358 fail:
15359 return NULL;
15360 }
15361
15362
15363 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15364 PyObject *resultobj = 0;
15365 wxJoystick *arg1 = (wxJoystick *) 0 ;
15366 int result;
15367 void *argp1 = 0 ;
15368 int res1 = 0 ;
15369 PyObject *swig_obj[1] ;
15370
15371 if (!args) SWIG_fail;
15372 swig_obj[0] = args;
15373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15374 if (!SWIG_IsOK(res1)) {
15375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15376 }
15377 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 result = (int)(arg1)->GetPOVCTSPosition();
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 resultobj = SWIG_From_int(static_cast< int >(result));
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15392 PyObject *resultobj = 0;
15393 wxJoystick *arg1 = (wxJoystick *) 0 ;
15394 int result;
15395 void *argp1 = 0 ;
15396 int res1 = 0 ;
15397 PyObject *swig_obj[1] ;
15398
15399 if (!args) SWIG_fail;
15400 swig_obj[0] = args;
15401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15402 if (!SWIG_IsOK(res1)) {
15403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15404 }
15405 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15406 {
15407 PyThreadState* __tstate = wxPyBeginAllowThreads();
15408 result = (int)(arg1)->GetRudderPosition();
15409 wxPyEndAllowThreads(__tstate);
15410 if (PyErr_Occurred()) SWIG_fail;
15411 }
15412 resultobj = SWIG_From_int(static_cast< int >(result));
15413 return resultobj;
15414 fail:
15415 return NULL;
15416 }
15417
15418
15419 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15420 PyObject *resultobj = 0;
15421 wxJoystick *arg1 = (wxJoystick *) 0 ;
15422 int result;
15423 void *argp1 = 0 ;
15424 int res1 = 0 ;
15425 PyObject *swig_obj[1] ;
15426
15427 if (!args) SWIG_fail;
15428 swig_obj[0] = args;
15429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15430 if (!SWIG_IsOK(res1)) {
15431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15432 }
15433 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15434 {
15435 PyThreadState* __tstate = wxPyBeginAllowThreads();
15436 result = (int)(arg1)->GetUPosition();
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = SWIG_From_int(static_cast< int >(result));
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15448 PyObject *resultobj = 0;
15449 wxJoystick *arg1 = (wxJoystick *) 0 ;
15450 int result;
15451 void *argp1 = 0 ;
15452 int res1 = 0 ;
15453 PyObject *swig_obj[1] ;
15454
15455 if (!args) SWIG_fail;
15456 swig_obj[0] = args;
15457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15458 if (!SWIG_IsOK(res1)) {
15459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15460 }
15461 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 result = (int)(arg1)->GetVPosition();
15465 wxPyEndAllowThreads(__tstate);
15466 if (PyErr_Occurred()) SWIG_fail;
15467 }
15468 resultobj = SWIG_From_int(static_cast< int >(result));
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15476 PyObject *resultobj = 0;
15477 wxJoystick *arg1 = (wxJoystick *) 0 ;
15478 int result;
15479 void *argp1 = 0 ;
15480 int res1 = 0 ;
15481 PyObject *swig_obj[1] ;
15482
15483 if (!args) SWIG_fail;
15484 swig_obj[0] = args;
15485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15486 if (!SWIG_IsOK(res1)) {
15487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15488 }
15489 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 result = (int)(arg1)->GetMovementThreshold();
15493 wxPyEndAllowThreads(__tstate);
15494 if (PyErr_Occurred()) SWIG_fail;
15495 }
15496 resultobj = SWIG_From_int(static_cast< int >(result));
15497 return resultobj;
15498 fail:
15499 return NULL;
15500 }
15501
15502
15503 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj = 0;
15505 wxJoystick *arg1 = (wxJoystick *) 0 ;
15506 int arg2 ;
15507 void *argp1 = 0 ;
15508 int res1 = 0 ;
15509 int val2 ;
15510 int ecode2 = 0 ;
15511 PyObject * obj0 = 0 ;
15512 PyObject * obj1 = 0 ;
15513 char * kwnames[] = {
15514 (char *) "self",(char *) "threshold", NULL
15515 };
15516
15517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15521 }
15522 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15523 ecode2 = SWIG_AsVal_int(obj1, &val2);
15524 if (!SWIG_IsOK(ecode2)) {
15525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15526 }
15527 arg2 = static_cast< int >(val2);
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 (arg1)->SetMovementThreshold(arg2);
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = SWIG_Py_Void();
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15542 PyObject *resultobj = 0;
15543 wxJoystick *arg1 = (wxJoystick *) 0 ;
15544 bool result;
15545 void *argp1 = 0 ;
15546 int res1 = 0 ;
15547 PyObject *swig_obj[1] ;
15548
15549 if (!args) SWIG_fail;
15550 swig_obj[0] = args;
15551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15552 if (!SWIG_IsOK(res1)) {
15553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15554 }
15555 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 result = (bool)(arg1)->IsOk();
15559 wxPyEndAllowThreads(__tstate);
15560 if (PyErr_Occurred()) SWIG_fail;
15561 }
15562 {
15563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15564 }
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15572 PyObject *resultobj = 0;
15573 wxJoystick *arg1 = (wxJoystick *) 0 ;
15574 int result;
15575 void *argp1 = 0 ;
15576 int res1 = 0 ;
15577 PyObject *swig_obj[1] ;
15578
15579 if (!args) SWIG_fail;
15580 swig_obj[0] = args;
15581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15582 if (!SWIG_IsOK(res1)) {
15583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15584 }
15585 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15586 {
15587 PyThreadState* __tstate = wxPyBeginAllowThreads();
15588 result = (int)(arg1)->GetNumberJoysticks();
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 resultobj = SWIG_From_int(static_cast< int >(result));
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15600 PyObject *resultobj = 0;
15601 wxJoystick *arg1 = (wxJoystick *) 0 ;
15602 int result;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 PyObject *swig_obj[1] ;
15606
15607 if (!args) SWIG_fail;
15608 swig_obj[0] = args;
15609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15610 if (!SWIG_IsOK(res1)) {
15611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15612 }
15613 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 result = (int)(arg1)->GetManufacturerId();
15617 wxPyEndAllowThreads(__tstate);
15618 if (PyErr_Occurred()) SWIG_fail;
15619 }
15620 resultobj = SWIG_From_int(static_cast< int >(result));
15621 return resultobj;
15622 fail:
15623 return NULL;
15624 }
15625
15626
15627 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15628 PyObject *resultobj = 0;
15629 wxJoystick *arg1 = (wxJoystick *) 0 ;
15630 int result;
15631 void *argp1 = 0 ;
15632 int res1 = 0 ;
15633 PyObject *swig_obj[1] ;
15634
15635 if (!args) SWIG_fail;
15636 swig_obj[0] = args;
15637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15638 if (!SWIG_IsOK(res1)) {
15639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15640 }
15641 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15642 {
15643 PyThreadState* __tstate = wxPyBeginAllowThreads();
15644 result = (int)(arg1)->GetProductId();
15645 wxPyEndAllowThreads(__tstate);
15646 if (PyErr_Occurred()) SWIG_fail;
15647 }
15648 resultobj = SWIG_From_int(static_cast< int >(result));
15649 return resultobj;
15650 fail:
15651 return NULL;
15652 }
15653
15654
15655 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15656 PyObject *resultobj = 0;
15657 wxJoystick *arg1 = (wxJoystick *) 0 ;
15658 wxString result;
15659 void *argp1 = 0 ;
15660 int res1 = 0 ;
15661 PyObject *swig_obj[1] ;
15662
15663 if (!args) SWIG_fail;
15664 swig_obj[0] = args;
15665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15666 if (!SWIG_IsOK(res1)) {
15667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15668 }
15669 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15670 {
15671 PyThreadState* __tstate = wxPyBeginAllowThreads();
15672 result = (arg1)->GetProductName();
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 {
15677 #if wxUSE_UNICODE
15678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15679 #else
15680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15681 #endif
15682 }
15683 return resultobj;
15684 fail:
15685 return NULL;
15686 }
15687
15688
15689 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15690 PyObject *resultobj = 0;
15691 wxJoystick *arg1 = (wxJoystick *) 0 ;
15692 int result;
15693 void *argp1 = 0 ;
15694 int res1 = 0 ;
15695 PyObject *swig_obj[1] ;
15696
15697 if (!args) SWIG_fail;
15698 swig_obj[0] = args;
15699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15700 if (!SWIG_IsOK(res1)) {
15701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15702 }
15703 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15704 {
15705 PyThreadState* __tstate = wxPyBeginAllowThreads();
15706 result = (int)(arg1)->GetXMin();
15707 wxPyEndAllowThreads(__tstate);
15708 if (PyErr_Occurred()) SWIG_fail;
15709 }
15710 resultobj = SWIG_From_int(static_cast< int >(result));
15711 return resultobj;
15712 fail:
15713 return NULL;
15714 }
15715
15716
15717 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15718 PyObject *resultobj = 0;
15719 wxJoystick *arg1 = (wxJoystick *) 0 ;
15720 int result;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 PyObject *swig_obj[1] ;
15724
15725 if (!args) SWIG_fail;
15726 swig_obj[0] = args;
15727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15728 if (!SWIG_IsOK(res1)) {
15729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15730 }
15731 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15732 {
15733 PyThreadState* __tstate = wxPyBeginAllowThreads();
15734 result = (int)(arg1)->GetYMin();
15735 wxPyEndAllowThreads(__tstate);
15736 if (PyErr_Occurred()) SWIG_fail;
15737 }
15738 resultobj = SWIG_From_int(static_cast< int >(result));
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15746 PyObject *resultobj = 0;
15747 wxJoystick *arg1 = (wxJoystick *) 0 ;
15748 int result;
15749 void *argp1 = 0 ;
15750 int res1 = 0 ;
15751 PyObject *swig_obj[1] ;
15752
15753 if (!args) SWIG_fail;
15754 swig_obj[0] = args;
15755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15756 if (!SWIG_IsOK(res1)) {
15757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15758 }
15759 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (int)(arg1)->GetZMin();
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 resultobj = SWIG_From_int(static_cast< int >(result));
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15774 PyObject *resultobj = 0;
15775 wxJoystick *arg1 = (wxJoystick *) 0 ;
15776 int result;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 PyObject *swig_obj[1] ;
15780
15781 if (!args) SWIG_fail;
15782 swig_obj[0] = args;
15783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15784 if (!SWIG_IsOK(res1)) {
15785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15786 }
15787 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (int)(arg1)->GetXMax();
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 resultobj = SWIG_From_int(static_cast< int >(result));
15795 return resultobj;
15796 fail:
15797 return NULL;
15798 }
15799
15800
15801 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15802 PyObject *resultobj = 0;
15803 wxJoystick *arg1 = (wxJoystick *) 0 ;
15804 int result;
15805 void *argp1 = 0 ;
15806 int res1 = 0 ;
15807 PyObject *swig_obj[1] ;
15808
15809 if (!args) SWIG_fail;
15810 swig_obj[0] = args;
15811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15814 }
15815 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (int)(arg1)->GetYMax();
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 resultobj = SWIG_From_int(static_cast< int >(result));
15823 return resultobj;
15824 fail:
15825 return NULL;
15826 }
15827
15828
15829 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15830 PyObject *resultobj = 0;
15831 wxJoystick *arg1 = (wxJoystick *) 0 ;
15832 int result;
15833 void *argp1 = 0 ;
15834 int res1 = 0 ;
15835 PyObject *swig_obj[1] ;
15836
15837 if (!args) SWIG_fail;
15838 swig_obj[0] = args;
15839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15840 if (!SWIG_IsOK(res1)) {
15841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15842 }
15843 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15844 {
15845 PyThreadState* __tstate = wxPyBeginAllowThreads();
15846 result = (int)(arg1)->GetZMax();
15847 wxPyEndAllowThreads(__tstate);
15848 if (PyErr_Occurred()) SWIG_fail;
15849 }
15850 resultobj = SWIG_From_int(static_cast< int >(result));
15851 return resultobj;
15852 fail:
15853 return NULL;
15854 }
15855
15856
15857 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15858 PyObject *resultobj = 0;
15859 wxJoystick *arg1 = (wxJoystick *) 0 ;
15860 int result;
15861 void *argp1 = 0 ;
15862 int res1 = 0 ;
15863 PyObject *swig_obj[1] ;
15864
15865 if (!args) SWIG_fail;
15866 swig_obj[0] = args;
15867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15868 if (!SWIG_IsOK(res1)) {
15869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15870 }
15871 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15872 {
15873 PyThreadState* __tstate = wxPyBeginAllowThreads();
15874 result = (int)(arg1)->GetNumberButtons();
15875 wxPyEndAllowThreads(__tstate);
15876 if (PyErr_Occurred()) SWIG_fail;
15877 }
15878 resultobj = SWIG_From_int(static_cast< int >(result));
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15886 PyObject *resultobj = 0;
15887 wxJoystick *arg1 = (wxJoystick *) 0 ;
15888 int result;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject *swig_obj[1] ;
15892
15893 if (!args) SWIG_fail;
15894 swig_obj[0] = args;
15895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15896 if (!SWIG_IsOK(res1)) {
15897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15898 }
15899 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (int)(arg1)->GetNumberAxes();
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_From_int(static_cast< int >(result));
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15914 PyObject *resultobj = 0;
15915 wxJoystick *arg1 = (wxJoystick *) 0 ;
15916 int result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 PyObject *swig_obj[1] ;
15920
15921 if (!args) SWIG_fail;
15922 swig_obj[0] = args;
15923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15924 if (!SWIG_IsOK(res1)) {
15925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15926 }
15927 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 result = (int)(arg1)->GetMaxButtons();
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 resultobj = SWIG_From_int(static_cast< int >(result));
15935 return resultobj;
15936 fail:
15937 return NULL;
15938 }
15939
15940
15941 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15942 PyObject *resultobj = 0;
15943 wxJoystick *arg1 = (wxJoystick *) 0 ;
15944 int result;
15945 void *argp1 = 0 ;
15946 int res1 = 0 ;
15947 PyObject *swig_obj[1] ;
15948
15949 if (!args) SWIG_fail;
15950 swig_obj[0] = args;
15951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15952 if (!SWIG_IsOK(res1)) {
15953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15954 }
15955 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15956 {
15957 PyThreadState* __tstate = wxPyBeginAllowThreads();
15958 result = (int)(arg1)->GetMaxAxes();
15959 wxPyEndAllowThreads(__tstate);
15960 if (PyErr_Occurred()) SWIG_fail;
15961 }
15962 resultobj = SWIG_From_int(static_cast< int >(result));
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15970 PyObject *resultobj = 0;
15971 wxJoystick *arg1 = (wxJoystick *) 0 ;
15972 int result;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 PyObject *swig_obj[1] ;
15976
15977 if (!args) SWIG_fail;
15978 swig_obj[0] = args;
15979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15980 if (!SWIG_IsOK(res1)) {
15981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15982 }
15983 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15984 {
15985 PyThreadState* __tstate = wxPyBeginAllowThreads();
15986 result = (int)(arg1)->GetPollingMin();
15987 wxPyEndAllowThreads(__tstate);
15988 if (PyErr_Occurred()) SWIG_fail;
15989 }
15990 resultobj = SWIG_From_int(static_cast< int >(result));
15991 return resultobj;
15992 fail:
15993 return NULL;
15994 }
15995
15996
15997 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15998 PyObject *resultobj = 0;
15999 wxJoystick *arg1 = (wxJoystick *) 0 ;
16000 int result;
16001 void *argp1 = 0 ;
16002 int res1 = 0 ;
16003 PyObject *swig_obj[1] ;
16004
16005 if (!args) SWIG_fail;
16006 swig_obj[0] = args;
16007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16008 if (!SWIG_IsOK(res1)) {
16009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16010 }
16011 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 result = (int)(arg1)->GetPollingMax();
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 resultobj = SWIG_From_int(static_cast< int >(result));
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16026 PyObject *resultobj = 0;
16027 wxJoystick *arg1 = (wxJoystick *) 0 ;
16028 int result;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 PyObject *swig_obj[1] ;
16032
16033 if (!args) SWIG_fail;
16034 swig_obj[0] = args;
16035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16036 if (!SWIG_IsOK(res1)) {
16037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16038 }
16039 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 result = (int)(arg1)->GetRudderMin();
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 resultobj = SWIG_From_int(static_cast< int >(result));
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16054 PyObject *resultobj = 0;
16055 wxJoystick *arg1 = (wxJoystick *) 0 ;
16056 int result;
16057 void *argp1 = 0 ;
16058 int res1 = 0 ;
16059 PyObject *swig_obj[1] ;
16060
16061 if (!args) SWIG_fail;
16062 swig_obj[0] = args;
16063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16064 if (!SWIG_IsOK(res1)) {
16065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16066 }
16067 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16068 {
16069 PyThreadState* __tstate = wxPyBeginAllowThreads();
16070 result = (int)(arg1)->GetRudderMax();
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 resultobj = SWIG_From_int(static_cast< int >(result));
16075 return resultobj;
16076 fail:
16077 return NULL;
16078 }
16079
16080
16081 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16082 PyObject *resultobj = 0;
16083 wxJoystick *arg1 = (wxJoystick *) 0 ;
16084 int result;
16085 void *argp1 = 0 ;
16086 int res1 = 0 ;
16087 PyObject *swig_obj[1] ;
16088
16089 if (!args) SWIG_fail;
16090 swig_obj[0] = args;
16091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16092 if (!SWIG_IsOK(res1)) {
16093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16094 }
16095 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 result = (int)(arg1)->GetUMin();
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 resultobj = SWIG_From_int(static_cast< int >(result));
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16110 PyObject *resultobj = 0;
16111 wxJoystick *arg1 = (wxJoystick *) 0 ;
16112 int result;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 PyObject *swig_obj[1] ;
16116
16117 if (!args) SWIG_fail;
16118 swig_obj[0] = args;
16119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16120 if (!SWIG_IsOK(res1)) {
16121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16122 }
16123 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 result = (int)(arg1)->GetUMax();
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 resultobj = SWIG_From_int(static_cast< int >(result));
16131 return resultobj;
16132 fail:
16133 return NULL;
16134 }
16135
16136
16137 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16138 PyObject *resultobj = 0;
16139 wxJoystick *arg1 = (wxJoystick *) 0 ;
16140 int result;
16141 void *argp1 = 0 ;
16142 int res1 = 0 ;
16143 PyObject *swig_obj[1] ;
16144
16145 if (!args) SWIG_fail;
16146 swig_obj[0] = args;
16147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16148 if (!SWIG_IsOK(res1)) {
16149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16150 }
16151 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16152 {
16153 PyThreadState* __tstate = wxPyBeginAllowThreads();
16154 result = (int)(arg1)->GetVMin();
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 resultobj = SWIG_From_int(static_cast< int >(result));
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16166 PyObject *resultobj = 0;
16167 wxJoystick *arg1 = (wxJoystick *) 0 ;
16168 int result;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 PyObject *swig_obj[1] ;
16172
16173 if (!args) SWIG_fail;
16174 swig_obj[0] = args;
16175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16178 }
16179 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16180 {
16181 PyThreadState* __tstate = wxPyBeginAllowThreads();
16182 result = (int)(arg1)->GetVMax();
16183 wxPyEndAllowThreads(__tstate);
16184 if (PyErr_Occurred()) SWIG_fail;
16185 }
16186 resultobj = SWIG_From_int(static_cast< int >(result));
16187 return resultobj;
16188 fail:
16189 return NULL;
16190 }
16191
16192
16193 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16194 PyObject *resultobj = 0;
16195 wxJoystick *arg1 = (wxJoystick *) 0 ;
16196 bool result;
16197 void *argp1 = 0 ;
16198 int res1 = 0 ;
16199 PyObject *swig_obj[1] ;
16200
16201 if (!args) SWIG_fail;
16202 swig_obj[0] = args;
16203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16204 if (!SWIG_IsOK(res1)) {
16205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16206 }
16207 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16208 {
16209 PyThreadState* __tstate = wxPyBeginAllowThreads();
16210 result = (bool)(arg1)->HasRudder();
16211 wxPyEndAllowThreads(__tstate);
16212 if (PyErr_Occurred()) SWIG_fail;
16213 }
16214 {
16215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16216 }
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16224 PyObject *resultobj = 0;
16225 wxJoystick *arg1 = (wxJoystick *) 0 ;
16226 bool result;
16227 void *argp1 = 0 ;
16228 int res1 = 0 ;
16229 PyObject *swig_obj[1] ;
16230
16231 if (!args) SWIG_fail;
16232 swig_obj[0] = args;
16233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16234 if (!SWIG_IsOK(res1)) {
16235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16236 }
16237 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16238 {
16239 PyThreadState* __tstate = wxPyBeginAllowThreads();
16240 result = (bool)(arg1)->HasZ();
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 {
16245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16246 }
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16254 PyObject *resultobj = 0;
16255 wxJoystick *arg1 = (wxJoystick *) 0 ;
16256 bool result;
16257 void *argp1 = 0 ;
16258 int res1 = 0 ;
16259 PyObject *swig_obj[1] ;
16260
16261 if (!args) SWIG_fail;
16262 swig_obj[0] = args;
16263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16264 if (!SWIG_IsOK(res1)) {
16265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16266 }
16267 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16268 {
16269 PyThreadState* __tstate = wxPyBeginAllowThreads();
16270 result = (bool)(arg1)->HasU();
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 {
16275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16276 }
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16284 PyObject *resultobj = 0;
16285 wxJoystick *arg1 = (wxJoystick *) 0 ;
16286 bool result;
16287 void *argp1 = 0 ;
16288 int res1 = 0 ;
16289 PyObject *swig_obj[1] ;
16290
16291 if (!args) SWIG_fail;
16292 swig_obj[0] = args;
16293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16294 if (!SWIG_IsOK(res1)) {
16295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16296 }
16297 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16298 {
16299 PyThreadState* __tstate = wxPyBeginAllowThreads();
16300 result = (bool)(arg1)->HasV();
16301 wxPyEndAllowThreads(__tstate);
16302 if (PyErr_Occurred()) SWIG_fail;
16303 }
16304 {
16305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16306 }
16307 return resultobj;
16308 fail:
16309 return NULL;
16310 }
16311
16312
16313 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16314 PyObject *resultobj = 0;
16315 wxJoystick *arg1 = (wxJoystick *) 0 ;
16316 bool result;
16317 void *argp1 = 0 ;
16318 int res1 = 0 ;
16319 PyObject *swig_obj[1] ;
16320
16321 if (!args) SWIG_fail;
16322 swig_obj[0] = args;
16323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16324 if (!SWIG_IsOK(res1)) {
16325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16326 }
16327 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 result = (bool)(arg1)->HasPOV();
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 {
16335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16336 }
16337 return resultobj;
16338 fail:
16339 return NULL;
16340 }
16341
16342
16343 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16344 PyObject *resultobj = 0;
16345 wxJoystick *arg1 = (wxJoystick *) 0 ;
16346 bool result;
16347 void *argp1 = 0 ;
16348 int res1 = 0 ;
16349 PyObject *swig_obj[1] ;
16350
16351 if (!args) SWIG_fail;
16352 swig_obj[0] = args;
16353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16354 if (!SWIG_IsOK(res1)) {
16355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16356 }
16357 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16358 {
16359 PyThreadState* __tstate = wxPyBeginAllowThreads();
16360 result = (bool)(arg1)->HasPOV4Dir();
16361 wxPyEndAllowThreads(__tstate);
16362 if (PyErr_Occurred()) SWIG_fail;
16363 }
16364 {
16365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16366 }
16367 return resultobj;
16368 fail:
16369 return NULL;
16370 }
16371
16372
16373 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16374 PyObject *resultobj = 0;
16375 wxJoystick *arg1 = (wxJoystick *) 0 ;
16376 bool result;
16377 void *argp1 = 0 ;
16378 int res1 = 0 ;
16379 PyObject *swig_obj[1] ;
16380
16381 if (!args) SWIG_fail;
16382 swig_obj[0] = args;
16383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16384 if (!SWIG_IsOK(res1)) {
16385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16386 }
16387 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16388 {
16389 PyThreadState* __tstate = wxPyBeginAllowThreads();
16390 result = (bool)(arg1)->HasPOVCTS();
16391 wxPyEndAllowThreads(__tstate);
16392 if (PyErr_Occurred()) SWIG_fail;
16393 }
16394 {
16395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16396 }
16397 return resultobj;
16398 fail:
16399 return NULL;
16400 }
16401
16402
16403 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16404 PyObject *resultobj = 0;
16405 wxJoystick *arg1 = (wxJoystick *) 0 ;
16406 wxWindow *arg2 = (wxWindow *) 0 ;
16407 int arg3 = (int) 0 ;
16408 bool result;
16409 void *argp1 = 0 ;
16410 int res1 = 0 ;
16411 void *argp2 = 0 ;
16412 int res2 = 0 ;
16413 int val3 ;
16414 int ecode3 = 0 ;
16415 PyObject * obj0 = 0 ;
16416 PyObject * obj1 = 0 ;
16417 PyObject * obj2 = 0 ;
16418 char * kwnames[] = {
16419 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16420 };
16421
16422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16426 }
16427 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16429 if (!SWIG_IsOK(res2)) {
16430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16431 }
16432 arg2 = reinterpret_cast< wxWindow * >(argp2);
16433 if (obj2) {
16434 ecode3 = SWIG_AsVal_int(obj2, &val3);
16435 if (!SWIG_IsOK(ecode3)) {
16436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16437 }
16438 arg3 = static_cast< int >(val3);
16439 }
16440 {
16441 PyThreadState* __tstate = wxPyBeginAllowThreads();
16442 result = (bool)(arg1)->SetCapture(arg2,arg3);
16443 wxPyEndAllowThreads(__tstate);
16444 if (PyErr_Occurred()) SWIG_fail;
16445 }
16446 {
16447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16448 }
16449 return resultobj;
16450 fail:
16451 return NULL;
16452 }
16453
16454
16455 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16456 PyObject *resultobj = 0;
16457 wxJoystick *arg1 = (wxJoystick *) 0 ;
16458 bool result;
16459 void *argp1 = 0 ;
16460 int res1 = 0 ;
16461 PyObject *swig_obj[1] ;
16462
16463 if (!args) SWIG_fail;
16464 swig_obj[0] = args;
16465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16466 if (!SWIG_IsOK(res1)) {
16467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16468 }
16469 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16470 {
16471 PyThreadState* __tstate = wxPyBeginAllowThreads();
16472 result = (bool)(arg1)->ReleaseCapture();
16473 wxPyEndAllowThreads(__tstate);
16474 if (PyErr_Occurred()) SWIG_fail;
16475 }
16476 {
16477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16478 }
16479 return resultobj;
16480 fail:
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16486 PyObject *obj;
16487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16488 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16489 return SWIG_Py_Void();
16490 }
16491
16492 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16493 return SWIG_Python_InitShadowInstance(args);
16494 }
16495
16496 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16497 PyObject *resultobj = 0;
16498 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16499 int arg2 = (int) 0 ;
16500 int arg3 = (int) wxJOYSTICK1 ;
16501 int arg4 = (int) 0 ;
16502 wxJoystickEvent *result = 0 ;
16503 int val1 ;
16504 int ecode1 = 0 ;
16505 int val2 ;
16506 int ecode2 = 0 ;
16507 int val3 ;
16508 int ecode3 = 0 ;
16509 int val4 ;
16510 int ecode4 = 0 ;
16511 PyObject * obj0 = 0 ;
16512 PyObject * obj1 = 0 ;
16513 PyObject * obj2 = 0 ;
16514 PyObject * obj3 = 0 ;
16515 char * kwnames[] = {
16516 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16517 };
16518
16519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16520 if (obj0) {
16521 ecode1 = SWIG_AsVal_int(obj0, &val1);
16522 if (!SWIG_IsOK(ecode1)) {
16523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16524 }
16525 arg1 = static_cast< wxEventType >(val1);
16526 }
16527 if (obj1) {
16528 ecode2 = SWIG_AsVal_int(obj1, &val2);
16529 if (!SWIG_IsOK(ecode2)) {
16530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16531 }
16532 arg2 = static_cast< int >(val2);
16533 }
16534 if (obj2) {
16535 ecode3 = SWIG_AsVal_int(obj2, &val3);
16536 if (!SWIG_IsOK(ecode3)) {
16537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16538 }
16539 arg3 = static_cast< int >(val3);
16540 }
16541 if (obj3) {
16542 ecode4 = SWIG_AsVal_int(obj3, &val4);
16543 if (!SWIG_IsOK(ecode4)) {
16544 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16545 }
16546 arg4 = static_cast< int >(val4);
16547 }
16548 {
16549 PyThreadState* __tstate = wxPyBeginAllowThreads();
16550 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16555 return resultobj;
16556 fail:
16557 return NULL;
16558 }
16559
16560
16561 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16562 PyObject *resultobj = 0;
16563 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16564 wxPoint result;
16565 void *argp1 = 0 ;
16566 int res1 = 0 ;
16567 PyObject *swig_obj[1] ;
16568
16569 if (!args) SWIG_fail;
16570 swig_obj[0] = args;
16571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16572 if (!SWIG_IsOK(res1)) {
16573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16574 }
16575 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16590 PyObject *resultobj = 0;
16591 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16592 int result;
16593 void *argp1 = 0 ;
16594 int res1 = 0 ;
16595 PyObject *swig_obj[1] ;
16596
16597 if (!args) SWIG_fail;
16598 swig_obj[0] = args;
16599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16600 if (!SWIG_IsOK(res1)) {
16601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16602 }
16603 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16604 {
16605 PyThreadState* __tstate = wxPyBeginAllowThreads();
16606 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 resultobj = SWIG_From_int(static_cast< int >(result));
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16618 PyObject *resultobj = 0;
16619 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16620 int result;
16621 void *argp1 = 0 ;
16622 int res1 = 0 ;
16623 PyObject *swig_obj[1] ;
16624
16625 if (!args) SWIG_fail;
16626 swig_obj[0] = args;
16627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16630 }
16631 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_From_int(static_cast< int >(result));
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16646 PyObject *resultobj = 0;
16647 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16648 int result;
16649 void *argp1 = 0 ;
16650 int res1 = 0 ;
16651 PyObject *swig_obj[1] ;
16652
16653 if (!args) SWIG_fail;
16654 swig_obj[0] = args;
16655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16658 }
16659 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 resultobj = SWIG_From_int(static_cast< int >(result));
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16674 PyObject *resultobj = 0;
16675 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16676 int result;
16677 void *argp1 = 0 ;
16678 int res1 = 0 ;
16679 PyObject *swig_obj[1] ;
16680
16681 if (!args) SWIG_fail;
16682 swig_obj[0] = args;
16683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16684 if (!SWIG_IsOK(res1)) {
16685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16686 }
16687 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16688 {
16689 PyThreadState* __tstate = wxPyBeginAllowThreads();
16690 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16691 wxPyEndAllowThreads(__tstate);
16692 if (PyErr_Occurred()) SWIG_fail;
16693 }
16694 resultobj = SWIG_From_int(static_cast< int >(result));
16695 return resultobj;
16696 fail:
16697 return NULL;
16698 }
16699
16700
16701 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16702 PyObject *resultobj = 0;
16703 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16704 int arg2 ;
16705 void *argp1 = 0 ;
16706 int res1 = 0 ;
16707 int val2 ;
16708 int ecode2 = 0 ;
16709 PyObject * obj0 = 0 ;
16710 PyObject * obj1 = 0 ;
16711 char * kwnames[] = {
16712 (char *) "self",(char *) "stick", NULL
16713 };
16714
16715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16717 if (!SWIG_IsOK(res1)) {
16718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16719 }
16720 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16721 ecode2 = SWIG_AsVal_int(obj1, &val2);
16722 if (!SWIG_IsOK(ecode2)) {
16723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16724 }
16725 arg2 = static_cast< int >(val2);
16726 {
16727 PyThreadState* __tstate = wxPyBeginAllowThreads();
16728 (arg1)->SetJoystick(arg2);
16729 wxPyEndAllowThreads(__tstate);
16730 if (PyErr_Occurred()) SWIG_fail;
16731 }
16732 resultobj = SWIG_Py_Void();
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16740 PyObject *resultobj = 0;
16741 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16742 int arg2 ;
16743 void *argp1 = 0 ;
16744 int res1 = 0 ;
16745 int val2 ;
16746 int ecode2 = 0 ;
16747 PyObject * obj0 = 0 ;
16748 PyObject * obj1 = 0 ;
16749 char * kwnames[] = {
16750 (char *) "self",(char *) "state", NULL
16751 };
16752
16753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16755 if (!SWIG_IsOK(res1)) {
16756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16757 }
16758 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16759 ecode2 = SWIG_AsVal_int(obj1, &val2);
16760 if (!SWIG_IsOK(ecode2)) {
16761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16762 }
16763 arg2 = static_cast< int >(val2);
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 (arg1)->SetButtonState(arg2);
16767 wxPyEndAllowThreads(__tstate);
16768 if (PyErr_Occurred()) SWIG_fail;
16769 }
16770 resultobj = SWIG_Py_Void();
16771 return resultobj;
16772 fail:
16773 return NULL;
16774 }
16775
16776
16777 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16778 PyObject *resultobj = 0;
16779 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16780 int arg2 ;
16781 void *argp1 = 0 ;
16782 int res1 = 0 ;
16783 int val2 ;
16784 int ecode2 = 0 ;
16785 PyObject * obj0 = 0 ;
16786 PyObject * obj1 = 0 ;
16787 char * kwnames[] = {
16788 (char *) "self",(char *) "change", NULL
16789 };
16790
16791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16793 if (!SWIG_IsOK(res1)) {
16794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16795 }
16796 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16797 ecode2 = SWIG_AsVal_int(obj1, &val2);
16798 if (!SWIG_IsOK(ecode2)) {
16799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16800 }
16801 arg2 = static_cast< int >(val2);
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 (arg1)->SetButtonChange(arg2);
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 resultobj = SWIG_Py_Void();
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj = 0;
16817 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16818 wxPoint *arg2 = 0 ;
16819 void *argp1 = 0 ;
16820 int res1 = 0 ;
16821 wxPoint temp2 ;
16822 PyObject * obj0 = 0 ;
16823 PyObject * obj1 = 0 ;
16824 char * kwnames[] = {
16825 (char *) "self",(char *) "pos", NULL
16826 };
16827
16828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16830 if (!SWIG_IsOK(res1)) {
16831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16832 }
16833 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16834 {
16835 arg2 = &temp2;
16836 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16837 }
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 (arg1)->SetPosition((wxPoint const &)*arg2);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_Py_Void();
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj = 0;
16853 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16854 int arg2 ;
16855 void *argp1 = 0 ;
16856 int res1 = 0 ;
16857 int val2 ;
16858 int ecode2 = 0 ;
16859 PyObject * obj0 = 0 ;
16860 PyObject * obj1 = 0 ;
16861 char * kwnames[] = {
16862 (char *) "self",(char *) "zPos", NULL
16863 };
16864
16865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16867 if (!SWIG_IsOK(res1)) {
16868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16869 }
16870 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16871 ecode2 = SWIG_AsVal_int(obj1, &val2);
16872 if (!SWIG_IsOK(ecode2)) {
16873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16874 }
16875 arg2 = static_cast< int >(val2);
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 (arg1)->SetZPosition(arg2);
16879 wxPyEndAllowThreads(__tstate);
16880 if (PyErr_Occurred()) SWIG_fail;
16881 }
16882 resultobj = SWIG_Py_Void();
16883 return resultobj;
16884 fail:
16885 return NULL;
16886 }
16887
16888
16889 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16890 PyObject *resultobj = 0;
16891 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16892 bool result;
16893 void *argp1 = 0 ;
16894 int res1 = 0 ;
16895 PyObject *swig_obj[1] ;
16896
16897 if (!args) SWIG_fail;
16898 swig_obj[0] = args;
16899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16900 if (!SWIG_IsOK(res1)) {
16901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16902 }
16903 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 {
16911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16912 }
16913 return resultobj;
16914 fail:
16915 return NULL;
16916 }
16917
16918
16919 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16920 PyObject *resultobj = 0;
16921 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16922 bool result;
16923 void *argp1 = 0 ;
16924 int res1 = 0 ;
16925 PyObject *swig_obj[1] ;
16926
16927 if (!args) SWIG_fail;
16928 swig_obj[0] = args;
16929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16930 if (!SWIG_IsOK(res1)) {
16931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16932 }
16933 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
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 *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16950 PyObject *resultobj = 0;
16951 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16952 bool result;
16953 void *argp1 = 0 ;
16954 int res1 = 0 ;
16955 PyObject *swig_obj[1] ;
16956
16957 if (!args) SWIG_fail;
16958 swig_obj[0] = args;
16959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16960 if (!SWIG_IsOK(res1)) {
16961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16962 }
16963 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16964 {
16965 PyThreadState* __tstate = wxPyBeginAllowThreads();
16966 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16967 wxPyEndAllowThreads(__tstate);
16968 if (PyErr_Occurred()) SWIG_fail;
16969 }
16970 {
16971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16972 }
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj = 0;
16981 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16982 int arg2 = (int) wxJOY_BUTTON_ANY ;
16983 bool result;
16984 void *argp1 = 0 ;
16985 int res1 = 0 ;
16986 int val2 ;
16987 int ecode2 = 0 ;
16988 PyObject * obj0 = 0 ;
16989 PyObject * obj1 = 0 ;
16990 char * kwnames[] = {
16991 (char *) "self",(char *) "but", NULL
16992 };
16993
16994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16996 if (!SWIG_IsOK(res1)) {
16997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16998 }
16999 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17000 if (obj1) {
17001 ecode2 = SWIG_AsVal_int(obj1, &val2);
17002 if (!SWIG_IsOK(ecode2)) {
17003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17004 }
17005 arg2 = static_cast< int >(val2);
17006 }
17007 {
17008 PyThreadState* __tstate = wxPyBeginAllowThreads();
17009 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17010 wxPyEndAllowThreads(__tstate);
17011 if (PyErr_Occurred()) SWIG_fail;
17012 }
17013 {
17014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17015 }
17016 return resultobj;
17017 fail:
17018 return NULL;
17019 }
17020
17021
17022 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17023 PyObject *resultobj = 0;
17024 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17025 int arg2 = (int) wxJOY_BUTTON_ANY ;
17026 bool result;
17027 void *argp1 = 0 ;
17028 int res1 = 0 ;
17029 int val2 ;
17030 int ecode2 = 0 ;
17031 PyObject * obj0 = 0 ;
17032 PyObject * obj1 = 0 ;
17033 char * kwnames[] = {
17034 (char *) "self",(char *) "but", NULL
17035 };
17036
17037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17039 if (!SWIG_IsOK(res1)) {
17040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17041 }
17042 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17043 if (obj1) {
17044 ecode2 = SWIG_AsVal_int(obj1, &val2);
17045 if (!SWIG_IsOK(ecode2)) {
17046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17047 }
17048 arg2 = static_cast< int >(val2);
17049 }
17050 {
17051 PyThreadState* __tstate = wxPyBeginAllowThreads();
17052 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17053 wxPyEndAllowThreads(__tstate);
17054 if (PyErr_Occurred()) SWIG_fail;
17055 }
17056 {
17057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17058 }
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj = 0;
17067 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17068 int arg2 = (int) wxJOY_BUTTON_ANY ;
17069 bool result;
17070 void *argp1 = 0 ;
17071 int res1 = 0 ;
17072 int val2 ;
17073 int ecode2 = 0 ;
17074 PyObject * obj0 = 0 ;
17075 PyObject * obj1 = 0 ;
17076 char * kwnames[] = {
17077 (char *) "self",(char *) "but", NULL
17078 };
17079
17080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17082 if (!SWIG_IsOK(res1)) {
17083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17084 }
17085 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17086 if (obj1) {
17087 ecode2 = SWIG_AsVal_int(obj1, &val2);
17088 if (!SWIG_IsOK(ecode2)) {
17089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17090 }
17091 arg2 = static_cast< int >(val2);
17092 }
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 {
17100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17101 }
17102 return resultobj;
17103 fail:
17104 return NULL;
17105 }
17106
17107
17108 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17109 PyObject *obj;
17110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17111 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17112 return SWIG_Py_Void();
17113 }
17114
17115 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17116 return SWIG_Python_InitShadowInstance(args);
17117 }
17118
17119 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17120 PyObject *resultobj = 0;
17121 wxString const &arg1_defvalue = wxPyEmptyString ;
17122 wxString *arg1 = (wxString *) &arg1_defvalue ;
17123 wxSound *result = 0 ;
17124 bool temp1 = false ;
17125 PyObject * obj0 = 0 ;
17126 char * kwnames[] = {
17127 (char *) "fileName", NULL
17128 };
17129
17130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17131 if (obj0) {
17132 {
17133 arg1 = wxString_in_helper(obj0);
17134 if (arg1 == NULL) SWIG_fail;
17135 temp1 = true;
17136 }
17137 }
17138 {
17139 if (!wxPyCheckForApp()) SWIG_fail;
17140 PyThreadState* __tstate = wxPyBeginAllowThreads();
17141 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17146 {
17147 if (temp1)
17148 delete arg1;
17149 }
17150 return resultobj;
17151 fail:
17152 {
17153 if (temp1)
17154 delete arg1;
17155 }
17156 return NULL;
17157 }
17158
17159
17160 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj = 0;
17162 PyObject *arg1 = (PyObject *) 0 ;
17163 wxSound *result = 0 ;
17164 PyObject * obj0 = 0 ;
17165 char * kwnames[] = {
17166 (char *) "data", NULL
17167 };
17168
17169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17170 arg1 = obj0;
17171 {
17172 if (!wxPyCheckForApp()) SWIG_fail;
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 result = (wxSound *)new_wxSound(arg1);
17175 wxPyEndAllowThreads(__tstate);
17176 if (PyErr_Occurred()) SWIG_fail;
17177 }
17178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17179 return resultobj;
17180 fail:
17181 return NULL;
17182 }
17183
17184
17185 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17186 PyObject *resultobj = 0;
17187 wxSound *arg1 = (wxSound *) 0 ;
17188 void *argp1 = 0 ;
17189 int res1 = 0 ;
17190 PyObject *swig_obj[1] ;
17191
17192 if (!args) SWIG_fail;
17193 swig_obj[0] = args;
17194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17195 if (!SWIG_IsOK(res1)) {
17196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17197 }
17198 arg1 = reinterpret_cast< wxSound * >(argp1);
17199 {
17200 PyThreadState* __tstate = wxPyBeginAllowThreads();
17201 delete arg1;
17202
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 resultobj = SWIG_Py_Void();
17207 return resultobj;
17208 fail:
17209 return NULL;
17210 }
17211
17212
17213 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17214 PyObject *resultobj = 0;
17215 wxSound *arg1 = (wxSound *) 0 ;
17216 wxString *arg2 = 0 ;
17217 bool result;
17218 void *argp1 = 0 ;
17219 int res1 = 0 ;
17220 bool temp2 = false ;
17221 PyObject * obj0 = 0 ;
17222 PyObject * obj1 = 0 ;
17223 char * kwnames[] = {
17224 (char *) "self",(char *) "fileName", NULL
17225 };
17226
17227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17229 if (!SWIG_IsOK(res1)) {
17230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17231 }
17232 arg1 = reinterpret_cast< wxSound * >(argp1);
17233 {
17234 arg2 = wxString_in_helper(obj1);
17235 if (arg2 == NULL) SWIG_fail;
17236 temp2 = true;
17237 }
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (bool)(arg1)->Create((wxString const &)*arg2);
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 {
17245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17246 }
17247 {
17248 if (temp2)
17249 delete arg2;
17250 }
17251 return resultobj;
17252 fail:
17253 {
17254 if (temp2)
17255 delete arg2;
17256 }
17257 return NULL;
17258 }
17259
17260
17261 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj = 0;
17263 wxSound *arg1 = (wxSound *) 0 ;
17264 PyObject *arg2 = (PyObject *) 0 ;
17265 bool result;
17266 void *argp1 = 0 ;
17267 int res1 = 0 ;
17268 PyObject * obj0 = 0 ;
17269 PyObject * obj1 = 0 ;
17270 char * kwnames[] = {
17271 (char *) "self",(char *) "data", NULL
17272 };
17273
17274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17276 if (!SWIG_IsOK(res1)) {
17277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17278 }
17279 arg1 = reinterpret_cast< wxSound * >(argp1);
17280 arg2 = obj1;
17281 {
17282 PyThreadState* __tstate = wxPyBeginAllowThreads();
17283 result = (bool)wxSound_CreateFromData(arg1,arg2);
17284 wxPyEndAllowThreads(__tstate);
17285 if (PyErr_Occurred()) SWIG_fail;
17286 }
17287 {
17288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17289 }
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17297 PyObject *resultobj = 0;
17298 wxSound *arg1 = (wxSound *) 0 ;
17299 bool result;
17300 void *argp1 = 0 ;
17301 int res1 = 0 ;
17302 PyObject *swig_obj[1] ;
17303
17304 if (!args) SWIG_fail;
17305 swig_obj[0] = args;
17306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17307 if (!SWIG_IsOK(res1)) {
17308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17309 }
17310 arg1 = reinterpret_cast< wxSound * >(argp1);
17311 {
17312 PyThreadState* __tstate = wxPyBeginAllowThreads();
17313 result = (bool)(arg1)->IsOk();
17314 wxPyEndAllowThreads(__tstate);
17315 if (PyErr_Occurred()) SWIG_fail;
17316 }
17317 {
17318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17319 }
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17327 PyObject *resultobj = 0;
17328 wxSound *arg1 = (wxSound *) 0 ;
17329 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17330 bool result;
17331 void *argp1 = 0 ;
17332 int res1 = 0 ;
17333 unsigned int val2 ;
17334 int ecode2 = 0 ;
17335 PyObject * obj0 = 0 ;
17336 PyObject * obj1 = 0 ;
17337 char * kwnames[] = {
17338 (char *) "self",(char *) "flags", NULL
17339 };
17340
17341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17343 if (!SWIG_IsOK(res1)) {
17344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17345 }
17346 arg1 = reinterpret_cast< wxSound * >(argp1);
17347 if (obj1) {
17348 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17349 if (!SWIG_IsOK(ecode2)) {
17350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17351 }
17352 arg2 = static_cast< unsigned int >(val2);
17353 }
17354 {
17355 if (!wxPyCheckForApp()) SWIG_fail;
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = (bool)((wxSound const *)arg1)->Play(arg2);
17358 wxPyEndAllowThreads(__tstate);
17359 if (PyErr_Occurred()) SWIG_fail;
17360 }
17361 {
17362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17363 }
17364 return resultobj;
17365 fail:
17366 return NULL;
17367 }
17368
17369
17370 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17371 PyObject *resultobj = 0;
17372 wxString *arg1 = 0 ;
17373 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17374 bool result;
17375 bool temp1 = false ;
17376 unsigned int val2 ;
17377 int ecode2 = 0 ;
17378 PyObject * obj0 = 0 ;
17379 PyObject * obj1 = 0 ;
17380 char * kwnames[] = {
17381 (char *) "filename",(char *) "flags", NULL
17382 };
17383
17384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17385 {
17386 arg1 = wxString_in_helper(obj0);
17387 if (arg1 == NULL) SWIG_fail;
17388 temp1 = true;
17389 }
17390 if (obj1) {
17391 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17392 if (!SWIG_IsOK(ecode2)) {
17393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17394 }
17395 arg2 = static_cast< unsigned int >(val2);
17396 }
17397 {
17398 if (!wxPyCheckForApp()) SWIG_fail;
17399 PyThreadState* __tstate = wxPyBeginAllowThreads();
17400 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17401 wxPyEndAllowThreads(__tstate);
17402 if (PyErr_Occurred()) SWIG_fail;
17403 }
17404 {
17405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17406 }
17407 {
17408 if (temp1)
17409 delete arg1;
17410 }
17411 return resultobj;
17412 fail:
17413 {
17414 if (temp1)
17415 delete arg1;
17416 }
17417 return NULL;
17418 }
17419
17420
17421 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17422 PyObject *resultobj = 0;
17423
17424 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17425 {
17426 if (!wxPyCheckForApp()) SWIG_fail;
17427 PyThreadState* __tstate = wxPyBeginAllowThreads();
17428 wxSound::Stop();
17429 wxPyEndAllowThreads(__tstate);
17430 if (PyErr_Occurred()) SWIG_fail;
17431 }
17432 resultobj = SWIG_Py_Void();
17433 return resultobj;
17434 fail:
17435 return NULL;
17436 }
17437
17438
17439 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 PyObject *obj;
17441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17442 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17443 return SWIG_Py_Void();
17444 }
17445
17446 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17447 return SWIG_Python_InitShadowInstance(args);
17448 }
17449
17450 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17451 PyObject *resultobj = 0;
17452 wxString *arg1 = 0 ;
17453 wxString *arg2 = 0 ;
17454 wxString *arg3 = 0 ;
17455 wxString *arg4 = 0 ;
17456 wxFileTypeInfo *result = 0 ;
17457 bool temp1 = false ;
17458 bool temp2 = false ;
17459 bool temp3 = false ;
17460 bool temp4 = false ;
17461 PyObject * obj0 = 0 ;
17462 PyObject * obj1 = 0 ;
17463 PyObject * obj2 = 0 ;
17464 PyObject * obj3 = 0 ;
17465 char * kwnames[] = {
17466 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17467 };
17468
17469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17470 {
17471 arg1 = wxString_in_helper(obj0);
17472 if (arg1 == NULL) SWIG_fail;
17473 temp1 = true;
17474 }
17475 {
17476 arg2 = wxString_in_helper(obj1);
17477 if (arg2 == NULL) SWIG_fail;
17478 temp2 = true;
17479 }
17480 {
17481 arg3 = wxString_in_helper(obj2);
17482 if (arg3 == NULL) SWIG_fail;
17483 temp3 = true;
17484 }
17485 {
17486 arg4 = wxString_in_helper(obj3);
17487 if (arg4 == NULL) SWIG_fail;
17488 temp4 = true;
17489 }
17490 {
17491 PyThreadState* __tstate = wxPyBeginAllowThreads();
17492 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17493 wxPyEndAllowThreads(__tstate);
17494 if (PyErr_Occurred()) SWIG_fail;
17495 }
17496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17497 {
17498 if (temp1)
17499 delete arg1;
17500 }
17501 {
17502 if (temp2)
17503 delete arg2;
17504 }
17505 {
17506 if (temp3)
17507 delete arg3;
17508 }
17509 {
17510 if (temp4)
17511 delete arg4;
17512 }
17513 return resultobj;
17514 fail:
17515 {
17516 if (temp1)
17517 delete arg1;
17518 }
17519 {
17520 if (temp2)
17521 delete arg2;
17522 }
17523 {
17524 if (temp3)
17525 delete arg3;
17526 }
17527 {
17528 if (temp4)
17529 delete arg4;
17530 }
17531 return NULL;
17532 }
17533
17534
17535 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17536 PyObject *resultobj = 0;
17537 wxArrayString *arg1 = 0 ;
17538 wxFileTypeInfo *result = 0 ;
17539 bool temp1 = false ;
17540 PyObject * obj0 = 0 ;
17541 char * kwnames[] = {
17542 (char *) "sArray", NULL
17543 };
17544
17545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17546 {
17547 if (! PySequence_Check(obj0)) {
17548 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17549 SWIG_fail;
17550 }
17551 arg1 = new wxArrayString;
17552 temp1 = true;
17553 int i, len=PySequence_Length(obj0);
17554 for (i=0; i<len; i++) {
17555 PyObject* item = PySequence_GetItem(obj0, i);
17556 wxString* s = wxString_in_helper(item);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 arg1->Add(*s);
17559 delete s;
17560 Py_DECREF(item);
17561 }
17562 }
17563 {
17564 PyThreadState* __tstate = wxPyBeginAllowThreads();
17565 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17566 wxPyEndAllowThreads(__tstate);
17567 if (PyErr_Occurred()) SWIG_fail;
17568 }
17569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17570 {
17571 if (temp1) delete arg1;
17572 }
17573 return resultobj;
17574 fail:
17575 {
17576 if (temp1) delete arg1;
17577 }
17578 return NULL;
17579 }
17580
17581
17582 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17583 PyObject *resultobj = 0;
17584 wxFileTypeInfo *result = 0 ;
17585
17586 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17587 {
17588 PyThreadState* __tstate = wxPyBeginAllowThreads();
17589 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17590 wxPyEndAllowThreads(__tstate);
17591 if (PyErr_Occurred()) SWIG_fail;
17592 }
17593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17594 return resultobj;
17595 fail:
17596 return NULL;
17597 }
17598
17599
17600 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17601 PyObject *resultobj = 0;
17602 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17603 bool result;
17604 void *argp1 = 0 ;
17605 int res1 = 0 ;
17606 PyObject *swig_obj[1] ;
17607
17608 if (!args) SWIG_fail;
17609 swig_obj[0] = args;
17610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17611 if (!SWIG_IsOK(res1)) {
17612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17613 }
17614 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17615 {
17616 PyThreadState* __tstate = wxPyBeginAllowThreads();
17617 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17618 wxPyEndAllowThreads(__tstate);
17619 if (PyErr_Occurred()) SWIG_fail;
17620 }
17621 {
17622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17623 }
17624 return resultobj;
17625 fail:
17626 return NULL;
17627 }
17628
17629
17630 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17631 PyObject *resultobj = 0;
17632 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17633 wxString *arg2 = 0 ;
17634 int arg3 = (int) 0 ;
17635 void *argp1 = 0 ;
17636 int res1 = 0 ;
17637 bool temp2 = false ;
17638 int val3 ;
17639 int ecode3 = 0 ;
17640 PyObject * obj0 = 0 ;
17641 PyObject * obj1 = 0 ;
17642 PyObject * obj2 = 0 ;
17643 char * kwnames[] = {
17644 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17645 };
17646
17647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17649 if (!SWIG_IsOK(res1)) {
17650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17651 }
17652 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17653 {
17654 arg2 = wxString_in_helper(obj1);
17655 if (arg2 == NULL) SWIG_fail;
17656 temp2 = true;
17657 }
17658 if (obj2) {
17659 ecode3 = SWIG_AsVal_int(obj2, &val3);
17660 if (!SWIG_IsOK(ecode3)) {
17661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17662 }
17663 arg3 = static_cast< int >(val3);
17664 }
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 resultobj = SWIG_Py_Void();
17672 {
17673 if (temp2)
17674 delete arg2;
17675 }
17676 return resultobj;
17677 fail:
17678 {
17679 if (temp2)
17680 delete arg2;
17681 }
17682 return NULL;
17683 }
17684
17685
17686 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17687 PyObject *resultobj = 0;
17688 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17689 wxString *arg2 = 0 ;
17690 void *argp1 = 0 ;
17691 int res1 = 0 ;
17692 bool temp2 = false ;
17693 PyObject * obj0 = 0 ;
17694 PyObject * obj1 = 0 ;
17695 char * kwnames[] = {
17696 (char *) "self",(char *) "shortDesc", NULL
17697 };
17698
17699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17701 if (!SWIG_IsOK(res1)) {
17702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17703 }
17704 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17705 {
17706 arg2 = wxString_in_helper(obj1);
17707 if (arg2 == NULL) SWIG_fail;
17708 temp2 = true;
17709 }
17710 {
17711 PyThreadState* __tstate = wxPyBeginAllowThreads();
17712 (arg1)->SetShortDesc((wxString const &)*arg2);
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_Py_Void();
17717 {
17718 if (temp2)
17719 delete arg2;
17720 }
17721 return resultobj;
17722 fail:
17723 {
17724 if (temp2)
17725 delete arg2;
17726 }
17727 return NULL;
17728 }
17729
17730
17731 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17732 PyObject *resultobj = 0;
17733 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17734 wxString *result = 0 ;
17735 void *argp1 = 0 ;
17736 int res1 = 0 ;
17737 PyObject *swig_obj[1] ;
17738
17739 if (!args) SWIG_fail;
17740 swig_obj[0] = args;
17741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17742 if (!SWIG_IsOK(res1)) {
17743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17744 }
17745 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17746 {
17747 PyThreadState* __tstate = wxPyBeginAllowThreads();
17748 {
17749 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17750 result = (wxString *) &_result_ref;
17751 }
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 {
17756 #if wxUSE_UNICODE
17757 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17758 #else
17759 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17760 #endif
17761 }
17762 return resultobj;
17763 fail:
17764 return NULL;
17765 }
17766
17767
17768 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17769 PyObject *resultobj = 0;
17770 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17771 wxString *result = 0 ;
17772 void *argp1 = 0 ;
17773 int res1 = 0 ;
17774 PyObject *swig_obj[1] ;
17775
17776 if (!args) SWIG_fail;
17777 swig_obj[0] = args;
17778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17779 if (!SWIG_IsOK(res1)) {
17780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17781 }
17782 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17783 {
17784 PyThreadState* __tstate = wxPyBeginAllowThreads();
17785 {
17786 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17787 result = (wxString *) &_result_ref;
17788 }
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 {
17793 #if wxUSE_UNICODE
17794 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17795 #else
17796 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17797 #endif
17798 }
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17806 PyObject *resultobj = 0;
17807 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17808 wxString *result = 0 ;
17809 void *argp1 = 0 ;
17810 int res1 = 0 ;
17811 PyObject *swig_obj[1] ;
17812
17813 if (!args) SWIG_fail;
17814 swig_obj[0] = args;
17815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17816 if (!SWIG_IsOK(res1)) {
17817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17818 }
17819 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17820 {
17821 PyThreadState* __tstate = wxPyBeginAllowThreads();
17822 {
17823 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17824 result = (wxString *) &_result_ref;
17825 }
17826 wxPyEndAllowThreads(__tstate);
17827 if (PyErr_Occurred()) SWIG_fail;
17828 }
17829 {
17830 #if wxUSE_UNICODE
17831 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17832 #else
17833 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17834 #endif
17835 }
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17843 PyObject *resultobj = 0;
17844 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17845 wxString *result = 0 ;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17855 }
17856 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 {
17860 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17861 result = (wxString *) &_result_ref;
17862 }
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 {
17867 #if wxUSE_UNICODE
17868 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17869 #else
17870 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17871 #endif
17872 }
17873 return resultobj;
17874 fail:
17875 return NULL;
17876 }
17877
17878
17879 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17880 PyObject *resultobj = 0;
17881 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17882 wxString *result = 0 ;
17883 void *argp1 = 0 ;
17884 int res1 = 0 ;
17885 PyObject *swig_obj[1] ;
17886
17887 if (!args) SWIG_fail;
17888 swig_obj[0] = args;
17889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17890 if (!SWIG_IsOK(res1)) {
17891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17892 }
17893 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17894 {
17895 PyThreadState* __tstate = wxPyBeginAllowThreads();
17896 {
17897 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17898 result = (wxString *) &_result_ref;
17899 }
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 {
17904 #if wxUSE_UNICODE
17905 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17906 #else
17907 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17908 #endif
17909 }
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17917 PyObject *resultobj = 0;
17918 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17919 wxArrayString *result = 0 ;
17920 void *argp1 = 0 ;
17921 int res1 = 0 ;
17922 PyObject *swig_obj[1] ;
17923
17924 if (!args) SWIG_fail;
17925 swig_obj[0] = args;
17926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17927 if (!SWIG_IsOK(res1)) {
17928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17929 }
17930 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 {
17934 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17935 result = (wxArrayString *) &_result_ref;
17936 }
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 {
17941 resultobj = wxArrayString2PyList_helper(*result);
17942 }
17943 return resultobj;
17944 fail:
17945 return NULL;
17946 }
17947
17948
17949 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17950 PyObject *resultobj = 0;
17951 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17952 size_t result;
17953 void *argp1 = 0 ;
17954 int res1 = 0 ;
17955 PyObject *swig_obj[1] ;
17956
17957 if (!args) SWIG_fail;
17958 swig_obj[0] = args;
17959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17960 if (!SWIG_IsOK(res1)) {
17961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17962 }
17963 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17964 {
17965 PyThreadState* __tstate = wxPyBeginAllowThreads();
17966 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17967 wxPyEndAllowThreads(__tstate);
17968 if (PyErr_Occurred()) SWIG_fail;
17969 }
17970 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17971 return resultobj;
17972 fail:
17973 return NULL;
17974 }
17975
17976
17977 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17978 PyObject *resultobj = 0;
17979 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17980 wxString *result = 0 ;
17981 void *argp1 = 0 ;
17982 int res1 = 0 ;
17983 PyObject *swig_obj[1] ;
17984
17985 if (!args) SWIG_fail;
17986 swig_obj[0] = args;
17987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17988 if (!SWIG_IsOK(res1)) {
17989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17990 }
17991 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17992 {
17993 PyThreadState* __tstate = wxPyBeginAllowThreads();
17994 {
17995 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17996 result = (wxString *) &_result_ref;
17997 }
17998 wxPyEndAllowThreads(__tstate);
17999 if (PyErr_Occurred()) SWIG_fail;
18000 }
18001 {
18002 #if wxUSE_UNICODE
18003 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18004 #else
18005 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18006 #endif
18007 }
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18015 PyObject *resultobj = 0;
18016 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18017 int result;
18018 void *argp1 = 0 ;
18019 int res1 = 0 ;
18020 PyObject *swig_obj[1] ;
18021
18022 if (!args) SWIG_fail;
18023 swig_obj[0] = args;
18024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18025 if (!SWIG_IsOK(res1)) {
18026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18027 }
18028 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18029 {
18030 PyThreadState* __tstate = wxPyBeginAllowThreads();
18031 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18032 wxPyEndAllowThreads(__tstate);
18033 if (PyErr_Occurred()) SWIG_fail;
18034 }
18035 resultobj = SWIG_From_int(static_cast< int >(result));
18036 return resultobj;
18037 fail:
18038 return NULL;
18039 }
18040
18041
18042 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18043 PyObject *obj;
18044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18045 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18046 return SWIG_Py_Void();
18047 }
18048
18049 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18050 return SWIG_Python_InitShadowInstance(args);
18051 }
18052
18053 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj = 0;
18055 wxFileTypeInfo *arg1 = 0 ;
18056 wxFileType *result = 0 ;
18057 void *argp1 = 0 ;
18058 int res1 = 0 ;
18059 PyObject * obj0 = 0 ;
18060 char * kwnames[] = {
18061 (char *) "ftInfo", NULL
18062 };
18063
18064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18065 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18066 if (!SWIG_IsOK(res1)) {
18067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18068 }
18069 if (!argp1) {
18070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18071 }
18072 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18076 wxPyEndAllowThreads(__tstate);
18077 if (PyErr_Occurred()) SWIG_fail;
18078 }
18079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 PyObject *resultobj = 0;
18088 wxFileType *arg1 = (wxFileType *) 0 ;
18089 void *argp1 = 0 ;
18090 int res1 = 0 ;
18091 PyObject *swig_obj[1] ;
18092
18093 if (!args) SWIG_fail;
18094 swig_obj[0] = args;
18095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18096 if (!SWIG_IsOK(res1)) {
18097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18098 }
18099 arg1 = reinterpret_cast< wxFileType * >(argp1);
18100 {
18101 PyThreadState* __tstate = wxPyBeginAllowThreads();
18102 delete arg1;
18103
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 resultobj = SWIG_Py_Void();
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18115 PyObject *resultobj = 0;
18116 wxFileType *arg1 = (wxFileType *) 0 ;
18117 PyObject *result = 0 ;
18118 void *argp1 = 0 ;
18119 int res1 = 0 ;
18120 PyObject *swig_obj[1] ;
18121
18122 if (!args) SWIG_fail;
18123 swig_obj[0] = args;
18124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18125 if (!SWIG_IsOK(res1)) {
18126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18127 }
18128 arg1 = reinterpret_cast< wxFileType * >(argp1);
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (PyObject *)wxFileType_GetMimeType(arg1);
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 resultobj = result;
18136 return resultobj;
18137 fail:
18138 return NULL;
18139 }
18140
18141
18142 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18143 PyObject *resultobj = 0;
18144 wxFileType *arg1 = (wxFileType *) 0 ;
18145 PyObject *result = 0 ;
18146 void *argp1 = 0 ;
18147 int res1 = 0 ;
18148 PyObject *swig_obj[1] ;
18149
18150 if (!args) SWIG_fail;
18151 swig_obj[0] = args;
18152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18153 if (!SWIG_IsOK(res1)) {
18154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18155 }
18156 arg1 = reinterpret_cast< wxFileType * >(argp1);
18157 {
18158 PyThreadState* __tstate = wxPyBeginAllowThreads();
18159 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18160 wxPyEndAllowThreads(__tstate);
18161 if (PyErr_Occurred()) SWIG_fail;
18162 }
18163 resultobj = result;
18164 return resultobj;
18165 fail:
18166 return NULL;
18167 }
18168
18169
18170 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18171 PyObject *resultobj = 0;
18172 wxFileType *arg1 = (wxFileType *) 0 ;
18173 PyObject *result = 0 ;
18174 void *argp1 = 0 ;
18175 int res1 = 0 ;
18176 PyObject *swig_obj[1] ;
18177
18178 if (!args) SWIG_fail;
18179 swig_obj[0] = args;
18180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18181 if (!SWIG_IsOK(res1)) {
18182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18183 }
18184 arg1 = reinterpret_cast< wxFileType * >(argp1);
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 result = (PyObject *)wxFileType_GetExtensions(arg1);
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 resultobj = result;
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *resultobj = 0;
18200 wxFileType *arg1 = (wxFileType *) 0 ;
18201 wxIcon *result = 0 ;
18202 void *argp1 = 0 ;
18203 int res1 = 0 ;
18204 PyObject *swig_obj[1] ;
18205
18206 if (!args) SWIG_fail;
18207 swig_obj[0] = args;
18208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18209 if (!SWIG_IsOK(res1)) {
18210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18211 }
18212 arg1 = reinterpret_cast< wxFileType * >(argp1);
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 result = (wxIcon *)wxFileType_GetIcon(arg1);
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18227 PyObject *resultobj = 0;
18228 wxFileType *arg1 = (wxFileType *) 0 ;
18229 PyObject *result = 0 ;
18230 void *argp1 = 0 ;
18231 int res1 = 0 ;
18232 PyObject *swig_obj[1] ;
18233
18234 if (!args) SWIG_fail;
18235 swig_obj[0] = args;
18236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18237 if (!SWIG_IsOK(res1)) {
18238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18239 }
18240 arg1 = reinterpret_cast< wxFileType * >(argp1);
18241 {
18242 PyThreadState* __tstate = wxPyBeginAllowThreads();
18243 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 resultobj = result;
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18255 PyObject *resultobj = 0;
18256 wxFileType *arg1 = (wxFileType *) 0 ;
18257 PyObject *result = 0 ;
18258 void *argp1 = 0 ;
18259 int res1 = 0 ;
18260 PyObject *swig_obj[1] ;
18261
18262 if (!args) SWIG_fail;
18263 swig_obj[0] = args;
18264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18265 if (!SWIG_IsOK(res1)) {
18266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18267 }
18268 arg1 = reinterpret_cast< wxFileType * >(argp1);
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 result = (PyObject *)wxFileType_GetDescription(arg1);
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 resultobj = result;
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj = 0;
18284 wxFileType *arg1 = (wxFileType *) 0 ;
18285 wxString *arg2 = 0 ;
18286 wxString const &arg3_defvalue = wxPyEmptyString ;
18287 wxString *arg3 = (wxString *) &arg3_defvalue ;
18288 PyObject *result = 0 ;
18289 void *argp1 = 0 ;
18290 int res1 = 0 ;
18291 bool temp2 = false ;
18292 bool temp3 = false ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 PyObject * obj2 = 0 ;
18296 char * kwnames[] = {
18297 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18298 };
18299
18300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18302 if (!SWIG_IsOK(res1)) {
18303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18304 }
18305 arg1 = reinterpret_cast< wxFileType * >(argp1);
18306 {
18307 arg2 = wxString_in_helper(obj1);
18308 if (arg2 == NULL) SWIG_fail;
18309 temp2 = true;
18310 }
18311 if (obj2) {
18312 {
18313 arg3 = wxString_in_helper(obj2);
18314 if (arg3 == NULL) SWIG_fail;
18315 temp3 = true;
18316 }
18317 }
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 resultobj = result;
18325 {
18326 if (temp2)
18327 delete arg2;
18328 }
18329 {
18330 if (temp3)
18331 delete arg3;
18332 }
18333 return resultobj;
18334 fail:
18335 {
18336 if (temp2)
18337 delete arg2;
18338 }
18339 {
18340 if (temp3)
18341 delete arg3;
18342 }
18343 return NULL;
18344 }
18345
18346
18347 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj = 0;
18349 wxFileType *arg1 = (wxFileType *) 0 ;
18350 wxString *arg2 = 0 ;
18351 wxString const &arg3_defvalue = wxPyEmptyString ;
18352 wxString *arg3 = (wxString *) &arg3_defvalue ;
18353 PyObject *result = 0 ;
18354 void *argp1 = 0 ;
18355 int res1 = 0 ;
18356 bool temp2 = false ;
18357 bool temp3 = false ;
18358 PyObject * obj0 = 0 ;
18359 PyObject * obj1 = 0 ;
18360 PyObject * obj2 = 0 ;
18361 char * kwnames[] = {
18362 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18363 };
18364
18365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18367 if (!SWIG_IsOK(res1)) {
18368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18369 }
18370 arg1 = reinterpret_cast< wxFileType * >(argp1);
18371 {
18372 arg2 = wxString_in_helper(obj1);
18373 if (arg2 == NULL) SWIG_fail;
18374 temp2 = true;
18375 }
18376 if (obj2) {
18377 {
18378 arg3 = wxString_in_helper(obj2);
18379 if (arg3 == NULL) SWIG_fail;
18380 temp3 = true;
18381 }
18382 }
18383 {
18384 PyThreadState* __tstate = wxPyBeginAllowThreads();
18385 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18386 wxPyEndAllowThreads(__tstate);
18387 if (PyErr_Occurred()) SWIG_fail;
18388 }
18389 resultobj = result;
18390 {
18391 if (temp2)
18392 delete arg2;
18393 }
18394 {
18395 if (temp3)
18396 delete arg3;
18397 }
18398 return resultobj;
18399 fail:
18400 {
18401 if (temp2)
18402 delete arg2;
18403 }
18404 {
18405 if (temp3)
18406 delete arg3;
18407 }
18408 return NULL;
18409 }
18410
18411
18412 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18413 PyObject *resultobj = 0;
18414 wxFileType *arg1 = (wxFileType *) 0 ;
18415 wxString *arg2 = 0 ;
18416 wxString const &arg3_defvalue = wxPyEmptyString ;
18417 wxString *arg3 = (wxString *) &arg3_defvalue ;
18418 PyObject *result = 0 ;
18419 void *argp1 = 0 ;
18420 int res1 = 0 ;
18421 bool temp2 = false ;
18422 bool temp3 = false ;
18423 PyObject * obj0 = 0 ;
18424 PyObject * obj1 = 0 ;
18425 PyObject * obj2 = 0 ;
18426 char * kwnames[] = {
18427 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18428 };
18429
18430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18432 if (!SWIG_IsOK(res1)) {
18433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18434 }
18435 arg1 = reinterpret_cast< wxFileType * >(argp1);
18436 {
18437 arg2 = wxString_in_helper(obj1);
18438 if (arg2 == NULL) SWIG_fail;
18439 temp2 = true;
18440 }
18441 if (obj2) {
18442 {
18443 arg3 = wxString_in_helper(obj2);
18444 if (arg3 == NULL) SWIG_fail;
18445 temp3 = true;
18446 }
18447 }
18448 {
18449 PyThreadState* __tstate = wxPyBeginAllowThreads();
18450 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18451 wxPyEndAllowThreads(__tstate);
18452 if (PyErr_Occurred()) SWIG_fail;
18453 }
18454 resultobj = result;
18455 {
18456 if (temp2)
18457 delete arg2;
18458 }
18459 {
18460 if (temp3)
18461 delete arg3;
18462 }
18463 return resultobj;
18464 fail:
18465 {
18466 if (temp2)
18467 delete arg2;
18468 }
18469 {
18470 if (temp3)
18471 delete arg3;
18472 }
18473 return NULL;
18474 }
18475
18476
18477 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18478 PyObject *resultobj = 0;
18479 wxFileType *arg1 = (wxFileType *) 0 ;
18480 wxString *arg2 = 0 ;
18481 wxString *arg3 = 0 ;
18482 bool arg4 = (bool) true ;
18483 bool result;
18484 void *argp1 = 0 ;
18485 int res1 = 0 ;
18486 bool temp2 = false ;
18487 bool temp3 = false ;
18488 bool val4 ;
18489 int ecode4 = 0 ;
18490 PyObject * obj0 = 0 ;
18491 PyObject * obj1 = 0 ;
18492 PyObject * obj2 = 0 ;
18493 PyObject * obj3 = 0 ;
18494 char * kwnames[] = {
18495 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18496 };
18497
18498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18500 if (!SWIG_IsOK(res1)) {
18501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18502 }
18503 arg1 = reinterpret_cast< wxFileType * >(argp1);
18504 {
18505 arg2 = wxString_in_helper(obj1);
18506 if (arg2 == NULL) SWIG_fail;
18507 temp2 = true;
18508 }
18509 {
18510 arg3 = wxString_in_helper(obj2);
18511 if (arg3 == NULL) SWIG_fail;
18512 temp3 = true;
18513 }
18514 if (obj3) {
18515 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18516 if (!SWIG_IsOK(ecode4)) {
18517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18518 }
18519 arg4 = static_cast< bool >(val4);
18520 }
18521 {
18522 PyThreadState* __tstate = wxPyBeginAllowThreads();
18523 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18524 wxPyEndAllowThreads(__tstate);
18525 if (PyErr_Occurred()) SWIG_fail;
18526 }
18527 {
18528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18529 }
18530 {
18531 if (temp2)
18532 delete arg2;
18533 }
18534 {
18535 if (temp3)
18536 delete arg3;
18537 }
18538 return resultobj;
18539 fail:
18540 {
18541 if (temp2)
18542 delete arg2;
18543 }
18544 {
18545 if (temp3)
18546 delete arg3;
18547 }
18548 return NULL;
18549 }
18550
18551
18552 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18553 PyObject *resultobj = 0;
18554 wxFileType *arg1 = (wxFileType *) 0 ;
18555 wxString const &arg2_defvalue = wxPyEmptyString ;
18556 wxString *arg2 = (wxString *) &arg2_defvalue ;
18557 int arg3 = (int) 0 ;
18558 bool result;
18559 void *argp1 = 0 ;
18560 int res1 = 0 ;
18561 bool temp2 = false ;
18562 int val3 ;
18563 int ecode3 = 0 ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 PyObject * obj2 = 0 ;
18567 char * kwnames[] = {
18568 (char *) "self",(char *) "cmd",(char *) "index", NULL
18569 };
18570
18571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18573 if (!SWIG_IsOK(res1)) {
18574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18575 }
18576 arg1 = reinterpret_cast< wxFileType * >(argp1);
18577 if (obj1) {
18578 {
18579 arg2 = wxString_in_helper(obj1);
18580 if (arg2 == NULL) SWIG_fail;
18581 temp2 = true;
18582 }
18583 }
18584 if (obj2) {
18585 ecode3 = SWIG_AsVal_int(obj2, &val3);
18586 if (!SWIG_IsOK(ecode3)) {
18587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18588 }
18589 arg3 = static_cast< int >(val3);
18590 }
18591 {
18592 PyThreadState* __tstate = wxPyBeginAllowThreads();
18593 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18594 wxPyEndAllowThreads(__tstate);
18595 if (PyErr_Occurred()) SWIG_fail;
18596 }
18597 {
18598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18599 }
18600 {
18601 if (temp2)
18602 delete arg2;
18603 }
18604 return resultobj;
18605 fail:
18606 {
18607 if (temp2)
18608 delete arg2;
18609 }
18610 return NULL;
18611 }
18612
18613
18614 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18615 PyObject *resultobj = 0;
18616 wxFileType *arg1 = (wxFileType *) 0 ;
18617 bool result;
18618 void *argp1 = 0 ;
18619 int res1 = 0 ;
18620 PyObject *swig_obj[1] ;
18621
18622 if (!args) SWIG_fail;
18623 swig_obj[0] = args;
18624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18625 if (!SWIG_IsOK(res1)) {
18626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18627 }
18628 arg1 = reinterpret_cast< wxFileType * >(argp1);
18629 {
18630 PyThreadState* __tstate = wxPyBeginAllowThreads();
18631 result = (bool)(arg1)->Unassociate();
18632 wxPyEndAllowThreads(__tstate);
18633 if (PyErr_Occurred()) SWIG_fail;
18634 }
18635 {
18636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18637 }
18638 return resultobj;
18639 fail:
18640 return NULL;
18641 }
18642
18643
18644 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18645 PyObject *resultobj = 0;
18646 wxString *arg1 = 0 ;
18647 wxString *arg2 = 0 ;
18648 wxString const &arg3_defvalue = wxPyEmptyString ;
18649 wxString *arg3 = (wxString *) &arg3_defvalue ;
18650 wxString result;
18651 bool temp1 = false ;
18652 bool temp2 = false ;
18653 bool temp3 = false ;
18654 PyObject * obj0 = 0 ;
18655 PyObject * obj1 = 0 ;
18656 PyObject * obj2 = 0 ;
18657 char * kwnames[] = {
18658 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18659 };
18660
18661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18662 {
18663 arg1 = wxString_in_helper(obj0);
18664 if (arg1 == NULL) SWIG_fail;
18665 temp1 = true;
18666 }
18667 {
18668 arg2 = wxString_in_helper(obj1);
18669 if (arg2 == NULL) SWIG_fail;
18670 temp2 = true;
18671 }
18672 if (obj2) {
18673 {
18674 arg3 = wxString_in_helper(obj2);
18675 if (arg3 == NULL) SWIG_fail;
18676 temp3 = true;
18677 }
18678 }
18679 {
18680 PyThreadState* __tstate = wxPyBeginAllowThreads();
18681 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 {
18686 #if wxUSE_UNICODE
18687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18688 #else
18689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18690 #endif
18691 }
18692 {
18693 if (temp1)
18694 delete arg1;
18695 }
18696 {
18697 if (temp2)
18698 delete arg2;
18699 }
18700 {
18701 if (temp3)
18702 delete arg3;
18703 }
18704 return resultobj;
18705 fail:
18706 {
18707 if (temp1)
18708 delete arg1;
18709 }
18710 {
18711 if (temp2)
18712 delete arg2;
18713 }
18714 {
18715 if (temp3)
18716 delete arg3;
18717 }
18718 return NULL;
18719 }
18720
18721
18722 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18723 PyObject *obj;
18724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18725 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18726 return SWIG_Py_Void();
18727 }
18728
18729 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18730 return SWIG_Python_InitShadowInstance(args);
18731 }
18732
18733 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18734 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18735 return 1;
18736 }
18737
18738
18739 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18740 PyObject *pyobj = 0;
18741
18742 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18743 return pyobj;
18744 }
18745
18746
18747 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18748 PyObject *resultobj = 0;
18749 wxString *arg1 = 0 ;
18750 wxString *arg2 = 0 ;
18751 bool result;
18752 bool temp1 = false ;
18753 bool temp2 = false ;
18754 PyObject * obj0 = 0 ;
18755 PyObject * obj1 = 0 ;
18756 char * kwnames[] = {
18757 (char *) "mimeType",(char *) "wildcard", NULL
18758 };
18759
18760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18761 {
18762 arg1 = wxString_in_helper(obj0);
18763 if (arg1 == NULL) SWIG_fail;
18764 temp1 = true;
18765 }
18766 {
18767 arg2 = wxString_in_helper(obj1);
18768 if (arg2 == NULL) SWIG_fail;
18769 temp2 = true;
18770 }
18771 {
18772 PyThreadState* __tstate = wxPyBeginAllowThreads();
18773 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18774 wxPyEndAllowThreads(__tstate);
18775 if (PyErr_Occurred()) SWIG_fail;
18776 }
18777 {
18778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18779 }
18780 {
18781 if (temp1)
18782 delete arg1;
18783 }
18784 {
18785 if (temp2)
18786 delete arg2;
18787 }
18788 return resultobj;
18789 fail:
18790 {
18791 if (temp1)
18792 delete arg1;
18793 }
18794 {
18795 if (temp2)
18796 delete arg2;
18797 }
18798 return NULL;
18799 }
18800
18801
18802 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18803 PyObject *resultobj = 0;
18804 wxMimeTypesManager *result = 0 ;
18805
18806 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18807 {
18808 PyThreadState* __tstate = wxPyBeginAllowThreads();
18809 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18810 wxPyEndAllowThreads(__tstate);
18811 if (PyErr_Occurred()) SWIG_fail;
18812 }
18813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18814 return resultobj;
18815 fail:
18816 return NULL;
18817 }
18818
18819
18820 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18821 PyObject *resultobj = 0;
18822 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18823 int arg2 = (int) wxMAILCAP_ALL ;
18824 wxString const &arg3_defvalue = wxPyEmptyString ;
18825 wxString *arg3 = (wxString *) &arg3_defvalue ;
18826 void *argp1 = 0 ;
18827 int res1 = 0 ;
18828 int val2 ;
18829 int ecode2 = 0 ;
18830 bool temp3 = false ;
18831 PyObject * obj0 = 0 ;
18832 PyObject * obj1 = 0 ;
18833 PyObject * obj2 = 0 ;
18834 char * kwnames[] = {
18835 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18836 };
18837
18838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18840 if (!SWIG_IsOK(res1)) {
18841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18842 }
18843 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18844 if (obj1) {
18845 ecode2 = SWIG_AsVal_int(obj1, &val2);
18846 if (!SWIG_IsOK(ecode2)) {
18847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18848 }
18849 arg2 = static_cast< int >(val2);
18850 }
18851 if (obj2) {
18852 {
18853 arg3 = wxString_in_helper(obj2);
18854 if (arg3 == NULL) SWIG_fail;
18855 temp3 = true;
18856 }
18857 }
18858 {
18859 PyThreadState* __tstate = wxPyBeginAllowThreads();
18860 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18861 wxPyEndAllowThreads(__tstate);
18862 if (PyErr_Occurred()) SWIG_fail;
18863 }
18864 resultobj = SWIG_Py_Void();
18865 {
18866 if (temp3)
18867 delete arg3;
18868 }
18869 return resultobj;
18870 fail:
18871 {
18872 if (temp3)
18873 delete arg3;
18874 }
18875 return NULL;
18876 }
18877
18878
18879 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18880 PyObject *resultobj = 0;
18881 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18882 void *argp1 = 0 ;
18883 int res1 = 0 ;
18884 PyObject *swig_obj[1] ;
18885
18886 if (!args) SWIG_fail;
18887 swig_obj[0] = args;
18888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18889 if (!SWIG_IsOK(res1)) {
18890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18891 }
18892 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 (arg1)->ClearData();
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 resultobj = SWIG_Py_Void();
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18907 PyObject *resultobj = 0;
18908 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18909 wxString *arg2 = 0 ;
18910 wxFileType *result = 0 ;
18911 void *argp1 = 0 ;
18912 int res1 = 0 ;
18913 bool temp2 = false ;
18914 PyObject * obj0 = 0 ;
18915 PyObject * obj1 = 0 ;
18916 char * kwnames[] = {
18917 (char *) "self",(char *) "ext", NULL
18918 };
18919
18920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18922 if (!SWIG_IsOK(res1)) {
18923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18924 }
18925 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18926 {
18927 arg2 = wxString_in_helper(obj1);
18928 if (arg2 == NULL) SWIG_fail;
18929 temp2 = true;
18930 }
18931 {
18932 PyThreadState* __tstate = wxPyBeginAllowThreads();
18933 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18934 wxPyEndAllowThreads(__tstate);
18935 if (PyErr_Occurred()) SWIG_fail;
18936 }
18937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18938 {
18939 if (temp2)
18940 delete arg2;
18941 }
18942 return resultobj;
18943 fail:
18944 {
18945 if (temp2)
18946 delete arg2;
18947 }
18948 return NULL;
18949 }
18950
18951
18952 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18953 PyObject *resultobj = 0;
18954 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18955 wxString *arg2 = 0 ;
18956 wxFileType *result = 0 ;
18957 void *argp1 = 0 ;
18958 int res1 = 0 ;
18959 bool temp2 = false ;
18960 PyObject * obj0 = 0 ;
18961 PyObject * obj1 = 0 ;
18962 char * kwnames[] = {
18963 (char *) "self",(char *) "mimeType", NULL
18964 };
18965
18966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18968 if (!SWIG_IsOK(res1)) {
18969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18970 }
18971 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18972 {
18973 arg2 = wxString_in_helper(obj1);
18974 if (arg2 == NULL) SWIG_fail;
18975 temp2 = true;
18976 }
18977 {
18978 PyThreadState* __tstate = wxPyBeginAllowThreads();
18979 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18980 wxPyEndAllowThreads(__tstate);
18981 if (PyErr_Occurred()) SWIG_fail;
18982 }
18983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18984 {
18985 if (temp2)
18986 delete arg2;
18987 }
18988 return resultobj;
18989 fail:
18990 {
18991 if (temp2)
18992 delete arg2;
18993 }
18994 return NULL;
18995 }
18996
18997
18998 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18999 PyObject *resultobj = 0;
19000 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19001 wxString *arg2 = 0 ;
19002 bool arg3 = (bool) false ;
19003 bool result;
19004 void *argp1 = 0 ;
19005 int res1 = 0 ;
19006 bool temp2 = false ;
19007 bool val3 ;
19008 int ecode3 = 0 ;
19009 PyObject * obj0 = 0 ;
19010 PyObject * obj1 = 0 ;
19011 PyObject * obj2 = 0 ;
19012 char * kwnames[] = {
19013 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19014 };
19015
19016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19018 if (!SWIG_IsOK(res1)) {
19019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19020 }
19021 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19022 {
19023 arg2 = wxString_in_helper(obj1);
19024 if (arg2 == NULL) SWIG_fail;
19025 temp2 = true;
19026 }
19027 if (obj2) {
19028 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19029 if (!SWIG_IsOK(ecode3)) {
19030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19031 }
19032 arg3 = static_cast< bool >(val3);
19033 }
19034 {
19035 PyThreadState* __tstate = wxPyBeginAllowThreads();
19036 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19037 wxPyEndAllowThreads(__tstate);
19038 if (PyErr_Occurred()) SWIG_fail;
19039 }
19040 {
19041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19042 }
19043 {
19044 if (temp2)
19045 delete arg2;
19046 }
19047 return resultobj;
19048 fail:
19049 {
19050 if (temp2)
19051 delete arg2;
19052 }
19053 return NULL;
19054 }
19055
19056
19057 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19058 PyObject *resultobj = 0;
19059 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19060 wxString *arg2 = 0 ;
19061 bool result;
19062 void *argp1 = 0 ;
19063 int res1 = 0 ;
19064 bool temp2 = false ;
19065 PyObject * obj0 = 0 ;
19066 PyObject * obj1 = 0 ;
19067 char * kwnames[] = {
19068 (char *) "self",(char *) "filename", NULL
19069 };
19070
19071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19073 if (!SWIG_IsOK(res1)) {
19074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19075 }
19076 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19077 {
19078 arg2 = wxString_in_helper(obj1);
19079 if (arg2 == NULL) SWIG_fail;
19080 temp2 = true;
19081 }
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 {
19089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19090 }
19091 {
19092 if (temp2)
19093 delete arg2;
19094 }
19095 return resultobj;
19096 fail:
19097 {
19098 if (temp2)
19099 delete arg2;
19100 }
19101 return NULL;
19102 }
19103
19104
19105 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19106 PyObject *resultobj = 0;
19107 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19108 PyObject *result = 0 ;
19109 void *argp1 = 0 ;
19110 int res1 = 0 ;
19111 PyObject *swig_obj[1] ;
19112
19113 if (!args) SWIG_fail;
19114 swig_obj[0] = args;
19115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19116 if (!SWIG_IsOK(res1)) {
19117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19118 }
19119 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19120 {
19121 PyThreadState* __tstate = wxPyBeginAllowThreads();
19122 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19123 wxPyEndAllowThreads(__tstate);
19124 if (PyErr_Occurred()) SWIG_fail;
19125 }
19126 resultobj = result;
19127 return resultobj;
19128 fail:
19129 return NULL;
19130 }
19131
19132
19133 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19134 PyObject *resultobj = 0;
19135 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19136 wxFileTypeInfo *arg2 = 0 ;
19137 void *argp1 = 0 ;
19138 int res1 = 0 ;
19139 void *argp2 = 0 ;
19140 int res2 = 0 ;
19141 PyObject * obj0 = 0 ;
19142 PyObject * obj1 = 0 ;
19143 char * kwnames[] = {
19144 (char *) "self",(char *) "ft", NULL
19145 };
19146
19147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19149 if (!SWIG_IsOK(res1)) {
19150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19151 }
19152 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19154 if (!SWIG_IsOK(res2)) {
19155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19156 }
19157 if (!argp2) {
19158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19159 }
19160 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19161 {
19162 PyThreadState* __tstate = wxPyBeginAllowThreads();
19163 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 resultobj = SWIG_Py_Void();
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19175 PyObject *resultobj = 0;
19176 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19177 wxFileTypeInfo *arg2 = 0 ;
19178 wxFileType *result = 0 ;
19179 void *argp1 = 0 ;
19180 int res1 = 0 ;
19181 void *argp2 = 0 ;
19182 int res2 = 0 ;
19183 PyObject * obj0 = 0 ;
19184 PyObject * obj1 = 0 ;
19185 char * kwnames[] = {
19186 (char *) "self",(char *) "ftInfo", NULL
19187 };
19188
19189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19191 if (!SWIG_IsOK(res1)) {
19192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19193 }
19194 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19196 if (!SWIG_IsOK(res2)) {
19197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19198 }
19199 if (!argp2) {
19200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19201 }
19202 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19203 {
19204 PyThreadState* __tstate = wxPyBeginAllowThreads();
19205 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19206 wxPyEndAllowThreads(__tstate);
19207 if (PyErr_Occurred()) SWIG_fail;
19208 }
19209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19210 return resultobj;
19211 fail:
19212 return NULL;
19213 }
19214
19215
19216 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19217 PyObject *resultobj = 0;
19218 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19219 wxFileType *arg2 = (wxFileType *) 0 ;
19220 bool result;
19221 void *argp1 = 0 ;
19222 int res1 = 0 ;
19223 void *argp2 = 0 ;
19224 int res2 = 0 ;
19225 PyObject * obj0 = 0 ;
19226 PyObject * obj1 = 0 ;
19227 char * kwnames[] = {
19228 (char *) "self",(char *) "ft", NULL
19229 };
19230
19231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19233 if (!SWIG_IsOK(res1)) {
19234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19235 }
19236 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19237 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19238 if (!SWIG_IsOK(res2)) {
19239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19240 }
19241 arg2 = reinterpret_cast< wxFileType * >(argp2);
19242 {
19243 PyThreadState* __tstate = wxPyBeginAllowThreads();
19244 result = (bool)(arg1)->Unassociate(arg2);
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 {
19249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19250 }
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19258 PyObject *resultobj = 0;
19259 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19260 void *argp1 = 0 ;
19261 int res1 = 0 ;
19262 PyObject *swig_obj[1] ;
19263
19264 if (!args) SWIG_fail;
19265 swig_obj[0] = args;
19266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19267 if (!SWIG_IsOK(res1)) {
19268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19269 }
19270 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 delete arg1;
19274
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 resultobj = SWIG_Py_Void();
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19286 PyObject *obj;
19287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19288 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19289 return SWIG_Py_Void();
19290 }
19291
19292 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19293 return SWIG_Python_InitShadowInstance(args);
19294 }
19295
19296 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19297 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19298 return 1;
19299 }
19300
19301
19302 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19303 PyObject *pyobj = 0;
19304
19305 {
19306 #if wxUSE_UNICODE
19307 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19308 #else
19309 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19310 #endif
19311 }
19312 return pyobj;
19313 }
19314
19315
19316 SWIGINTERN int ART_MENU_set(PyObject *) {
19317 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19318 return 1;
19319 }
19320
19321
19322 SWIGINTERN PyObject *ART_MENU_get(void) {
19323 PyObject *pyobj = 0;
19324
19325 {
19326 #if wxUSE_UNICODE
19327 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19328 #else
19329 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19330 #endif
19331 }
19332 return pyobj;
19333 }
19334
19335
19336 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19337 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19338 return 1;
19339 }
19340
19341
19342 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19343 PyObject *pyobj = 0;
19344
19345 {
19346 #if wxUSE_UNICODE
19347 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19348 #else
19349 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19350 #endif
19351 }
19352 return pyobj;
19353 }
19354
19355
19356 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19357 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19358 return 1;
19359 }
19360
19361
19362 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19363 PyObject *pyobj = 0;
19364
19365 {
19366 #if wxUSE_UNICODE
19367 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19368 #else
19369 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19370 #endif
19371 }
19372 return pyobj;
19373 }
19374
19375
19376 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19377 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19378 return 1;
19379 }
19380
19381
19382 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19383 PyObject *pyobj = 0;
19384
19385 {
19386 #if wxUSE_UNICODE
19387 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19388 #else
19389 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19390 #endif
19391 }
19392 return pyobj;
19393 }
19394
19395
19396 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19397 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19398 return 1;
19399 }
19400
19401
19402 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19403 PyObject *pyobj = 0;
19404
19405 {
19406 #if wxUSE_UNICODE
19407 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19408 #else
19409 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19410 #endif
19411 }
19412 return pyobj;
19413 }
19414
19415
19416 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19417 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19418 return 1;
19419 }
19420
19421
19422 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19423 PyObject *pyobj = 0;
19424
19425 {
19426 #if wxUSE_UNICODE
19427 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19428 #else
19429 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19430 #endif
19431 }
19432 return pyobj;
19433 }
19434
19435
19436 SWIGINTERN int ART_OTHER_set(PyObject *) {
19437 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19438 return 1;
19439 }
19440
19441
19442 SWIGINTERN PyObject *ART_OTHER_get(void) {
19443 PyObject *pyobj = 0;
19444
19445 {
19446 #if wxUSE_UNICODE
19447 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19448 #else
19449 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19450 #endif
19451 }
19452 return pyobj;
19453 }
19454
19455
19456 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19457 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19458 return 1;
19459 }
19460
19461
19462 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19463 PyObject *pyobj = 0;
19464
19465 {
19466 #if wxUSE_UNICODE
19467 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19468 #else
19469 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19470 #endif
19471 }
19472 return pyobj;
19473 }
19474
19475
19476 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19477 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19478 return 1;
19479 }
19480
19481
19482 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19483 PyObject *pyobj = 0;
19484
19485 {
19486 #if wxUSE_UNICODE
19487 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19488 #else
19489 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19490 #endif
19491 }
19492 return pyobj;
19493 }
19494
19495
19496 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19497 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19498 return 1;
19499 }
19500
19501
19502 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19503 PyObject *pyobj = 0;
19504
19505 {
19506 #if wxUSE_UNICODE
19507 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19508 #else
19509 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19510 #endif
19511 }
19512 return pyobj;
19513 }
19514
19515
19516 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19517 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19518 return 1;
19519 }
19520
19521
19522 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19523 PyObject *pyobj = 0;
19524
19525 {
19526 #if wxUSE_UNICODE
19527 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19528 #else
19529 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19530 #endif
19531 }
19532 return pyobj;
19533 }
19534
19535
19536 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19537 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19538 return 1;
19539 }
19540
19541
19542 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19543 PyObject *pyobj = 0;
19544
19545 {
19546 #if wxUSE_UNICODE
19547 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19548 #else
19549 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19550 #endif
19551 }
19552 return pyobj;
19553 }
19554
19555
19556 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19557 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19558 return 1;
19559 }
19560
19561
19562 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19563 PyObject *pyobj = 0;
19564
19565 {
19566 #if wxUSE_UNICODE
19567 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19568 #else
19569 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19570 #endif
19571 }
19572 return pyobj;
19573 }
19574
19575
19576 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19577 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19578 return 1;
19579 }
19580
19581
19582 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19583 PyObject *pyobj = 0;
19584
19585 {
19586 #if wxUSE_UNICODE
19587 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19588 #else
19589 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19590 #endif
19591 }
19592 return pyobj;
19593 }
19594
19595
19596 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19597 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19598 return 1;
19599 }
19600
19601
19602 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19603 PyObject *pyobj = 0;
19604
19605 {
19606 #if wxUSE_UNICODE
19607 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19608 #else
19609 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19610 #endif
19611 }
19612 return pyobj;
19613 }
19614
19615
19616 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19617 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19618 return 1;
19619 }
19620
19621
19622 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19623 PyObject *pyobj = 0;
19624
19625 {
19626 #if wxUSE_UNICODE
19627 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19628 #else
19629 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19630 #endif
19631 }
19632 return pyobj;
19633 }
19634
19635
19636 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19637 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19638 return 1;
19639 }
19640
19641
19642 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19643 PyObject *pyobj = 0;
19644
19645 {
19646 #if wxUSE_UNICODE
19647 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19648 #else
19649 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19650 #endif
19651 }
19652 return pyobj;
19653 }
19654
19655
19656 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19657 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19658 return 1;
19659 }
19660
19661
19662 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19663 PyObject *pyobj = 0;
19664
19665 {
19666 #if wxUSE_UNICODE
19667 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19668 #else
19669 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19670 #endif
19671 }
19672 return pyobj;
19673 }
19674
19675
19676 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19677 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19678 return 1;
19679 }
19680
19681
19682 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19683 PyObject *pyobj = 0;
19684
19685 {
19686 #if wxUSE_UNICODE
19687 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19688 #else
19689 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19690 #endif
19691 }
19692 return pyobj;
19693 }
19694
19695
19696 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19697 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19698 return 1;
19699 }
19700
19701
19702 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19703 PyObject *pyobj = 0;
19704
19705 {
19706 #if wxUSE_UNICODE
19707 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19708 #else
19709 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19710 #endif
19711 }
19712 return pyobj;
19713 }
19714
19715
19716 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19717 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19718 return 1;
19719 }
19720
19721
19722 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19723 PyObject *pyobj = 0;
19724
19725 {
19726 #if wxUSE_UNICODE
19727 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19728 #else
19729 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19730 #endif
19731 }
19732 return pyobj;
19733 }
19734
19735
19736 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19737 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19738 return 1;
19739 }
19740
19741
19742 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19743 PyObject *pyobj = 0;
19744
19745 {
19746 #if wxUSE_UNICODE
19747 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19748 #else
19749 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19750 #endif
19751 }
19752 return pyobj;
19753 }
19754
19755
19756 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19757 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19758 return 1;
19759 }
19760
19761
19762 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19763 PyObject *pyobj = 0;
19764
19765 {
19766 #if wxUSE_UNICODE
19767 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19768 #else
19769 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19770 #endif
19771 }
19772 return pyobj;
19773 }
19774
19775
19776 SWIGINTERN int ART_PRINT_set(PyObject *) {
19777 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19778 return 1;
19779 }
19780
19781
19782 SWIGINTERN PyObject *ART_PRINT_get(void) {
19783 PyObject *pyobj = 0;
19784
19785 {
19786 #if wxUSE_UNICODE
19787 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19788 #else
19789 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19790 #endif
19791 }
19792 return pyobj;
19793 }
19794
19795
19796 SWIGINTERN int ART_HELP_set(PyObject *) {
19797 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19798 return 1;
19799 }
19800
19801
19802 SWIGINTERN PyObject *ART_HELP_get(void) {
19803 PyObject *pyobj = 0;
19804
19805 {
19806 #if wxUSE_UNICODE
19807 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19808 #else
19809 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19810 #endif
19811 }
19812 return pyobj;
19813 }
19814
19815
19816 SWIGINTERN int ART_TIP_set(PyObject *) {
19817 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19818 return 1;
19819 }
19820
19821
19822 SWIGINTERN PyObject *ART_TIP_get(void) {
19823 PyObject *pyobj = 0;
19824
19825 {
19826 #if wxUSE_UNICODE
19827 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19828 #else
19829 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19830 #endif
19831 }
19832 return pyobj;
19833 }
19834
19835
19836 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19837 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19838 return 1;
19839 }
19840
19841
19842 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19843 PyObject *pyobj = 0;
19844
19845 {
19846 #if wxUSE_UNICODE
19847 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19848 #else
19849 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19850 #endif
19851 }
19852 return pyobj;
19853 }
19854
19855
19856 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19857 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19858 return 1;
19859 }
19860
19861
19862 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19863 PyObject *pyobj = 0;
19864
19865 {
19866 #if wxUSE_UNICODE
19867 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19868 #else
19869 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19870 #endif
19871 }
19872 return pyobj;
19873 }
19874
19875
19876 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19877 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19878 return 1;
19879 }
19880
19881
19882 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19883 PyObject *pyobj = 0;
19884
19885 {
19886 #if wxUSE_UNICODE
19887 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19888 #else
19889 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19890 #endif
19891 }
19892 return pyobj;
19893 }
19894
19895
19896 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19897 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19898 return 1;
19899 }
19900
19901
19902 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19903 PyObject *pyobj = 0;
19904
19905 {
19906 #if wxUSE_UNICODE
19907 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19908 #else
19909 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19910 #endif
19911 }
19912 return pyobj;
19913 }
19914
19915
19916 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19917 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19918 return 1;
19919 }
19920
19921
19922 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19923 PyObject *pyobj = 0;
19924
19925 {
19926 #if wxUSE_UNICODE
19927 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19928 #else
19929 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19930 #endif
19931 }
19932 return pyobj;
19933 }
19934
19935
19936 SWIGINTERN int ART_CDROM_set(PyObject *) {
19937 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19938 return 1;
19939 }
19940
19941
19942 SWIGINTERN PyObject *ART_CDROM_get(void) {
19943 PyObject *pyobj = 0;
19944
19945 {
19946 #if wxUSE_UNICODE
19947 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19948 #else
19949 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19950 #endif
19951 }
19952 return pyobj;
19953 }
19954
19955
19956 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19957 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19958 return 1;
19959 }
19960
19961
19962 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19963 PyObject *pyobj = 0;
19964
19965 {
19966 #if wxUSE_UNICODE
19967 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19968 #else
19969 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19970 #endif
19971 }
19972 return pyobj;
19973 }
19974
19975
19976 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19977 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19978 return 1;
19979 }
19980
19981
19982 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19983 PyObject *pyobj = 0;
19984
19985 {
19986 #if wxUSE_UNICODE
19987 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19988 #else
19989 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19990 #endif
19991 }
19992 return pyobj;
19993 }
19994
19995
19996 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19997 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19998 return 1;
19999 }
20000
20001
20002 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20003 PyObject *pyobj = 0;
20004
20005 {
20006 #if wxUSE_UNICODE
20007 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20008 #else
20009 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20010 #endif
20011 }
20012 return pyobj;
20013 }
20014
20015
20016 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20017 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20018 return 1;
20019 }
20020
20021
20022 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20023 PyObject *pyobj = 0;
20024
20025 {
20026 #if wxUSE_UNICODE
20027 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20028 #else
20029 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20030 #endif
20031 }
20032 return pyobj;
20033 }
20034
20035
20036 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20037 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20038 return 1;
20039 }
20040
20041
20042 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20043 PyObject *pyobj = 0;
20044
20045 {
20046 #if wxUSE_UNICODE
20047 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20048 #else
20049 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20050 #endif
20051 }
20052 return pyobj;
20053 }
20054
20055
20056 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20057 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20058 return 1;
20059 }
20060
20061
20062 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20063 PyObject *pyobj = 0;
20064
20065 {
20066 #if wxUSE_UNICODE
20067 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20068 #else
20069 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20070 #endif
20071 }
20072 return pyobj;
20073 }
20074
20075
20076 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20077 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20078 return 1;
20079 }
20080
20081
20082 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20083 PyObject *pyobj = 0;
20084
20085 {
20086 #if wxUSE_UNICODE
20087 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20088 #else
20089 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20090 #endif
20091 }
20092 return pyobj;
20093 }
20094
20095
20096 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20097 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20098 return 1;
20099 }
20100
20101
20102 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20103 PyObject *pyobj = 0;
20104
20105 {
20106 #if wxUSE_UNICODE
20107 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20108 #else
20109 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20110 #endif
20111 }
20112 return pyobj;
20113 }
20114
20115
20116 SWIGINTERN int ART_ERROR_set(PyObject *) {
20117 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20118 return 1;
20119 }
20120
20121
20122 SWIGINTERN PyObject *ART_ERROR_get(void) {
20123 PyObject *pyobj = 0;
20124
20125 {
20126 #if wxUSE_UNICODE
20127 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20128 #else
20129 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20130 #endif
20131 }
20132 return pyobj;
20133 }
20134
20135
20136 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20137 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20138 return 1;
20139 }
20140
20141
20142 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20143 PyObject *pyobj = 0;
20144
20145 {
20146 #if wxUSE_UNICODE
20147 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20148 #else
20149 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20150 #endif
20151 }
20152 return pyobj;
20153 }
20154
20155
20156 SWIGINTERN int ART_WARNING_set(PyObject *) {
20157 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20158 return 1;
20159 }
20160
20161
20162 SWIGINTERN PyObject *ART_WARNING_get(void) {
20163 PyObject *pyobj = 0;
20164
20165 {
20166 #if wxUSE_UNICODE
20167 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20168 #else
20169 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20170 #endif
20171 }
20172 return pyobj;
20173 }
20174
20175
20176 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20177 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20178 return 1;
20179 }
20180
20181
20182 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20183 PyObject *pyobj = 0;
20184
20185 {
20186 #if wxUSE_UNICODE
20187 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20188 #else
20189 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20190 #endif
20191 }
20192 return pyobj;
20193 }
20194
20195
20196 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20197 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20198 return 1;
20199 }
20200
20201
20202 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20203 PyObject *pyobj = 0;
20204
20205 {
20206 #if wxUSE_UNICODE
20207 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20208 #else
20209 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20210 #endif
20211 }
20212 return pyobj;
20213 }
20214
20215
20216 SWIGINTERN int ART_COPY_set(PyObject *) {
20217 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20218 return 1;
20219 }
20220
20221
20222 SWIGINTERN PyObject *ART_COPY_get(void) {
20223 PyObject *pyobj = 0;
20224
20225 {
20226 #if wxUSE_UNICODE
20227 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20228 #else
20229 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20230 #endif
20231 }
20232 return pyobj;
20233 }
20234
20235
20236 SWIGINTERN int ART_CUT_set(PyObject *) {
20237 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20238 return 1;
20239 }
20240
20241
20242 SWIGINTERN PyObject *ART_CUT_get(void) {
20243 PyObject *pyobj = 0;
20244
20245 {
20246 #if wxUSE_UNICODE
20247 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20248 #else
20249 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20250 #endif
20251 }
20252 return pyobj;
20253 }
20254
20255
20256 SWIGINTERN int ART_PASTE_set(PyObject *) {
20257 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20258 return 1;
20259 }
20260
20261
20262 SWIGINTERN PyObject *ART_PASTE_get(void) {
20263 PyObject *pyobj = 0;
20264
20265 {
20266 #if wxUSE_UNICODE
20267 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20268 #else
20269 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20270 #endif
20271 }
20272 return pyobj;
20273 }
20274
20275
20276 SWIGINTERN int ART_DELETE_set(PyObject *) {
20277 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20278 return 1;
20279 }
20280
20281
20282 SWIGINTERN PyObject *ART_DELETE_get(void) {
20283 PyObject *pyobj = 0;
20284
20285 {
20286 #if wxUSE_UNICODE
20287 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20288 #else
20289 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20290 #endif
20291 }
20292 return pyobj;
20293 }
20294
20295
20296 SWIGINTERN int ART_NEW_set(PyObject *) {
20297 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20298 return 1;
20299 }
20300
20301
20302 SWIGINTERN PyObject *ART_NEW_get(void) {
20303 PyObject *pyobj = 0;
20304
20305 {
20306 #if wxUSE_UNICODE
20307 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20308 #else
20309 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20310 #endif
20311 }
20312 return pyobj;
20313 }
20314
20315
20316 SWIGINTERN int ART_UNDO_set(PyObject *) {
20317 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20318 return 1;
20319 }
20320
20321
20322 SWIGINTERN PyObject *ART_UNDO_get(void) {
20323 PyObject *pyobj = 0;
20324
20325 {
20326 #if wxUSE_UNICODE
20327 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20328 #else
20329 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20330 #endif
20331 }
20332 return pyobj;
20333 }
20334
20335
20336 SWIGINTERN int ART_REDO_set(PyObject *) {
20337 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20338 return 1;
20339 }
20340
20341
20342 SWIGINTERN PyObject *ART_REDO_get(void) {
20343 PyObject *pyobj = 0;
20344
20345 {
20346 #if wxUSE_UNICODE
20347 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20348 #else
20349 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20350 #endif
20351 }
20352 return pyobj;
20353 }
20354
20355
20356 SWIGINTERN int ART_QUIT_set(PyObject *) {
20357 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20358 return 1;
20359 }
20360
20361
20362 SWIGINTERN PyObject *ART_QUIT_get(void) {
20363 PyObject *pyobj = 0;
20364
20365 {
20366 #if wxUSE_UNICODE
20367 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20368 #else
20369 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20370 #endif
20371 }
20372 return pyobj;
20373 }
20374
20375
20376 SWIGINTERN int ART_FIND_set(PyObject *) {
20377 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20378 return 1;
20379 }
20380
20381
20382 SWIGINTERN PyObject *ART_FIND_get(void) {
20383 PyObject *pyobj = 0;
20384
20385 {
20386 #if wxUSE_UNICODE
20387 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20388 #else
20389 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20390 #endif
20391 }
20392 return pyobj;
20393 }
20394
20395
20396 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20397 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20398 return 1;
20399 }
20400
20401
20402 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20403 PyObject *pyobj = 0;
20404
20405 {
20406 #if wxUSE_UNICODE
20407 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20408 #else
20409 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20410 #endif
20411 }
20412 return pyobj;
20413 }
20414
20415
20416 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20417 PyObject *resultobj = 0;
20418 wxPyArtProvider *result = 0 ;
20419
20420 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20421 {
20422 if (!wxPyCheckForApp()) SWIG_fail;
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 result = (wxPyArtProvider *)new wxPyArtProvider();
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20429 return resultobj;
20430 fail:
20431 return NULL;
20432 }
20433
20434
20435 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20436 PyObject *resultobj = 0;
20437 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20438 void *argp1 = 0 ;
20439 int res1 = 0 ;
20440 PyObject *swig_obj[1] ;
20441
20442 if (!args) SWIG_fail;
20443 swig_obj[0] = args;
20444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20445 if (!SWIG_IsOK(res1)) {
20446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20447 }
20448 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 delete arg1;
20452
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 resultobj = SWIG_Py_Void();
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj = 0;
20465 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20466 PyObject *arg2 = (PyObject *) 0 ;
20467 PyObject *arg3 = (PyObject *) 0 ;
20468 void *argp1 = 0 ;
20469 int res1 = 0 ;
20470 PyObject * obj0 = 0 ;
20471 PyObject * obj1 = 0 ;
20472 PyObject * obj2 = 0 ;
20473 char * kwnames[] = {
20474 (char *) "self",(char *) "self",(char *) "_class", NULL
20475 };
20476
20477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20479 if (!SWIG_IsOK(res1)) {
20480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20481 }
20482 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20483 arg2 = obj1;
20484 arg3 = obj2;
20485 {
20486 PyThreadState* __tstate = wxPyBeginAllowThreads();
20487 (arg1)->_setCallbackInfo(arg2,arg3);
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 resultobj = SWIG_Py_Void();
20492 return resultobj;
20493 fail:
20494 return NULL;
20495 }
20496
20497
20498 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20499 PyObject *resultobj = 0;
20500 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20501 int res1 = 0 ;
20502 PyObject * obj0 = 0 ;
20503 char * kwnames[] = {
20504 (char *) "provider", NULL
20505 };
20506
20507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20508 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20509 if (!SWIG_IsOK(res1)) {
20510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20511 }
20512 {
20513 PyThreadState* __tstate = wxPyBeginAllowThreads();
20514 wxPyArtProvider::Push(arg1);
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 resultobj = SWIG_Py_Void();
20519 return resultobj;
20520 fail:
20521 return NULL;
20522 }
20523
20524
20525 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj = 0;
20527 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20528 int res1 = 0 ;
20529 PyObject * obj0 = 0 ;
20530 char * kwnames[] = {
20531 (char *) "provider", NULL
20532 };
20533
20534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20535 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20536 if (!SWIG_IsOK(res1)) {
20537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20538 }
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 wxPyArtProvider::Insert(arg1);
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 resultobj = SWIG_Py_Void();
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 bool result;
20555
20556 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (bool)wxPyArtProvider::Pop();
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 {
20564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20565 }
20566 return resultobj;
20567 fail:
20568 return NULL;
20569 }
20570
20571
20572 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20573 PyObject *resultobj = 0;
20574 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20575 bool result;
20576 void *argp1 = 0 ;
20577 int res1 = 0 ;
20578 PyObject * obj0 = 0 ;
20579 char * kwnames[] = {
20580 (char *) "provider", NULL
20581 };
20582
20583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20585 if (!SWIG_IsOK(res1)) {
20586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20587 }
20588 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20589 {
20590 PyThreadState* __tstate = wxPyBeginAllowThreads();
20591 result = (bool)wxPyArtProvider::Delete(arg1);
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 {
20596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20597 }
20598 return resultobj;
20599 fail:
20600 return NULL;
20601 }
20602
20603
20604 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20605 PyObject *resultobj = 0;
20606 wxString *arg1 = 0 ;
20607 wxString const &arg2_defvalue = wxPyART_OTHER ;
20608 wxString *arg2 = (wxString *) &arg2_defvalue ;
20609 wxSize const &arg3_defvalue = wxDefaultSize ;
20610 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20611 wxBitmap result;
20612 bool temp1 = false ;
20613 bool temp2 = false ;
20614 wxSize temp3 ;
20615 PyObject * obj0 = 0 ;
20616 PyObject * obj1 = 0 ;
20617 PyObject * obj2 = 0 ;
20618 char * kwnames[] = {
20619 (char *) "id",(char *) "client",(char *) "size", NULL
20620 };
20621
20622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20623 {
20624 arg1 = wxString_in_helper(obj0);
20625 if (arg1 == NULL) SWIG_fail;
20626 temp1 = true;
20627 }
20628 if (obj1) {
20629 {
20630 arg2 = wxString_in_helper(obj1);
20631 if (arg2 == NULL) SWIG_fail;
20632 temp2 = true;
20633 }
20634 }
20635 if (obj2) {
20636 {
20637 arg3 = &temp3;
20638 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20639 }
20640 }
20641 {
20642 if (!wxPyCheckForApp()) SWIG_fail;
20643 PyThreadState* __tstate = wxPyBeginAllowThreads();
20644 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20645 wxPyEndAllowThreads(__tstate);
20646 if (PyErr_Occurred()) SWIG_fail;
20647 }
20648 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20649 {
20650 if (temp1)
20651 delete arg1;
20652 }
20653 {
20654 if (temp2)
20655 delete arg2;
20656 }
20657 return resultobj;
20658 fail:
20659 {
20660 if (temp1)
20661 delete arg1;
20662 }
20663 {
20664 if (temp2)
20665 delete arg2;
20666 }
20667 return NULL;
20668 }
20669
20670
20671 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj = 0;
20673 wxString *arg1 = 0 ;
20674 wxString const &arg2_defvalue = wxPyART_OTHER ;
20675 wxString *arg2 = (wxString *) &arg2_defvalue ;
20676 wxSize const &arg3_defvalue = wxDefaultSize ;
20677 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20678 wxIcon result;
20679 bool temp1 = false ;
20680 bool temp2 = false ;
20681 wxSize temp3 ;
20682 PyObject * obj0 = 0 ;
20683 PyObject * obj1 = 0 ;
20684 PyObject * obj2 = 0 ;
20685 char * kwnames[] = {
20686 (char *) "id",(char *) "client",(char *) "size", NULL
20687 };
20688
20689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20690 {
20691 arg1 = wxString_in_helper(obj0);
20692 if (arg1 == NULL) SWIG_fail;
20693 temp1 = true;
20694 }
20695 if (obj1) {
20696 {
20697 arg2 = wxString_in_helper(obj1);
20698 if (arg2 == NULL) SWIG_fail;
20699 temp2 = true;
20700 }
20701 }
20702 if (obj2) {
20703 {
20704 arg3 = &temp3;
20705 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20706 }
20707 }
20708 {
20709 if (!wxPyCheckForApp()) SWIG_fail;
20710 PyThreadState* __tstate = wxPyBeginAllowThreads();
20711 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20712 wxPyEndAllowThreads(__tstate);
20713 if (PyErr_Occurred()) SWIG_fail;
20714 }
20715 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20716 {
20717 if (temp1)
20718 delete arg1;
20719 }
20720 {
20721 if (temp2)
20722 delete arg2;
20723 }
20724 return resultobj;
20725 fail:
20726 {
20727 if (temp1)
20728 delete arg1;
20729 }
20730 {
20731 if (temp2)
20732 delete arg2;
20733 }
20734 return NULL;
20735 }
20736
20737
20738 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20739 PyObject *resultobj = 0;
20740 wxString *arg1 = 0 ;
20741 bool arg2 = (bool) false ;
20742 wxSize result;
20743 bool temp1 = false ;
20744 bool val2 ;
20745 int ecode2 = 0 ;
20746 PyObject * obj0 = 0 ;
20747 PyObject * obj1 = 0 ;
20748 char * kwnames[] = {
20749 (char *) "client",(char *) "platform_dependent", NULL
20750 };
20751
20752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20753 {
20754 arg1 = wxString_in_helper(obj0);
20755 if (arg1 == NULL) SWIG_fail;
20756 temp1 = true;
20757 }
20758 if (obj1) {
20759 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20760 if (!SWIG_IsOK(ecode2)) {
20761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20762 }
20763 arg2 = static_cast< bool >(val2);
20764 }
20765 {
20766 PyThreadState* __tstate = wxPyBeginAllowThreads();
20767 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20768 wxPyEndAllowThreads(__tstate);
20769 if (PyErr_Occurred()) SWIG_fail;
20770 }
20771 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20772 {
20773 if (temp1)
20774 delete arg1;
20775 }
20776 return resultobj;
20777 fail:
20778 {
20779 if (temp1)
20780 delete arg1;
20781 }
20782 return NULL;
20783 }
20784
20785
20786 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20787 PyObject *resultobj = 0;
20788 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20789 void *argp1 = 0 ;
20790 int res1 = 0 ;
20791 PyObject *swig_obj[1] ;
20792
20793 if (!args) SWIG_fail;
20794 swig_obj[0] = args;
20795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20796 if (!SWIG_IsOK(res1)) {
20797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20798 }
20799 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 wxPyArtProvider_Destroy(arg1);
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_Py_Void();
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20814 PyObject *obj;
20815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20816 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20817 return SWIG_Py_Void();
20818 }
20819
20820 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20821 return SWIG_Python_InitShadowInstance(args);
20822 }
20823
20824 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20825 PyObject *resultobj = 0;
20826 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20827 void *argp1 = 0 ;
20828 int res1 = 0 ;
20829 PyObject *swig_obj[1] ;
20830
20831 if (!args) SWIG_fail;
20832 swig_obj[0] = args;
20833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20834 if (!SWIG_IsOK(res1)) {
20835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20836 }
20837 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 delete arg1;
20841
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 resultobj = SWIG_Py_Void();
20846 return resultobj;
20847 fail:
20848 return NULL;
20849 }
20850
20851
20852 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20853 PyObject *resultobj = 0;
20854 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20855 wxConfigBase *result = 0 ;
20856 int res1 = 0 ;
20857 PyObject * obj0 = 0 ;
20858 char * kwnames[] = {
20859 (char *) "config", NULL
20860 };
20861
20862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20863 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20864 if (!SWIG_IsOK(res1)) {
20865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20866 }
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20881 PyObject *resultobj = 0;
20882 bool arg1 = (bool) true ;
20883 wxConfigBase *result = 0 ;
20884 bool val1 ;
20885 int ecode1 = 0 ;
20886 PyObject * obj0 = 0 ;
20887 char * kwnames[] = {
20888 (char *) "createOnDemand", NULL
20889 };
20890
20891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20892 if (obj0) {
20893 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20894 if (!SWIG_IsOK(ecode1)) {
20895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20896 }
20897 arg1 = static_cast< bool >(val1);
20898 }
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20913 PyObject *resultobj = 0;
20914 wxConfigBase *result = 0 ;
20915
20916 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 result = (wxConfigBase *)wxConfigBase::Create();
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20931 PyObject *resultobj = 0;
20932
20933 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20934 {
20935 PyThreadState* __tstate = wxPyBeginAllowThreads();
20936 wxConfigBase::DontCreateOnDemand();
20937 wxPyEndAllowThreads(__tstate);
20938 if (PyErr_Occurred()) SWIG_fail;
20939 }
20940 resultobj = SWIG_Py_Void();
20941 return resultobj;
20942 fail:
20943 return NULL;
20944 }
20945
20946
20947 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20948 PyObject *resultobj = 0;
20949 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20950 wxString *arg2 = 0 ;
20951 void *argp1 = 0 ;
20952 int res1 = 0 ;
20953 bool temp2 = false ;
20954 PyObject * obj0 = 0 ;
20955 PyObject * obj1 = 0 ;
20956 char * kwnames[] = {
20957 (char *) "self",(char *) "path", NULL
20958 };
20959
20960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20962 if (!SWIG_IsOK(res1)) {
20963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20964 }
20965 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20966 {
20967 arg2 = wxString_in_helper(obj1);
20968 if (arg2 == NULL) SWIG_fail;
20969 temp2 = true;
20970 }
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 (arg1)->SetPath((wxString const &)*arg2);
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 resultobj = SWIG_Py_Void();
20978 {
20979 if (temp2)
20980 delete arg2;
20981 }
20982 return resultobj;
20983 fail:
20984 {
20985 if (temp2)
20986 delete arg2;
20987 }
20988 return NULL;
20989 }
20990
20991
20992 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20993 PyObject *resultobj = 0;
20994 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20995 wxString *result = 0 ;
20996 void *argp1 = 0 ;
20997 int res1 = 0 ;
20998 PyObject *swig_obj[1] ;
20999
21000 if (!args) SWIG_fail;
21001 swig_obj[0] = args;
21002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21003 if (!SWIG_IsOK(res1)) {
21004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21005 }
21006 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21007 {
21008 PyThreadState* __tstate = wxPyBeginAllowThreads();
21009 {
21010 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21011 result = (wxString *) &_result_ref;
21012 }
21013 wxPyEndAllowThreads(__tstate);
21014 if (PyErr_Occurred()) SWIG_fail;
21015 }
21016 {
21017 #if wxUSE_UNICODE
21018 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21019 #else
21020 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21021 #endif
21022 }
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *resultobj = 0;
21031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21032 PyObject *result = 0 ;
21033 void *argp1 = 0 ;
21034 int res1 = 0 ;
21035 PyObject *swig_obj[1] ;
21036
21037 if (!args) SWIG_fail;
21038 swig_obj[0] = args;
21039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21040 if (!SWIG_IsOK(res1)) {
21041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21042 }
21043 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21044 {
21045 PyThreadState* __tstate = wxPyBeginAllowThreads();
21046 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21047 wxPyEndAllowThreads(__tstate);
21048 if (PyErr_Occurred()) SWIG_fail;
21049 }
21050 resultobj = result;
21051 return resultobj;
21052 fail:
21053 return NULL;
21054 }
21055
21056
21057 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21058 PyObject *resultobj = 0;
21059 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21060 long arg2 ;
21061 PyObject *result = 0 ;
21062 void *argp1 = 0 ;
21063 int res1 = 0 ;
21064 long val2 ;
21065 int ecode2 = 0 ;
21066 PyObject * obj0 = 0 ;
21067 PyObject * obj1 = 0 ;
21068 char * kwnames[] = {
21069 (char *) "self",(char *) "index", NULL
21070 };
21071
21072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21074 if (!SWIG_IsOK(res1)) {
21075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21076 }
21077 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21078 ecode2 = SWIG_AsVal_long(obj1, &val2);
21079 if (!SWIG_IsOK(ecode2)) {
21080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21081 }
21082 arg2 = static_cast< long >(val2);
21083 {
21084 PyThreadState* __tstate = wxPyBeginAllowThreads();
21085 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 resultobj = result;
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21097 PyObject *resultobj = 0;
21098 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21099 PyObject *result = 0 ;
21100 void *argp1 = 0 ;
21101 int res1 = 0 ;
21102 PyObject *swig_obj[1] ;
21103
21104 if (!args) SWIG_fail;
21105 swig_obj[0] = args;
21106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21107 if (!SWIG_IsOK(res1)) {
21108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21109 }
21110 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21111 {
21112 PyThreadState* __tstate = wxPyBeginAllowThreads();
21113 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21114 wxPyEndAllowThreads(__tstate);
21115 if (PyErr_Occurred()) SWIG_fail;
21116 }
21117 resultobj = result;
21118 return resultobj;
21119 fail:
21120 return NULL;
21121 }
21122
21123
21124 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21125 PyObject *resultobj = 0;
21126 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21127 long arg2 ;
21128 PyObject *result = 0 ;
21129 void *argp1 = 0 ;
21130 int res1 = 0 ;
21131 long val2 ;
21132 int ecode2 = 0 ;
21133 PyObject * obj0 = 0 ;
21134 PyObject * obj1 = 0 ;
21135 char * kwnames[] = {
21136 (char *) "self",(char *) "index", NULL
21137 };
21138
21139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21141 if (!SWIG_IsOK(res1)) {
21142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21143 }
21144 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21145 ecode2 = SWIG_AsVal_long(obj1, &val2);
21146 if (!SWIG_IsOK(ecode2)) {
21147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21148 }
21149 arg2 = static_cast< long >(val2);
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21153 wxPyEndAllowThreads(__tstate);
21154 if (PyErr_Occurred()) SWIG_fail;
21155 }
21156 resultobj = result;
21157 return resultobj;
21158 fail:
21159 return NULL;
21160 }
21161
21162
21163 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21164 PyObject *resultobj = 0;
21165 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21166 bool arg2 = (bool) false ;
21167 size_t result;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 bool val2 ;
21171 int ecode2 = 0 ;
21172 PyObject * obj0 = 0 ;
21173 PyObject * obj1 = 0 ;
21174 char * kwnames[] = {
21175 (char *) "self",(char *) "recursive", NULL
21176 };
21177
21178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21180 if (!SWIG_IsOK(res1)) {
21181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21182 }
21183 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21184 if (obj1) {
21185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21186 if (!SWIG_IsOK(ecode2)) {
21187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21188 }
21189 arg2 = static_cast< bool >(val2);
21190 }
21191 {
21192 PyThreadState* __tstate = wxPyBeginAllowThreads();
21193 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21194 wxPyEndAllowThreads(__tstate);
21195 if (PyErr_Occurred()) SWIG_fail;
21196 }
21197 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21198 return resultobj;
21199 fail:
21200 return NULL;
21201 }
21202
21203
21204 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21205 PyObject *resultobj = 0;
21206 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21207 bool arg2 = (bool) false ;
21208 size_t result;
21209 void *argp1 = 0 ;
21210 int res1 = 0 ;
21211 bool val2 ;
21212 int ecode2 = 0 ;
21213 PyObject * obj0 = 0 ;
21214 PyObject * obj1 = 0 ;
21215 char * kwnames[] = {
21216 (char *) "self",(char *) "recursive", NULL
21217 };
21218
21219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21221 if (!SWIG_IsOK(res1)) {
21222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21223 }
21224 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21225 if (obj1) {
21226 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21227 if (!SWIG_IsOK(ecode2)) {
21228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21229 }
21230 arg2 = static_cast< bool >(val2);
21231 }
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21239 return resultobj;
21240 fail:
21241 return NULL;
21242 }
21243
21244
21245 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21246 PyObject *resultobj = 0;
21247 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21248 wxString *arg2 = 0 ;
21249 bool result;
21250 void *argp1 = 0 ;
21251 int res1 = 0 ;
21252 bool temp2 = false ;
21253 PyObject * obj0 = 0 ;
21254 PyObject * obj1 = 0 ;
21255 char * kwnames[] = {
21256 (char *) "self",(char *) "name", NULL
21257 };
21258
21259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21261 if (!SWIG_IsOK(res1)) {
21262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21263 }
21264 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21265 {
21266 arg2 = wxString_in_helper(obj1);
21267 if (arg2 == NULL) SWIG_fail;
21268 temp2 = true;
21269 }
21270 {
21271 PyThreadState* __tstate = wxPyBeginAllowThreads();
21272 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21273 wxPyEndAllowThreads(__tstate);
21274 if (PyErr_Occurred()) SWIG_fail;
21275 }
21276 {
21277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21278 }
21279 {
21280 if (temp2)
21281 delete arg2;
21282 }
21283 return resultobj;
21284 fail:
21285 {
21286 if (temp2)
21287 delete arg2;
21288 }
21289 return NULL;
21290 }
21291
21292
21293 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21294 PyObject *resultobj = 0;
21295 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21296 wxString *arg2 = 0 ;
21297 bool result;
21298 void *argp1 = 0 ;
21299 int res1 = 0 ;
21300 bool temp2 = false ;
21301 PyObject * obj0 = 0 ;
21302 PyObject * obj1 = 0 ;
21303 char * kwnames[] = {
21304 (char *) "self",(char *) "name", NULL
21305 };
21306
21307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21311 }
21312 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21313 {
21314 arg2 = wxString_in_helper(obj1);
21315 if (arg2 == NULL) SWIG_fail;
21316 temp2 = true;
21317 }
21318 {
21319 PyThreadState* __tstate = wxPyBeginAllowThreads();
21320 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21321 wxPyEndAllowThreads(__tstate);
21322 if (PyErr_Occurred()) SWIG_fail;
21323 }
21324 {
21325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21326 }
21327 {
21328 if (temp2)
21329 delete arg2;
21330 }
21331 return resultobj;
21332 fail:
21333 {
21334 if (temp2)
21335 delete arg2;
21336 }
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21342 PyObject *resultobj = 0;
21343 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21344 wxString *arg2 = 0 ;
21345 bool result;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 bool temp2 = false ;
21349 PyObject * obj0 = 0 ;
21350 PyObject * obj1 = 0 ;
21351 char * kwnames[] = {
21352 (char *) "self",(char *) "name", NULL
21353 };
21354
21355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21357 if (!SWIG_IsOK(res1)) {
21358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21359 }
21360 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21361 {
21362 arg2 = wxString_in_helper(obj1);
21363 if (arg2 == NULL) SWIG_fail;
21364 temp2 = true;
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 {
21373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21374 }
21375 {
21376 if (temp2)
21377 delete arg2;
21378 }
21379 return resultobj;
21380 fail:
21381 {
21382 if (temp2)
21383 delete arg2;
21384 }
21385 return NULL;
21386 }
21387
21388
21389 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj = 0;
21391 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21392 wxString *arg2 = 0 ;
21393 wxConfigBase::EntryType result;
21394 void *argp1 = 0 ;
21395 int res1 = 0 ;
21396 bool temp2 = false ;
21397 PyObject * obj0 = 0 ;
21398 PyObject * obj1 = 0 ;
21399 char * kwnames[] = {
21400 (char *) "self",(char *) "name", NULL
21401 };
21402
21403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21405 if (!SWIG_IsOK(res1)) {
21406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21407 }
21408 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21409 {
21410 arg2 = wxString_in_helper(obj1);
21411 if (arg2 == NULL) SWIG_fail;
21412 temp2 = true;
21413 }
21414 {
21415 PyThreadState* __tstate = wxPyBeginAllowThreads();
21416 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 resultobj = SWIG_From_int(static_cast< int >(result));
21421 {
21422 if (temp2)
21423 delete arg2;
21424 }
21425 return resultobj;
21426 fail:
21427 {
21428 if (temp2)
21429 delete arg2;
21430 }
21431 return NULL;
21432 }
21433
21434
21435 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21436 PyObject *resultobj = 0;
21437 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21438 wxString *arg2 = 0 ;
21439 wxString const &arg3_defvalue = wxPyEmptyString ;
21440 wxString *arg3 = (wxString *) &arg3_defvalue ;
21441 wxString result;
21442 void *argp1 = 0 ;
21443 int res1 = 0 ;
21444 bool temp2 = false ;
21445 bool temp3 = false ;
21446 PyObject * obj0 = 0 ;
21447 PyObject * obj1 = 0 ;
21448 PyObject * obj2 = 0 ;
21449 char * kwnames[] = {
21450 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21451 };
21452
21453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21455 if (!SWIG_IsOK(res1)) {
21456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21457 }
21458 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21459 {
21460 arg2 = wxString_in_helper(obj1);
21461 if (arg2 == NULL) SWIG_fail;
21462 temp2 = true;
21463 }
21464 if (obj2) {
21465 {
21466 arg3 = wxString_in_helper(obj2);
21467 if (arg3 == NULL) SWIG_fail;
21468 temp3 = true;
21469 }
21470 }
21471 {
21472 PyThreadState* __tstate = wxPyBeginAllowThreads();
21473 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21474 wxPyEndAllowThreads(__tstate);
21475 if (PyErr_Occurred()) SWIG_fail;
21476 }
21477 {
21478 #if wxUSE_UNICODE
21479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21480 #else
21481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21482 #endif
21483 }
21484 {
21485 if (temp2)
21486 delete arg2;
21487 }
21488 {
21489 if (temp3)
21490 delete arg3;
21491 }
21492 return resultobj;
21493 fail:
21494 {
21495 if (temp2)
21496 delete arg2;
21497 }
21498 {
21499 if (temp3)
21500 delete arg3;
21501 }
21502 return NULL;
21503 }
21504
21505
21506 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21507 PyObject *resultobj = 0;
21508 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21509 wxString *arg2 = 0 ;
21510 long arg3 = (long) 0 ;
21511 long result;
21512 void *argp1 = 0 ;
21513 int res1 = 0 ;
21514 bool temp2 = false ;
21515 long val3 ;
21516 int ecode3 = 0 ;
21517 PyObject * obj0 = 0 ;
21518 PyObject * obj1 = 0 ;
21519 PyObject * obj2 = 0 ;
21520 char * kwnames[] = {
21521 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21522 };
21523
21524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21526 if (!SWIG_IsOK(res1)) {
21527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21528 }
21529 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21530 {
21531 arg2 = wxString_in_helper(obj1);
21532 if (arg2 == NULL) SWIG_fail;
21533 temp2 = true;
21534 }
21535 if (obj2) {
21536 ecode3 = SWIG_AsVal_long(obj2, &val3);
21537 if (!SWIG_IsOK(ecode3)) {
21538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21539 }
21540 arg3 = static_cast< long >(val3);
21541 }
21542 {
21543 PyThreadState* __tstate = wxPyBeginAllowThreads();
21544 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21545 wxPyEndAllowThreads(__tstate);
21546 if (PyErr_Occurred()) SWIG_fail;
21547 }
21548 resultobj = SWIG_From_long(static_cast< long >(result));
21549 {
21550 if (temp2)
21551 delete arg2;
21552 }
21553 return resultobj;
21554 fail:
21555 {
21556 if (temp2)
21557 delete arg2;
21558 }
21559 return NULL;
21560 }
21561
21562
21563 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21564 PyObject *resultobj = 0;
21565 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21566 wxString *arg2 = 0 ;
21567 double arg3 = (double) 0.0 ;
21568 double result;
21569 void *argp1 = 0 ;
21570 int res1 = 0 ;
21571 bool temp2 = false ;
21572 double val3 ;
21573 int ecode3 = 0 ;
21574 PyObject * obj0 = 0 ;
21575 PyObject * obj1 = 0 ;
21576 PyObject * obj2 = 0 ;
21577 char * kwnames[] = {
21578 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21579 };
21580
21581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21583 if (!SWIG_IsOK(res1)) {
21584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21585 }
21586 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21587 {
21588 arg2 = wxString_in_helper(obj1);
21589 if (arg2 == NULL) SWIG_fail;
21590 temp2 = true;
21591 }
21592 if (obj2) {
21593 ecode3 = SWIG_AsVal_double(obj2, &val3);
21594 if (!SWIG_IsOK(ecode3)) {
21595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21596 }
21597 arg3 = static_cast< double >(val3);
21598 }
21599 {
21600 PyThreadState* __tstate = wxPyBeginAllowThreads();
21601 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21602 wxPyEndAllowThreads(__tstate);
21603 if (PyErr_Occurred()) SWIG_fail;
21604 }
21605 resultobj = SWIG_From_double(static_cast< double >(result));
21606 {
21607 if (temp2)
21608 delete arg2;
21609 }
21610 return resultobj;
21611 fail:
21612 {
21613 if (temp2)
21614 delete arg2;
21615 }
21616 return NULL;
21617 }
21618
21619
21620 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj = 0;
21622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21623 wxString *arg2 = 0 ;
21624 bool arg3 = (bool) false ;
21625 bool result;
21626 void *argp1 = 0 ;
21627 int res1 = 0 ;
21628 bool temp2 = false ;
21629 bool val3 ;
21630 int ecode3 = 0 ;
21631 PyObject * obj0 = 0 ;
21632 PyObject * obj1 = 0 ;
21633 PyObject * obj2 = 0 ;
21634 char * kwnames[] = {
21635 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21636 };
21637
21638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21640 if (!SWIG_IsOK(res1)) {
21641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21642 }
21643 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21644 {
21645 arg2 = wxString_in_helper(obj1);
21646 if (arg2 == NULL) SWIG_fail;
21647 temp2 = true;
21648 }
21649 if (obj2) {
21650 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21651 if (!SWIG_IsOK(ecode3)) {
21652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21653 }
21654 arg3 = static_cast< bool >(val3);
21655 }
21656 {
21657 PyThreadState* __tstate = wxPyBeginAllowThreads();
21658 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21659 wxPyEndAllowThreads(__tstate);
21660 if (PyErr_Occurred()) SWIG_fail;
21661 }
21662 {
21663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21664 }
21665 {
21666 if (temp2)
21667 delete arg2;
21668 }
21669 return resultobj;
21670 fail:
21671 {
21672 if (temp2)
21673 delete arg2;
21674 }
21675 return NULL;
21676 }
21677
21678
21679 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21680 PyObject *resultobj = 0;
21681 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21682 wxString *arg2 = 0 ;
21683 wxString *arg3 = 0 ;
21684 bool result;
21685 void *argp1 = 0 ;
21686 int res1 = 0 ;
21687 bool temp2 = false ;
21688 bool temp3 = false ;
21689 PyObject * obj0 = 0 ;
21690 PyObject * obj1 = 0 ;
21691 PyObject * obj2 = 0 ;
21692 char * kwnames[] = {
21693 (char *) "self",(char *) "key",(char *) "value", NULL
21694 };
21695
21696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21698 if (!SWIG_IsOK(res1)) {
21699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21700 }
21701 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21702 {
21703 arg2 = wxString_in_helper(obj1);
21704 if (arg2 == NULL) SWIG_fail;
21705 temp2 = true;
21706 }
21707 {
21708 arg3 = wxString_in_helper(obj2);
21709 if (arg3 == NULL) SWIG_fail;
21710 temp3 = true;
21711 }
21712 {
21713 PyThreadState* __tstate = wxPyBeginAllowThreads();
21714 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21715 wxPyEndAllowThreads(__tstate);
21716 if (PyErr_Occurred()) SWIG_fail;
21717 }
21718 {
21719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21720 }
21721 {
21722 if (temp2)
21723 delete arg2;
21724 }
21725 {
21726 if (temp3)
21727 delete arg3;
21728 }
21729 return resultobj;
21730 fail:
21731 {
21732 if (temp2)
21733 delete arg2;
21734 }
21735 {
21736 if (temp3)
21737 delete arg3;
21738 }
21739 return NULL;
21740 }
21741
21742
21743 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21744 PyObject *resultobj = 0;
21745 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21746 wxString *arg2 = 0 ;
21747 long arg3 ;
21748 bool result;
21749 void *argp1 = 0 ;
21750 int res1 = 0 ;
21751 bool temp2 = false ;
21752 long val3 ;
21753 int ecode3 = 0 ;
21754 PyObject * obj0 = 0 ;
21755 PyObject * obj1 = 0 ;
21756 PyObject * obj2 = 0 ;
21757 char * kwnames[] = {
21758 (char *) "self",(char *) "key",(char *) "value", NULL
21759 };
21760
21761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21763 if (!SWIG_IsOK(res1)) {
21764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21765 }
21766 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21767 {
21768 arg2 = wxString_in_helper(obj1);
21769 if (arg2 == NULL) SWIG_fail;
21770 temp2 = true;
21771 }
21772 ecode3 = SWIG_AsVal_long(obj2, &val3);
21773 if (!SWIG_IsOK(ecode3)) {
21774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21775 }
21776 arg3 = static_cast< long >(val3);
21777 {
21778 PyThreadState* __tstate = wxPyBeginAllowThreads();
21779 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21780 wxPyEndAllowThreads(__tstate);
21781 if (PyErr_Occurred()) SWIG_fail;
21782 }
21783 {
21784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21785 }
21786 {
21787 if (temp2)
21788 delete arg2;
21789 }
21790 return resultobj;
21791 fail:
21792 {
21793 if (temp2)
21794 delete arg2;
21795 }
21796 return NULL;
21797 }
21798
21799
21800 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21801 PyObject *resultobj = 0;
21802 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21803 wxString *arg2 = 0 ;
21804 double arg3 ;
21805 bool result;
21806 void *argp1 = 0 ;
21807 int res1 = 0 ;
21808 bool temp2 = false ;
21809 double val3 ;
21810 int ecode3 = 0 ;
21811 PyObject * obj0 = 0 ;
21812 PyObject * obj1 = 0 ;
21813 PyObject * obj2 = 0 ;
21814 char * kwnames[] = {
21815 (char *) "self",(char *) "key",(char *) "value", NULL
21816 };
21817
21818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21820 if (!SWIG_IsOK(res1)) {
21821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21822 }
21823 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21824 {
21825 arg2 = wxString_in_helper(obj1);
21826 if (arg2 == NULL) SWIG_fail;
21827 temp2 = true;
21828 }
21829 ecode3 = SWIG_AsVal_double(obj2, &val3);
21830 if (!SWIG_IsOK(ecode3)) {
21831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21832 }
21833 arg3 = static_cast< double >(val3);
21834 {
21835 PyThreadState* __tstate = wxPyBeginAllowThreads();
21836 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21837 wxPyEndAllowThreads(__tstate);
21838 if (PyErr_Occurred()) SWIG_fail;
21839 }
21840 {
21841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21842 }
21843 {
21844 if (temp2)
21845 delete arg2;
21846 }
21847 return resultobj;
21848 fail:
21849 {
21850 if (temp2)
21851 delete arg2;
21852 }
21853 return NULL;
21854 }
21855
21856
21857 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21858 PyObject *resultobj = 0;
21859 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21860 wxString *arg2 = 0 ;
21861 bool arg3 ;
21862 bool result;
21863 void *argp1 = 0 ;
21864 int res1 = 0 ;
21865 bool temp2 = false ;
21866 bool val3 ;
21867 int ecode3 = 0 ;
21868 PyObject * obj0 = 0 ;
21869 PyObject * obj1 = 0 ;
21870 PyObject * obj2 = 0 ;
21871 char * kwnames[] = {
21872 (char *) "self",(char *) "key",(char *) "value", NULL
21873 };
21874
21875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21877 if (!SWIG_IsOK(res1)) {
21878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21879 }
21880 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21881 {
21882 arg2 = wxString_in_helper(obj1);
21883 if (arg2 == NULL) SWIG_fail;
21884 temp2 = true;
21885 }
21886 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21887 if (!SWIG_IsOK(ecode3)) {
21888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21889 }
21890 arg3 = static_cast< bool >(val3);
21891 {
21892 PyThreadState* __tstate = wxPyBeginAllowThreads();
21893 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21894 wxPyEndAllowThreads(__tstate);
21895 if (PyErr_Occurred()) SWIG_fail;
21896 }
21897 {
21898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21899 }
21900 {
21901 if (temp2)
21902 delete arg2;
21903 }
21904 return resultobj;
21905 fail:
21906 {
21907 if (temp2)
21908 delete arg2;
21909 }
21910 return NULL;
21911 }
21912
21913
21914 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21915 PyObject *resultobj = 0;
21916 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21917 bool arg2 = (bool) false ;
21918 bool result;
21919 void *argp1 = 0 ;
21920 int res1 = 0 ;
21921 bool val2 ;
21922 int ecode2 = 0 ;
21923 PyObject * obj0 = 0 ;
21924 PyObject * obj1 = 0 ;
21925 char * kwnames[] = {
21926 (char *) "self",(char *) "currentOnly", NULL
21927 };
21928
21929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21931 if (!SWIG_IsOK(res1)) {
21932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21933 }
21934 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21935 if (obj1) {
21936 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21937 if (!SWIG_IsOK(ecode2)) {
21938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21939 }
21940 arg2 = static_cast< bool >(val2);
21941 }
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (bool)(arg1)->Flush(arg2);
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 {
21949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21950 }
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21958 PyObject *resultobj = 0;
21959 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21960 wxString *arg2 = 0 ;
21961 wxString *arg3 = 0 ;
21962 bool result;
21963 void *argp1 = 0 ;
21964 int res1 = 0 ;
21965 bool temp2 = false ;
21966 bool temp3 = false ;
21967 PyObject * obj0 = 0 ;
21968 PyObject * obj1 = 0 ;
21969 PyObject * obj2 = 0 ;
21970 char * kwnames[] = {
21971 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21972 };
21973
21974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21976 if (!SWIG_IsOK(res1)) {
21977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21978 }
21979 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21980 {
21981 arg2 = wxString_in_helper(obj1);
21982 if (arg2 == NULL) SWIG_fail;
21983 temp2 = true;
21984 }
21985 {
21986 arg3 = wxString_in_helper(obj2);
21987 if (arg3 == NULL) SWIG_fail;
21988 temp3 = true;
21989 }
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21993 wxPyEndAllowThreads(__tstate);
21994 if (PyErr_Occurred()) SWIG_fail;
21995 }
21996 {
21997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21998 }
21999 {
22000 if (temp2)
22001 delete arg2;
22002 }
22003 {
22004 if (temp3)
22005 delete arg3;
22006 }
22007 return resultobj;
22008 fail:
22009 {
22010 if (temp2)
22011 delete arg2;
22012 }
22013 {
22014 if (temp3)
22015 delete arg3;
22016 }
22017 return NULL;
22018 }
22019
22020
22021 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22022 PyObject *resultobj = 0;
22023 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22024 wxString *arg2 = 0 ;
22025 wxString *arg3 = 0 ;
22026 bool result;
22027 void *argp1 = 0 ;
22028 int res1 = 0 ;
22029 bool temp2 = false ;
22030 bool temp3 = false ;
22031 PyObject * obj0 = 0 ;
22032 PyObject * obj1 = 0 ;
22033 PyObject * obj2 = 0 ;
22034 char * kwnames[] = {
22035 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22036 };
22037
22038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22040 if (!SWIG_IsOK(res1)) {
22041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22042 }
22043 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22044 {
22045 arg2 = wxString_in_helper(obj1);
22046 if (arg2 == NULL) SWIG_fail;
22047 temp2 = true;
22048 }
22049 {
22050 arg3 = wxString_in_helper(obj2);
22051 if (arg3 == NULL) SWIG_fail;
22052 temp3 = true;
22053 }
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 {
22064 if (temp2)
22065 delete arg2;
22066 }
22067 {
22068 if (temp3)
22069 delete arg3;
22070 }
22071 return resultobj;
22072 fail:
22073 {
22074 if (temp2)
22075 delete arg2;
22076 }
22077 {
22078 if (temp3)
22079 delete arg3;
22080 }
22081 return NULL;
22082 }
22083
22084
22085 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22086 PyObject *resultobj = 0;
22087 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22088 wxString *arg2 = 0 ;
22089 bool arg3 = (bool) true ;
22090 bool result;
22091 void *argp1 = 0 ;
22092 int res1 = 0 ;
22093 bool temp2 = false ;
22094 bool val3 ;
22095 int ecode3 = 0 ;
22096 PyObject * obj0 = 0 ;
22097 PyObject * obj1 = 0 ;
22098 PyObject * obj2 = 0 ;
22099 char * kwnames[] = {
22100 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22101 };
22102
22103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22105 if (!SWIG_IsOK(res1)) {
22106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22107 }
22108 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22109 {
22110 arg2 = wxString_in_helper(obj1);
22111 if (arg2 == NULL) SWIG_fail;
22112 temp2 = true;
22113 }
22114 if (obj2) {
22115 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22116 if (!SWIG_IsOK(ecode3)) {
22117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22118 }
22119 arg3 = static_cast< bool >(val3);
22120 }
22121 {
22122 PyThreadState* __tstate = wxPyBeginAllowThreads();
22123 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 {
22128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22129 }
22130 {
22131 if (temp2)
22132 delete arg2;
22133 }
22134 return resultobj;
22135 fail:
22136 {
22137 if (temp2)
22138 delete arg2;
22139 }
22140 return NULL;
22141 }
22142
22143
22144 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22145 PyObject *resultobj = 0;
22146 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22147 wxString *arg2 = 0 ;
22148 bool result;
22149 void *argp1 = 0 ;
22150 int res1 = 0 ;
22151 bool temp2 = false ;
22152 PyObject * obj0 = 0 ;
22153 PyObject * obj1 = 0 ;
22154 char * kwnames[] = {
22155 (char *) "self",(char *) "key", NULL
22156 };
22157
22158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22160 if (!SWIG_IsOK(res1)) {
22161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22162 }
22163 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22164 {
22165 arg2 = wxString_in_helper(obj1);
22166 if (arg2 == NULL) SWIG_fail;
22167 temp2 = true;
22168 }
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 {
22176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22177 }
22178 {
22179 if (temp2)
22180 delete arg2;
22181 }
22182 return resultobj;
22183 fail:
22184 {
22185 if (temp2)
22186 delete arg2;
22187 }
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22193 PyObject *resultobj = 0;
22194 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22195 bool result;
22196 void *argp1 = 0 ;
22197 int res1 = 0 ;
22198 PyObject *swig_obj[1] ;
22199
22200 if (!args) SWIG_fail;
22201 swig_obj[0] = args;
22202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22203 if (!SWIG_IsOK(res1)) {
22204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22205 }
22206 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (bool)(arg1)->DeleteAll();
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 {
22214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22215 }
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22223 PyObject *resultobj = 0;
22224 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22225 bool arg2 = (bool) true ;
22226 void *argp1 = 0 ;
22227 int res1 = 0 ;
22228 bool val2 ;
22229 int ecode2 = 0 ;
22230 PyObject * obj0 = 0 ;
22231 PyObject * obj1 = 0 ;
22232 char * kwnames[] = {
22233 (char *) "self",(char *) "doIt", NULL
22234 };
22235
22236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22238 if (!SWIG_IsOK(res1)) {
22239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22240 }
22241 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22242 if (obj1) {
22243 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22244 if (!SWIG_IsOK(ecode2)) {
22245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22246 }
22247 arg2 = static_cast< bool >(val2);
22248 }
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 (arg1)->SetExpandEnvVars(arg2);
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 resultobj = SWIG_Py_Void();
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22263 PyObject *resultobj = 0;
22264 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22265 bool result;
22266 void *argp1 = 0 ;
22267 int res1 = 0 ;
22268 PyObject *swig_obj[1] ;
22269
22270 if (!args) SWIG_fail;
22271 swig_obj[0] = args;
22272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22273 if (!SWIG_IsOK(res1)) {
22274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22275 }
22276 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22280 wxPyEndAllowThreads(__tstate);
22281 if (PyErr_Occurred()) SWIG_fail;
22282 }
22283 {
22284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22285 }
22286 return resultobj;
22287 fail:
22288 return NULL;
22289 }
22290
22291
22292 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22293 PyObject *resultobj = 0;
22294 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22295 bool arg2 = (bool) true ;
22296 void *argp1 = 0 ;
22297 int res1 = 0 ;
22298 bool val2 ;
22299 int ecode2 = 0 ;
22300 PyObject * obj0 = 0 ;
22301 PyObject * obj1 = 0 ;
22302 char * kwnames[] = {
22303 (char *) "self",(char *) "doIt", NULL
22304 };
22305
22306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22308 if (!SWIG_IsOK(res1)) {
22309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22310 }
22311 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22312 if (obj1) {
22313 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22314 if (!SWIG_IsOK(ecode2)) {
22315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22316 }
22317 arg2 = static_cast< bool >(val2);
22318 }
22319 {
22320 PyThreadState* __tstate = wxPyBeginAllowThreads();
22321 (arg1)->SetRecordDefaults(arg2);
22322 wxPyEndAllowThreads(__tstate);
22323 if (PyErr_Occurred()) SWIG_fail;
22324 }
22325 resultobj = SWIG_Py_Void();
22326 return resultobj;
22327 fail:
22328 return NULL;
22329 }
22330
22331
22332 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22333 PyObject *resultobj = 0;
22334 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22335 bool result;
22336 void *argp1 = 0 ;
22337 int res1 = 0 ;
22338 PyObject *swig_obj[1] ;
22339
22340 if (!args) SWIG_fail;
22341 swig_obj[0] = args;
22342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22343 if (!SWIG_IsOK(res1)) {
22344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22345 }
22346 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22347 {
22348 PyThreadState* __tstate = wxPyBeginAllowThreads();
22349 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22350 wxPyEndAllowThreads(__tstate);
22351 if (PyErr_Occurred()) SWIG_fail;
22352 }
22353 {
22354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22355 }
22356 return resultobj;
22357 fail:
22358 return NULL;
22359 }
22360
22361
22362 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22363 PyObject *resultobj = 0;
22364 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22365 wxString *arg2 = 0 ;
22366 wxString result;
22367 void *argp1 = 0 ;
22368 int res1 = 0 ;
22369 bool temp2 = false ;
22370 PyObject * obj0 = 0 ;
22371 PyObject * obj1 = 0 ;
22372 char * kwnames[] = {
22373 (char *) "self",(char *) "str", NULL
22374 };
22375
22376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22378 if (!SWIG_IsOK(res1)) {
22379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22380 }
22381 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22382 {
22383 arg2 = wxString_in_helper(obj1);
22384 if (arg2 == NULL) SWIG_fail;
22385 temp2 = true;
22386 }
22387 {
22388 PyThreadState* __tstate = wxPyBeginAllowThreads();
22389 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22390 wxPyEndAllowThreads(__tstate);
22391 if (PyErr_Occurred()) SWIG_fail;
22392 }
22393 {
22394 #if wxUSE_UNICODE
22395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22396 #else
22397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22398 #endif
22399 }
22400 {
22401 if (temp2)
22402 delete arg2;
22403 }
22404 return resultobj;
22405 fail:
22406 {
22407 if (temp2)
22408 delete arg2;
22409 }
22410 return NULL;
22411 }
22412
22413
22414 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22415 PyObject *resultobj = 0;
22416 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22417 wxString result;
22418 void *argp1 = 0 ;
22419 int res1 = 0 ;
22420 PyObject *swig_obj[1] ;
22421
22422 if (!args) SWIG_fail;
22423 swig_obj[0] = args;
22424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22425 if (!SWIG_IsOK(res1)) {
22426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22427 }
22428 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22429 {
22430 PyThreadState* __tstate = wxPyBeginAllowThreads();
22431 result = ((wxConfigBase const *)arg1)->GetAppName();
22432 wxPyEndAllowThreads(__tstate);
22433 if (PyErr_Occurred()) SWIG_fail;
22434 }
22435 {
22436 #if wxUSE_UNICODE
22437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22438 #else
22439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22440 #endif
22441 }
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22449 PyObject *resultobj = 0;
22450 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22451 wxString result;
22452 void *argp1 = 0 ;
22453 int res1 = 0 ;
22454 PyObject *swig_obj[1] ;
22455
22456 if (!args) SWIG_fail;
22457 swig_obj[0] = args;
22458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22459 if (!SWIG_IsOK(res1)) {
22460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22461 }
22462 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22463 {
22464 PyThreadState* __tstate = wxPyBeginAllowThreads();
22465 result = ((wxConfigBase const *)arg1)->GetVendorName();
22466 wxPyEndAllowThreads(__tstate);
22467 if (PyErr_Occurred()) SWIG_fail;
22468 }
22469 {
22470 #if wxUSE_UNICODE
22471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22472 #else
22473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22474 #endif
22475 }
22476 return resultobj;
22477 fail:
22478 return NULL;
22479 }
22480
22481
22482 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22483 PyObject *resultobj = 0;
22484 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22485 wxString *arg2 = 0 ;
22486 void *argp1 = 0 ;
22487 int res1 = 0 ;
22488 bool temp2 = false ;
22489 PyObject * obj0 = 0 ;
22490 PyObject * obj1 = 0 ;
22491 char * kwnames[] = {
22492 (char *) "self",(char *) "appName", NULL
22493 };
22494
22495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22497 if (!SWIG_IsOK(res1)) {
22498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22499 }
22500 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22501 {
22502 arg2 = wxString_in_helper(obj1);
22503 if (arg2 == NULL) SWIG_fail;
22504 temp2 = true;
22505 }
22506 {
22507 PyThreadState* __tstate = wxPyBeginAllowThreads();
22508 (arg1)->SetAppName((wxString const &)*arg2);
22509 wxPyEndAllowThreads(__tstate);
22510 if (PyErr_Occurred()) SWIG_fail;
22511 }
22512 resultobj = SWIG_Py_Void();
22513 {
22514 if (temp2)
22515 delete arg2;
22516 }
22517 return resultobj;
22518 fail:
22519 {
22520 if (temp2)
22521 delete arg2;
22522 }
22523 return NULL;
22524 }
22525
22526
22527 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22528 PyObject *resultobj = 0;
22529 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22530 wxString *arg2 = 0 ;
22531 void *argp1 = 0 ;
22532 int res1 = 0 ;
22533 bool temp2 = false ;
22534 PyObject * obj0 = 0 ;
22535 PyObject * obj1 = 0 ;
22536 char * kwnames[] = {
22537 (char *) "self",(char *) "vendorName", NULL
22538 };
22539
22540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22542 if (!SWIG_IsOK(res1)) {
22543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22544 }
22545 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22546 {
22547 arg2 = wxString_in_helper(obj1);
22548 if (arg2 == NULL) SWIG_fail;
22549 temp2 = true;
22550 }
22551 {
22552 PyThreadState* __tstate = wxPyBeginAllowThreads();
22553 (arg1)->SetVendorName((wxString const &)*arg2);
22554 wxPyEndAllowThreads(__tstate);
22555 if (PyErr_Occurred()) SWIG_fail;
22556 }
22557 resultobj = SWIG_Py_Void();
22558 {
22559 if (temp2)
22560 delete arg2;
22561 }
22562 return resultobj;
22563 fail:
22564 {
22565 if (temp2)
22566 delete arg2;
22567 }
22568 return NULL;
22569 }
22570
22571
22572 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22573 PyObject *resultobj = 0;
22574 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22575 long arg2 ;
22576 void *argp1 = 0 ;
22577 int res1 = 0 ;
22578 long val2 ;
22579 int ecode2 = 0 ;
22580 PyObject * obj0 = 0 ;
22581 PyObject * obj1 = 0 ;
22582 char * kwnames[] = {
22583 (char *) "self",(char *) "style", NULL
22584 };
22585
22586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22588 if (!SWIG_IsOK(res1)) {
22589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22590 }
22591 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22592 ecode2 = SWIG_AsVal_long(obj1, &val2);
22593 if (!SWIG_IsOK(ecode2)) {
22594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22595 }
22596 arg2 = static_cast< long >(val2);
22597 {
22598 PyThreadState* __tstate = wxPyBeginAllowThreads();
22599 (arg1)->SetStyle(arg2);
22600 wxPyEndAllowThreads(__tstate);
22601 if (PyErr_Occurred()) SWIG_fail;
22602 }
22603 resultobj = SWIG_Py_Void();
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22611 PyObject *resultobj = 0;
22612 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22613 long result;
22614 void *argp1 = 0 ;
22615 int res1 = 0 ;
22616 PyObject *swig_obj[1] ;
22617
22618 if (!args) SWIG_fail;
22619 swig_obj[0] = args;
22620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22621 if (!SWIG_IsOK(res1)) {
22622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22623 }
22624 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22625 {
22626 PyThreadState* __tstate = wxPyBeginAllowThreads();
22627 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22628 wxPyEndAllowThreads(__tstate);
22629 if (PyErr_Occurred()) SWIG_fail;
22630 }
22631 resultobj = SWIG_From_long(static_cast< long >(result));
22632 return resultobj;
22633 fail:
22634 return NULL;
22635 }
22636
22637
22638 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22639 PyObject *obj;
22640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22641 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22642 return SWIG_Py_Void();
22643 }
22644
22645 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22646 PyObject *resultobj = 0;
22647 wxString const &arg1_defvalue = wxPyEmptyString ;
22648 wxString *arg1 = (wxString *) &arg1_defvalue ;
22649 wxString const &arg2_defvalue = wxPyEmptyString ;
22650 wxString *arg2 = (wxString *) &arg2_defvalue ;
22651 wxString const &arg3_defvalue = wxPyEmptyString ;
22652 wxString *arg3 = (wxString *) &arg3_defvalue ;
22653 wxString const &arg4_defvalue = wxPyEmptyString ;
22654 wxString *arg4 = (wxString *) &arg4_defvalue ;
22655 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22656 wxConfig *result = 0 ;
22657 bool temp1 = false ;
22658 bool temp2 = false ;
22659 bool temp3 = false ;
22660 bool temp4 = false ;
22661 long val5 ;
22662 int ecode5 = 0 ;
22663 PyObject * obj0 = 0 ;
22664 PyObject * obj1 = 0 ;
22665 PyObject * obj2 = 0 ;
22666 PyObject * obj3 = 0 ;
22667 PyObject * obj4 = 0 ;
22668 char * kwnames[] = {
22669 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22670 };
22671
22672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22673 if (obj0) {
22674 {
22675 arg1 = wxString_in_helper(obj0);
22676 if (arg1 == NULL) SWIG_fail;
22677 temp1 = true;
22678 }
22679 }
22680 if (obj1) {
22681 {
22682 arg2 = wxString_in_helper(obj1);
22683 if (arg2 == NULL) SWIG_fail;
22684 temp2 = true;
22685 }
22686 }
22687 if (obj2) {
22688 {
22689 arg3 = wxString_in_helper(obj2);
22690 if (arg3 == NULL) SWIG_fail;
22691 temp3 = true;
22692 }
22693 }
22694 if (obj3) {
22695 {
22696 arg4 = wxString_in_helper(obj3);
22697 if (arg4 == NULL) SWIG_fail;
22698 temp4 = true;
22699 }
22700 }
22701 if (obj4) {
22702 ecode5 = SWIG_AsVal_long(obj4, &val5);
22703 if (!SWIG_IsOK(ecode5)) {
22704 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22705 }
22706 arg5 = static_cast< long >(val5);
22707 }
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22711 wxPyEndAllowThreads(__tstate);
22712 if (PyErr_Occurred()) SWIG_fail;
22713 }
22714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22715 {
22716 if (temp1)
22717 delete arg1;
22718 }
22719 {
22720 if (temp2)
22721 delete arg2;
22722 }
22723 {
22724 if (temp3)
22725 delete arg3;
22726 }
22727 {
22728 if (temp4)
22729 delete arg4;
22730 }
22731 return resultobj;
22732 fail:
22733 {
22734 if (temp1)
22735 delete arg1;
22736 }
22737 {
22738 if (temp2)
22739 delete arg2;
22740 }
22741 {
22742 if (temp3)
22743 delete arg3;
22744 }
22745 {
22746 if (temp4)
22747 delete arg4;
22748 }
22749 return NULL;
22750 }
22751
22752
22753 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22754 PyObject *resultobj = 0;
22755 wxConfig *arg1 = (wxConfig *) 0 ;
22756 void *argp1 = 0 ;
22757 int res1 = 0 ;
22758 PyObject *swig_obj[1] ;
22759
22760 if (!args) SWIG_fail;
22761 swig_obj[0] = args;
22762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22763 if (!SWIG_IsOK(res1)) {
22764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22765 }
22766 arg1 = reinterpret_cast< wxConfig * >(argp1);
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 delete arg1;
22770
22771 wxPyEndAllowThreads(__tstate);
22772 if (PyErr_Occurred()) SWIG_fail;
22773 }
22774 resultobj = SWIG_Py_Void();
22775 return resultobj;
22776 fail:
22777 return NULL;
22778 }
22779
22780
22781 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22782 PyObject *obj;
22783 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22784 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22785 return SWIG_Py_Void();
22786 }
22787
22788 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22789 return SWIG_Python_InitShadowInstance(args);
22790 }
22791
22792 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22793 PyObject *resultobj = 0;
22794 wxString const &arg1_defvalue = wxPyEmptyString ;
22795 wxString *arg1 = (wxString *) &arg1_defvalue ;
22796 wxString const &arg2_defvalue = wxPyEmptyString ;
22797 wxString *arg2 = (wxString *) &arg2_defvalue ;
22798 wxString const &arg3_defvalue = wxPyEmptyString ;
22799 wxString *arg3 = (wxString *) &arg3_defvalue ;
22800 wxString const &arg4_defvalue = wxPyEmptyString ;
22801 wxString *arg4 = (wxString *) &arg4_defvalue ;
22802 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22803 wxFileConfig *result = 0 ;
22804 bool temp1 = false ;
22805 bool temp2 = false ;
22806 bool temp3 = false ;
22807 bool temp4 = false ;
22808 long val5 ;
22809 int ecode5 = 0 ;
22810 PyObject * obj0 = 0 ;
22811 PyObject * obj1 = 0 ;
22812 PyObject * obj2 = 0 ;
22813 PyObject * obj3 = 0 ;
22814 PyObject * obj4 = 0 ;
22815 char * kwnames[] = {
22816 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22817 };
22818
22819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22820 if (obj0) {
22821 {
22822 arg1 = wxString_in_helper(obj0);
22823 if (arg1 == NULL) SWIG_fail;
22824 temp1 = true;
22825 }
22826 }
22827 if (obj1) {
22828 {
22829 arg2 = wxString_in_helper(obj1);
22830 if (arg2 == NULL) SWIG_fail;
22831 temp2 = true;
22832 }
22833 }
22834 if (obj2) {
22835 {
22836 arg3 = wxString_in_helper(obj2);
22837 if (arg3 == NULL) SWIG_fail;
22838 temp3 = true;
22839 }
22840 }
22841 if (obj3) {
22842 {
22843 arg4 = wxString_in_helper(obj3);
22844 if (arg4 == NULL) SWIG_fail;
22845 temp4 = true;
22846 }
22847 }
22848 if (obj4) {
22849 ecode5 = SWIG_AsVal_long(obj4, &val5);
22850 if (!SWIG_IsOK(ecode5)) {
22851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22852 }
22853 arg5 = static_cast< long >(val5);
22854 }
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22858 wxPyEndAllowThreads(__tstate);
22859 if (PyErr_Occurred()) SWIG_fail;
22860 }
22861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22862 {
22863 if (temp1)
22864 delete arg1;
22865 }
22866 {
22867 if (temp2)
22868 delete arg2;
22869 }
22870 {
22871 if (temp3)
22872 delete arg3;
22873 }
22874 {
22875 if (temp4)
22876 delete arg4;
22877 }
22878 return resultobj;
22879 fail:
22880 {
22881 if (temp1)
22882 delete arg1;
22883 }
22884 {
22885 if (temp2)
22886 delete arg2;
22887 }
22888 {
22889 if (temp3)
22890 delete arg3;
22891 }
22892 {
22893 if (temp4)
22894 delete arg4;
22895 }
22896 return NULL;
22897 }
22898
22899
22900 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22901 PyObject *resultobj = 0;
22902 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22903 void *argp1 = 0 ;
22904 int res1 = 0 ;
22905 PyObject *swig_obj[1] ;
22906
22907 if (!args) SWIG_fail;
22908 swig_obj[0] = args;
22909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22910 if (!SWIG_IsOK(res1)) {
22911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22912 }
22913 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22914 {
22915 PyThreadState* __tstate = wxPyBeginAllowThreads();
22916 delete arg1;
22917
22918 wxPyEndAllowThreads(__tstate);
22919 if (PyErr_Occurred()) SWIG_fail;
22920 }
22921 resultobj = SWIG_Py_Void();
22922 return resultobj;
22923 fail:
22924 return NULL;
22925 }
22926
22927
22928 SWIGINTERN PyObject *_wrap_FileConfig_GetGlobalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22929 PyObject *resultobj = 0;
22930 wxString *arg1 = 0 ;
22931 wxString result;
22932 bool temp1 = false ;
22933 PyObject * obj0 = 0 ;
22934 char * kwnames[] = {
22935 (char *) "szFile", NULL
22936 };
22937
22938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileConfig_GetGlobalFileName",kwnames,&obj0)) SWIG_fail;
22939 {
22940 arg1 = wxString_in_helper(obj0);
22941 if (arg1 == NULL) SWIG_fail;
22942 temp1 = true;
22943 }
22944 {
22945 PyThreadState* __tstate = wxPyBeginAllowThreads();
22946 result = wxFileConfig::GetGlobalFileName((wxString const &)*arg1);
22947 wxPyEndAllowThreads(__tstate);
22948 if (PyErr_Occurred()) SWIG_fail;
22949 }
22950 {
22951 #if wxUSE_UNICODE
22952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22953 #else
22954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22955 #endif
22956 }
22957 {
22958 if (temp1)
22959 delete arg1;
22960 }
22961 return resultobj;
22962 fail:
22963 {
22964 if (temp1)
22965 delete arg1;
22966 }
22967 return NULL;
22968 }
22969
22970
22971 SWIGINTERN PyObject *_wrap_FileConfig_GetLocalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22972 PyObject *resultobj = 0;
22973 wxString *arg1 = 0 ;
22974 int arg2 = (int) 0 ;
22975 wxString result;
22976 bool temp1 = false ;
22977 int val2 ;
22978 int ecode2 = 0 ;
22979 PyObject * obj0 = 0 ;
22980 PyObject * obj1 = 0 ;
22981 char * kwnames[] = {
22982 (char *) "szFile",(char *) "style", NULL
22983 };
22984
22985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FileConfig_GetLocalFileName",kwnames,&obj0,&obj1)) SWIG_fail;
22986 {
22987 arg1 = wxString_in_helper(obj0);
22988 if (arg1 == NULL) SWIG_fail;
22989 temp1 = true;
22990 }
22991 if (obj1) {
22992 ecode2 = SWIG_AsVal_int(obj1, &val2);
22993 if (!SWIG_IsOK(ecode2)) {
22994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileConfig_GetLocalFileName" "', expected argument " "2"" of type '" "int""'");
22995 }
22996 arg2 = static_cast< int >(val2);
22997 }
22998 {
22999 PyThreadState* __tstate = wxPyBeginAllowThreads();
23000 result = wxFileConfig::GetLocalFileName((wxString const &)*arg1,arg2);
23001 wxPyEndAllowThreads(__tstate);
23002 if (PyErr_Occurred()) SWIG_fail;
23003 }
23004 {
23005 #if wxUSE_UNICODE
23006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23007 #else
23008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23009 #endif
23010 }
23011 {
23012 if (temp1)
23013 delete arg1;
23014 }
23015 return resultobj;
23016 fail:
23017 {
23018 if (temp1)
23019 delete arg1;
23020 }
23021 return NULL;
23022 }
23023
23024
23025 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23026 PyObject *obj;
23027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23028 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
23029 return SWIG_Py_Void();
23030 }
23031
23032 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23033 return SWIG_Python_InitShadowInstance(args);
23034 }
23035
23036 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23037 PyObject *resultobj = 0;
23038 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
23039 wxString *arg2 = 0 ;
23040 wxConfigPathChanger *result = 0 ;
23041 void *argp1 = 0 ;
23042 int res1 = 0 ;
23043 bool temp2 = false ;
23044 PyObject * obj0 = 0 ;
23045 PyObject * obj1 = 0 ;
23046 char * kwnames[] = {
23047 (char *) "config",(char *) "entry", NULL
23048 };
23049
23050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
23051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
23052 if (!SWIG_IsOK(res1)) {
23053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
23054 }
23055 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23056 {
23057 arg2 = wxString_in_helper(obj1);
23058 if (arg2 == NULL) SWIG_fail;
23059 temp2 = true;
23060 }
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23068 {
23069 if (temp2)
23070 delete arg2;
23071 }
23072 return resultobj;
23073 fail:
23074 {
23075 if (temp2)
23076 delete arg2;
23077 }
23078 return NULL;
23079 }
23080
23081
23082 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23083 PyObject *resultobj = 0;
23084 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 PyObject *swig_obj[1] ;
23088
23089 if (!args) SWIG_fail;
23090 swig_obj[0] = args;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23094 }
23095 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 delete arg1;
23099
23100 wxPyEndAllowThreads(__tstate);
23101 if (PyErr_Occurred()) SWIG_fail;
23102 }
23103 resultobj = SWIG_Py_Void();
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23111 PyObject *resultobj = 0;
23112 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23113 wxString *result = 0 ;
23114 void *argp1 = 0 ;
23115 int res1 = 0 ;
23116 PyObject *swig_obj[1] ;
23117
23118 if (!args) SWIG_fail;
23119 swig_obj[0] = args;
23120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23121 if (!SWIG_IsOK(res1)) {
23122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23123 }
23124 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23125 {
23126 PyThreadState* __tstate = wxPyBeginAllowThreads();
23127 {
23128 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23129 result = (wxString *) &_result_ref;
23130 }
23131 wxPyEndAllowThreads(__tstate);
23132 if (PyErr_Occurred()) SWIG_fail;
23133 }
23134 {
23135 #if wxUSE_UNICODE
23136 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23137 #else
23138 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23139 #endif
23140 }
23141 return resultobj;
23142 fail:
23143 return NULL;
23144 }
23145
23146
23147 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23148 PyObject *obj;
23149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23150 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23151 return SWIG_Py_Void();
23152 }
23153
23154 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23155 return SWIG_Python_InitShadowInstance(args);
23156 }
23157
23158 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23159 PyObject *resultobj = 0;
23160 wxString *arg1 = 0 ;
23161 wxString result;
23162 bool temp1 = false ;
23163 PyObject * obj0 = 0 ;
23164 char * kwnames[] = {
23165 (char *) "sz", NULL
23166 };
23167
23168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23169 {
23170 arg1 = wxString_in_helper(obj0);
23171 if (arg1 == NULL) SWIG_fail;
23172 temp1 = true;
23173 }
23174 {
23175 PyThreadState* __tstate = wxPyBeginAllowThreads();
23176 result = wxExpandEnvVars((wxString const &)*arg1);
23177 wxPyEndAllowThreads(__tstate);
23178 if (PyErr_Occurred()) SWIG_fail;
23179 }
23180 {
23181 #if wxUSE_UNICODE
23182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23183 #else
23184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23185 #endif
23186 }
23187 {
23188 if (temp1)
23189 delete arg1;
23190 }
23191 return resultobj;
23192 fail:
23193 {
23194 if (temp1)
23195 delete arg1;
23196 }
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23202 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23203 return 1;
23204 }
23205
23206
23207 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23208 PyObject *pyobj = 0;
23209
23210 {
23211 #if wxUSE_UNICODE
23212 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23213 #else
23214 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23215 #endif
23216 }
23217 return pyobj;
23218 }
23219
23220
23221 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23222 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23223 return 1;
23224 }
23225
23226
23227 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23228 PyObject *pyobj = 0;
23229
23230 {
23231 #if wxUSE_UNICODE
23232 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23233 #else
23234 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23235 #endif
23236 }
23237 return pyobj;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj = 0;
23243 wxDateTime::Country arg1 ;
23244 int val1 ;
23245 int ecode1 = 0 ;
23246 PyObject * obj0 = 0 ;
23247 char * kwnames[] = {
23248 (char *) "country", NULL
23249 };
23250
23251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23252 ecode1 = SWIG_AsVal_int(obj0, &val1);
23253 if (!SWIG_IsOK(ecode1)) {
23254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23255 }
23256 arg1 = static_cast< wxDateTime::Country >(val1);
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 wxDateTime::SetCountry(arg1);
23260 wxPyEndAllowThreads(__tstate);
23261 if (PyErr_Occurred()) SWIG_fail;
23262 }
23263 resultobj = SWIG_Py_Void();
23264 return resultobj;
23265 fail:
23266 return NULL;
23267 }
23268
23269
23270 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23271 PyObject *resultobj = 0;
23272 wxDateTime::Country result;
23273
23274 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23275 {
23276 PyThreadState* __tstate = wxPyBeginAllowThreads();
23277 result = (wxDateTime::Country)wxDateTime::GetCountry();
23278 wxPyEndAllowThreads(__tstate);
23279 if (PyErr_Occurred()) SWIG_fail;
23280 }
23281 resultobj = SWIG_From_int(static_cast< int >(result));
23282 return resultobj;
23283 fail:
23284 return NULL;
23285 }
23286
23287
23288 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23289 PyObject *resultobj = 0;
23290 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23291 bool result;
23292 int val1 ;
23293 int ecode1 = 0 ;
23294 PyObject * obj0 = 0 ;
23295 char * kwnames[] = {
23296 (char *) "country", NULL
23297 };
23298
23299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23300 if (obj0) {
23301 ecode1 = SWIG_AsVal_int(obj0, &val1);
23302 if (!SWIG_IsOK(ecode1)) {
23303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23304 }
23305 arg1 = static_cast< wxDateTime::Country >(val1);
23306 }
23307 {
23308 PyThreadState* __tstate = wxPyBeginAllowThreads();
23309 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23310 wxPyEndAllowThreads(__tstate);
23311 if (PyErr_Occurred()) SWIG_fail;
23312 }
23313 {
23314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23315 }
23316 return resultobj;
23317 fail:
23318 return NULL;
23319 }
23320
23321
23322 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23323 PyObject *resultobj = 0;
23324 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23325 int result;
23326 int val1 ;
23327 int ecode1 = 0 ;
23328 PyObject * obj0 = 0 ;
23329 char * kwnames[] = {
23330 (char *) "cal", NULL
23331 };
23332
23333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23334 if (obj0) {
23335 ecode1 = SWIG_AsVal_int(obj0, &val1);
23336 if (!SWIG_IsOK(ecode1)) {
23337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23338 }
23339 arg1 = static_cast< wxDateTime::Calendar >(val1);
23340 }
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 result = (int)wxDateTime::GetCurrentYear(arg1);
23344 wxPyEndAllowThreads(__tstate);
23345 if (PyErr_Occurred()) SWIG_fail;
23346 }
23347 resultobj = SWIG_From_int(static_cast< int >(result));
23348 return resultobj;
23349 fail:
23350 return NULL;
23351 }
23352
23353
23354 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23355 PyObject *resultobj = 0;
23356 int arg1 ;
23357 int result;
23358 int val1 ;
23359 int ecode1 = 0 ;
23360 PyObject * obj0 = 0 ;
23361 char * kwnames[] = {
23362 (char *) "year", NULL
23363 };
23364
23365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23366 ecode1 = SWIG_AsVal_int(obj0, &val1);
23367 if (!SWIG_IsOK(ecode1)) {
23368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23369 }
23370 arg1 = static_cast< int >(val1);
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 result = (int)wxDateTime::ConvertYearToBC(arg1);
23374 wxPyEndAllowThreads(__tstate);
23375 if (PyErr_Occurred()) SWIG_fail;
23376 }
23377 resultobj = SWIG_From_int(static_cast< int >(result));
23378 return resultobj;
23379 fail:
23380 return NULL;
23381 }
23382
23383
23384 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23385 PyObject *resultobj = 0;
23386 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23387 wxDateTime::Month result;
23388 int val1 ;
23389 int ecode1 = 0 ;
23390 PyObject * obj0 = 0 ;
23391 char * kwnames[] = {
23392 (char *) "cal", NULL
23393 };
23394
23395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23396 if (obj0) {
23397 ecode1 = SWIG_AsVal_int(obj0, &val1);
23398 if (!SWIG_IsOK(ecode1)) {
23399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23400 }
23401 arg1 = static_cast< wxDateTime::Calendar >(val1);
23402 }
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 resultobj = SWIG_From_int(static_cast< int >(result));
23410 return resultobj;
23411 fail:
23412 return NULL;
23413 }
23414
23415
23416 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23417 PyObject *resultobj = 0;
23418 int arg1 = (int) wxDateTime::Inv_Year ;
23419 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23420 bool result;
23421 int val1 ;
23422 int ecode1 = 0 ;
23423 int val2 ;
23424 int ecode2 = 0 ;
23425 PyObject * obj0 = 0 ;
23426 PyObject * obj1 = 0 ;
23427 char * kwnames[] = {
23428 (char *) "year",(char *) "cal", NULL
23429 };
23430
23431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23432 if (obj0) {
23433 ecode1 = SWIG_AsVal_int(obj0, &val1);
23434 if (!SWIG_IsOK(ecode1)) {
23435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23436 }
23437 arg1 = static_cast< int >(val1);
23438 }
23439 if (obj1) {
23440 ecode2 = SWIG_AsVal_int(obj1, &val2);
23441 if (!SWIG_IsOK(ecode2)) {
23442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23443 }
23444 arg2 = static_cast< wxDateTime::Calendar >(val2);
23445 }
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23449 wxPyEndAllowThreads(__tstate);
23450 if (PyErr_Occurred()) SWIG_fail;
23451 }
23452 {
23453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23454 }
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23462 PyObject *resultobj = 0;
23463 int arg1 = (int) wxDateTime::Inv_Year ;
23464 int result;
23465 int val1 ;
23466 int ecode1 = 0 ;
23467 PyObject * obj0 = 0 ;
23468 char * kwnames[] = {
23469 (char *) "year", NULL
23470 };
23471
23472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23473 if (obj0) {
23474 ecode1 = SWIG_AsVal_int(obj0, &val1);
23475 if (!SWIG_IsOK(ecode1)) {
23476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23477 }
23478 arg1 = static_cast< int >(val1);
23479 }
23480 {
23481 PyThreadState* __tstate = wxPyBeginAllowThreads();
23482 result = (int)wxDateTime::GetCentury(arg1);
23483 wxPyEndAllowThreads(__tstate);
23484 if (PyErr_Occurred()) SWIG_fail;
23485 }
23486 resultobj = SWIG_From_int(static_cast< int >(result));
23487 return resultobj;
23488 fail:
23489 return NULL;
23490 }
23491
23492
23493 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23494 PyObject *resultobj = 0;
23495 int arg1 ;
23496 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23497 int result;
23498 int val1 ;
23499 int ecode1 = 0 ;
23500 int val2 ;
23501 int ecode2 = 0 ;
23502 PyObject * obj0 = 0 ;
23503 PyObject * obj1 = 0 ;
23504 char * kwnames[] = {
23505 (char *) "year",(char *) "cal", NULL
23506 };
23507
23508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23509 ecode1 = SWIG_AsVal_int(obj0, &val1);
23510 if (!SWIG_IsOK(ecode1)) {
23511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23512 }
23513 arg1 = static_cast< int >(val1);
23514 if (obj1) {
23515 ecode2 = SWIG_AsVal_int(obj1, &val2);
23516 if (!SWIG_IsOK(ecode2)) {
23517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23518 }
23519 arg2 = static_cast< wxDateTime::Calendar >(val2);
23520 }
23521 {
23522 PyThreadState* __tstate = wxPyBeginAllowThreads();
23523 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23524 wxPyEndAllowThreads(__tstate);
23525 if (PyErr_Occurred()) SWIG_fail;
23526 }
23527 resultobj = SWIG_From_int(static_cast< int >(result));
23528 return resultobj;
23529 fail:
23530 return NULL;
23531 }
23532
23533
23534 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23535 PyObject *resultobj = 0;
23536 wxDateTime::Month arg1 ;
23537 int arg2 = (int) wxDateTime::Inv_Year ;
23538 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23539 int result;
23540 int val1 ;
23541 int ecode1 = 0 ;
23542 int val2 ;
23543 int ecode2 = 0 ;
23544 int val3 ;
23545 int ecode3 = 0 ;
23546 PyObject * obj0 = 0 ;
23547 PyObject * obj1 = 0 ;
23548 PyObject * obj2 = 0 ;
23549 char * kwnames[] = {
23550 (char *) "month",(char *) "year",(char *) "cal", NULL
23551 };
23552
23553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23554 ecode1 = SWIG_AsVal_int(obj0, &val1);
23555 if (!SWIG_IsOK(ecode1)) {
23556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23557 }
23558 arg1 = static_cast< wxDateTime::Month >(val1);
23559 if (obj1) {
23560 ecode2 = SWIG_AsVal_int(obj1, &val2);
23561 if (!SWIG_IsOK(ecode2)) {
23562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23563 }
23564 arg2 = static_cast< int >(val2);
23565 }
23566 if (obj2) {
23567 ecode3 = SWIG_AsVal_int(obj2, &val3);
23568 if (!SWIG_IsOK(ecode3)) {
23569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23570 }
23571 arg3 = static_cast< wxDateTime::Calendar >(val3);
23572 }
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 resultobj = SWIG_From_int(static_cast< int >(result));
23580 return resultobj;
23581 fail:
23582 return NULL;
23583 }
23584
23585
23586 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23587 PyObject *resultobj = 0;
23588 wxDateTime::Month arg1 ;
23589 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23590 wxString result;
23591 int val1 ;
23592 int ecode1 = 0 ;
23593 int val2 ;
23594 int ecode2 = 0 ;
23595 PyObject * obj0 = 0 ;
23596 PyObject * obj1 = 0 ;
23597 char * kwnames[] = {
23598 (char *) "month",(char *) "flags", NULL
23599 };
23600
23601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23602 ecode1 = SWIG_AsVal_int(obj0, &val1);
23603 if (!SWIG_IsOK(ecode1)) {
23604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23605 }
23606 arg1 = static_cast< wxDateTime::Month >(val1);
23607 if (obj1) {
23608 ecode2 = SWIG_AsVal_int(obj1, &val2);
23609 if (!SWIG_IsOK(ecode2)) {
23610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23611 }
23612 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23613 }
23614 {
23615 PyThreadState* __tstate = wxPyBeginAllowThreads();
23616 result = wxDateTime::GetMonthName(arg1,arg2);
23617 wxPyEndAllowThreads(__tstate);
23618 if (PyErr_Occurred()) SWIG_fail;
23619 }
23620 {
23621 #if wxUSE_UNICODE
23622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23623 #else
23624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23625 #endif
23626 }
23627 return resultobj;
23628 fail:
23629 return NULL;
23630 }
23631
23632
23633 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23634 PyObject *resultobj = 0;
23635 wxDateTime::WeekDay arg1 ;
23636 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23637 wxString result;
23638 int val1 ;
23639 int ecode1 = 0 ;
23640 int val2 ;
23641 int ecode2 = 0 ;
23642 PyObject * obj0 = 0 ;
23643 PyObject * obj1 = 0 ;
23644 char * kwnames[] = {
23645 (char *) "weekday",(char *) "flags", NULL
23646 };
23647
23648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23649 ecode1 = SWIG_AsVal_int(obj0, &val1);
23650 if (!SWIG_IsOK(ecode1)) {
23651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23652 }
23653 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23654 if (obj1) {
23655 ecode2 = SWIG_AsVal_int(obj1, &val2);
23656 if (!SWIG_IsOK(ecode2)) {
23657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23658 }
23659 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23660 }
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = wxDateTime::GetWeekDayName(arg1,arg2);
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 {
23668 #if wxUSE_UNICODE
23669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23670 #else
23671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23672 #endif
23673 }
23674 return resultobj;
23675 fail:
23676 return NULL;
23677 }
23678
23679
23680 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23681 PyObject *resultobj = 0;
23682 PyObject *result = 0 ;
23683
23684 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 result = (PyObject *)wxDateTime_GetAmPmStrings();
23688 wxPyEndAllowThreads(__tstate);
23689 if (PyErr_Occurred()) SWIG_fail;
23690 }
23691 resultobj = result;
23692 return resultobj;
23693 fail:
23694 return NULL;
23695 }
23696
23697
23698 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23699 PyObject *resultobj = 0;
23700 int arg1 = (int) wxDateTime::Inv_Year ;
23701 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23702 bool result;
23703 int val1 ;
23704 int ecode1 = 0 ;
23705 int val2 ;
23706 int ecode2 = 0 ;
23707 PyObject * obj0 = 0 ;
23708 PyObject * obj1 = 0 ;
23709 char * kwnames[] = {
23710 (char *) "year",(char *) "country", NULL
23711 };
23712
23713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23714 if (obj0) {
23715 ecode1 = SWIG_AsVal_int(obj0, &val1);
23716 if (!SWIG_IsOK(ecode1)) {
23717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23718 }
23719 arg1 = static_cast< int >(val1);
23720 }
23721 if (obj1) {
23722 ecode2 = SWIG_AsVal_int(obj1, &val2);
23723 if (!SWIG_IsOK(ecode2)) {
23724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23725 }
23726 arg2 = static_cast< wxDateTime::Country >(val2);
23727 }
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 {
23735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23736 }
23737 return resultobj;
23738 fail:
23739 return NULL;
23740 }
23741
23742
23743 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23744 PyObject *resultobj = 0;
23745 int arg1 = (int) wxDateTime::Inv_Year ;
23746 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23747 wxDateTime result;
23748 int val1 ;
23749 int ecode1 = 0 ;
23750 int val2 ;
23751 int ecode2 = 0 ;
23752 PyObject * obj0 = 0 ;
23753 PyObject * obj1 = 0 ;
23754 char * kwnames[] = {
23755 (char *) "year",(char *) "country", NULL
23756 };
23757
23758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23759 if (obj0) {
23760 ecode1 = SWIG_AsVal_int(obj0, &val1);
23761 if (!SWIG_IsOK(ecode1)) {
23762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23763 }
23764 arg1 = static_cast< int >(val1);
23765 }
23766 if (obj1) {
23767 ecode2 = SWIG_AsVal_int(obj1, &val2);
23768 if (!SWIG_IsOK(ecode2)) {
23769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23770 }
23771 arg2 = static_cast< wxDateTime::Country >(val2);
23772 }
23773 {
23774 PyThreadState* __tstate = wxPyBeginAllowThreads();
23775 result = wxDateTime::GetBeginDST(arg1,arg2);
23776 wxPyEndAllowThreads(__tstate);
23777 if (PyErr_Occurred()) SWIG_fail;
23778 }
23779 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23780 return resultobj;
23781 fail:
23782 return NULL;
23783 }
23784
23785
23786 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj = 0;
23788 int arg1 = (int) wxDateTime::Inv_Year ;
23789 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23790 wxDateTime result;
23791 int val1 ;
23792 int ecode1 = 0 ;
23793 int val2 ;
23794 int ecode2 = 0 ;
23795 PyObject * obj0 = 0 ;
23796 PyObject * obj1 = 0 ;
23797 char * kwnames[] = {
23798 (char *) "year",(char *) "country", NULL
23799 };
23800
23801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23802 if (obj0) {
23803 ecode1 = SWIG_AsVal_int(obj0, &val1);
23804 if (!SWIG_IsOK(ecode1)) {
23805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23806 }
23807 arg1 = static_cast< int >(val1);
23808 }
23809 if (obj1) {
23810 ecode2 = SWIG_AsVal_int(obj1, &val2);
23811 if (!SWIG_IsOK(ecode2)) {
23812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23813 }
23814 arg2 = static_cast< wxDateTime::Country >(val2);
23815 }
23816 {
23817 PyThreadState* __tstate = wxPyBeginAllowThreads();
23818 result = wxDateTime::GetEndDST(arg1,arg2);
23819 wxPyEndAllowThreads(__tstate);
23820 if (PyErr_Occurred()) SWIG_fail;
23821 }
23822 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23823 return resultobj;
23824 fail:
23825 return NULL;
23826 }
23827
23828
23829 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23830 PyObject *resultobj = 0;
23831 wxDateTime result;
23832
23833 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23834 {
23835 PyThreadState* __tstate = wxPyBeginAllowThreads();
23836 result = wxDateTime::Now();
23837 wxPyEndAllowThreads(__tstate);
23838 if (PyErr_Occurred()) SWIG_fail;
23839 }
23840 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23848 PyObject *resultobj = 0;
23849 wxDateTime result;
23850
23851 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = wxDateTime::UNow();
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23866 PyObject *resultobj = 0;
23867 wxDateTime result;
23868
23869 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = wxDateTime::Today();
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *resultobj = 0;
23885 wxDateTime *result = 0 ;
23886
23887 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23888 {
23889 PyThreadState* __tstate = wxPyBeginAllowThreads();
23890 result = (wxDateTime *)new wxDateTime();
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23902 PyObject *resultobj = 0;
23903 time_t arg1 ;
23904 wxDateTime *result = 0 ;
23905 unsigned int val1 ;
23906 int ecode1 = 0 ;
23907 PyObject * obj0 = 0 ;
23908 char * kwnames[] = {
23909 (char *) "timet", NULL
23910 };
23911
23912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23913 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23914 if (!SWIG_IsOK(ecode1)) {
23915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23916 }
23917 arg1 = static_cast< time_t >(val1);
23918 {
23919 PyThreadState* __tstate = wxPyBeginAllowThreads();
23920 result = (wxDateTime *)new wxDateTime(arg1);
23921 wxPyEndAllowThreads(__tstate);
23922 if (PyErr_Occurred()) SWIG_fail;
23923 }
23924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23932 PyObject *resultobj = 0;
23933 double arg1 ;
23934 wxDateTime *result = 0 ;
23935 double val1 ;
23936 int ecode1 = 0 ;
23937 PyObject * obj0 = 0 ;
23938 char * kwnames[] = {
23939 (char *) "jdn", NULL
23940 };
23941
23942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23943 ecode1 = SWIG_AsVal_double(obj0, &val1);
23944 if (!SWIG_IsOK(ecode1)) {
23945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23946 }
23947 arg1 = static_cast< double >(val1);
23948 {
23949 PyThreadState* __tstate = wxPyBeginAllowThreads();
23950 result = (wxDateTime *)new wxDateTime(arg1);
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23962 PyObject *resultobj = 0;
23963 int arg1 ;
23964 int arg2 = (int) 0 ;
23965 int arg3 = (int) 0 ;
23966 int arg4 = (int) 0 ;
23967 wxDateTime *result = 0 ;
23968 int val1 ;
23969 int ecode1 = 0 ;
23970 int val2 ;
23971 int ecode2 = 0 ;
23972 int val3 ;
23973 int ecode3 = 0 ;
23974 int val4 ;
23975 int ecode4 = 0 ;
23976 PyObject * obj0 = 0 ;
23977 PyObject * obj1 = 0 ;
23978 PyObject * obj2 = 0 ;
23979 PyObject * obj3 = 0 ;
23980 char * kwnames[] = {
23981 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23982 };
23983
23984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23985 ecode1 = SWIG_AsVal_int(obj0, &val1);
23986 if (!SWIG_IsOK(ecode1)) {
23987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23988 }
23989 arg1 = static_cast< int >(val1);
23990 if (obj1) {
23991 ecode2 = SWIG_AsVal_int(obj1, &val2);
23992 if (!SWIG_IsOK(ecode2)) {
23993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23994 }
23995 arg2 = static_cast< int >(val2);
23996 }
23997 if (obj2) {
23998 ecode3 = SWIG_AsVal_int(obj2, &val3);
23999 if (!SWIG_IsOK(ecode3)) {
24000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
24001 }
24002 arg3 = static_cast< int >(val3);
24003 }
24004 if (obj3) {
24005 ecode4 = SWIG_AsVal_int(obj3, &val4);
24006 if (!SWIG_IsOK(ecode4)) {
24007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
24008 }
24009 arg4 = static_cast< int >(val4);
24010 }
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
24014 wxPyEndAllowThreads(__tstate);
24015 if (PyErr_Occurred()) SWIG_fail;
24016 }
24017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24018 return resultobj;
24019 fail:
24020 return NULL;
24021 }
24022
24023
24024 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24025 PyObject *resultobj = 0;
24026 int arg1 ;
24027 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24028 int arg3 = (int) wxDateTime::Inv_Year ;
24029 int arg4 = (int) 0 ;
24030 int arg5 = (int) 0 ;
24031 int arg6 = (int) 0 ;
24032 int arg7 = (int) 0 ;
24033 wxDateTime *result = 0 ;
24034 int val1 ;
24035 int ecode1 = 0 ;
24036 int val2 ;
24037 int ecode2 = 0 ;
24038 int val3 ;
24039 int ecode3 = 0 ;
24040 int val4 ;
24041 int ecode4 = 0 ;
24042 int val5 ;
24043 int ecode5 = 0 ;
24044 int val6 ;
24045 int ecode6 = 0 ;
24046 int val7 ;
24047 int ecode7 = 0 ;
24048 PyObject * obj0 = 0 ;
24049 PyObject * obj1 = 0 ;
24050 PyObject * obj2 = 0 ;
24051 PyObject * obj3 = 0 ;
24052 PyObject * obj4 = 0 ;
24053 PyObject * obj5 = 0 ;
24054 PyObject * obj6 = 0 ;
24055 char * kwnames[] = {
24056 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24057 };
24058
24059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24060 ecode1 = SWIG_AsVal_int(obj0, &val1);
24061 if (!SWIG_IsOK(ecode1)) {
24062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24063 }
24064 arg1 = static_cast< int >(val1);
24065 if (obj1) {
24066 ecode2 = SWIG_AsVal_int(obj1, &val2);
24067 if (!SWIG_IsOK(ecode2)) {
24068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24069 }
24070 arg2 = static_cast< wxDateTime::Month >(val2);
24071 }
24072 if (obj2) {
24073 ecode3 = SWIG_AsVal_int(obj2, &val3);
24074 if (!SWIG_IsOK(ecode3)) {
24075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24076 }
24077 arg3 = static_cast< int >(val3);
24078 }
24079 if (obj3) {
24080 ecode4 = SWIG_AsVal_int(obj3, &val4);
24081 if (!SWIG_IsOK(ecode4)) {
24082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24083 }
24084 arg4 = static_cast< int >(val4);
24085 }
24086 if (obj4) {
24087 ecode5 = SWIG_AsVal_int(obj4, &val5);
24088 if (!SWIG_IsOK(ecode5)) {
24089 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24090 }
24091 arg5 = static_cast< int >(val5);
24092 }
24093 if (obj5) {
24094 ecode6 = SWIG_AsVal_int(obj5, &val6);
24095 if (!SWIG_IsOK(ecode6)) {
24096 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24097 }
24098 arg6 = static_cast< int >(val6);
24099 }
24100 if (obj6) {
24101 ecode7 = SWIG_AsVal_int(obj6, &val7);
24102 if (!SWIG_IsOK(ecode7)) {
24103 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24104 }
24105 arg7 = static_cast< int >(val7);
24106 }
24107 {
24108 PyThreadState* __tstate = wxPyBeginAllowThreads();
24109 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24110 wxPyEndAllowThreads(__tstate);
24111 if (PyErr_Occurred()) SWIG_fail;
24112 }
24113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24114 return resultobj;
24115 fail:
24116 return NULL;
24117 }
24118
24119
24120 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24121 PyObject *resultobj = 0;
24122 wxDateTime *arg1 = 0 ;
24123 wxDateTime *result = 0 ;
24124 void *argp1 = 0 ;
24125 int res1 = 0 ;
24126 PyObject * obj0 = 0 ;
24127 char * kwnames[] = {
24128 (char *) "date", NULL
24129 };
24130
24131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24132 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24133 if (!SWIG_IsOK(res1)) {
24134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24135 }
24136 if (!argp1) {
24137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24138 }
24139 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24140 {
24141 PyThreadState* __tstate = wxPyBeginAllowThreads();
24142 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24147 return resultobj;
24148 fail:
24149 return NULL;
24150 }
24151
24152
24153 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24154 PyObject *resultobj = 0;
24155 wxDateTime *arg1 = (wxDateTime *) 0 ;
24156 void *argp1 = 0 ;
24157 int res1 = 0 ;
24158 PyObject *swig_obj[1] ;
24159
24160 if (!args) SWIG_fail;
24161 swig_obj[0] = args;
24162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24163 if (!SWIG_IsOK(res1)) {
24164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24165 }
24166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24167 {
24168 PyThreadState* __tstate = wxPyBeginAllowThreads();
24169 delete arg1;
24170
24171 wxPyEndAllowThreads(__tstate);
24172 if (PyErr_Occurred()) SWIG_fail;
24173 }
24174 resultobj = SWIG_Py_Void();
24175 return resultobj;
24176 fail:
24177 return NULL;
24178 }
24179
24180
24181 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24182 PyObject *resultobj = 0;
24183 wxDateTime *arg1 = (wxDateTime *) 0 ;
24184 wxDateTime *result = 0 ;
24185 void *argp1 = 0 ;
24186 int res1 = 0 ;
24187 PyObject *swig_obj[1] ;
24188
24189 if (!args) SWIG_fail;
24190 swig_obj[0] = args;
24191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24192 if (!SWIG_IsOK(res1)) {
24193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24194 }
24195 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24196 {
24197 PyThreadState* __tstate = wxPyBeginAllowThreads();
24198 {
24199 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24200 result = (wxDateTime *) &_result_ref;
24201 }
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24213 PyObject *resultobj = 0;
24214 wxDateTime *arg1 = (wxDateTime *) 0 ;
24215 time_t arg2 ;
24216 wxDateTime *result = 0 ;
24217 void *argp1 = 0 ;
24218 int res1 = 0 ;
24219 unsigned int val2 ;
24220 int ecode2 = 0 ;
24221 PyObject * obj0 = 0 ;
24222 PyObject * obj1 = 0 ;
24223 char * kwnames[] = {
24224 (char *) "self",(char *) "timet", NULL
24225 };
24226
24227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24229 if (!SWIG_IsOK(res1)) {
24230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24231 }
24232 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24233 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24234 if (!SWIG_IsOK(ecode2)) {
24235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24236 }
24237 arg2 = static_cast< time_t >(val2);
24238 {
24239 PyThreadState* __tstate = wxPyBeginAllowThreads();
24240 {
24241 wxDateTime &_result_ref = (arg1)->Set(arg2);
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_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24255 PyObject *resultobj = 0;
24256 wxDateTime *arg1 = (wxDateTime *) 0 ;
24257 double arg2 ;
24258 wxDateTime *result = 0 ;
24259 void *argp1 = 0 ;
24260 int res1 = 0 ;
24261 double val2 ;
24262 int ecode2 = 0 ;
24263 PyObject * obj0 = 0 ;
24264 PyObject * obj1 = 0 ;
24265 char * kwnames[] = {
24266 (char *) "self",(char *) "jdn", NULL
24267 };
24268
24269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",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_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24273 }
24274 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24275 ecode2 = SWIG_AsVal_double(obj1, &val2);
24276 if (!SWIG_IsOK(ecode2)) {
24277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24278 }
24279 arg2 = static_cast< double >(val2);
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 {
24283 wxDateTime &_result_ref = (arg1)->Set(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_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj = 0;
24298 wxDateTime *arg1 = (wxDateTime *) 0 ;
24299 int arg2 ;
24300 int arg3 = (int) 0 ;
24301 int arg4 = (int) 0 ;
24302 int arg5 = (int) 0 ;
24303 wxDateTime *result = 0 ;
24304 void *argp1 = 0 ;
24305 int res1 = 0 ;
24306 int val2 ;
24307 int ecode2 = 0 ;
24308 int val3 ;
24309 int ecode3 = 0 ;
24310 int val4 ;
24311 int ecode4 = 0 ;
24312 int val5 ;
24313 int ecode5 = 0 ;
24314 PyObject * obj0 = 0 ;
24315 PyObject * obj1 = 0 ;
24316 PyObject * obj2 = 0 ;
24317 PyObject * obj3 = 0 ;
24318 PyObject * obj4 = 0 ;
24319 char * kwnames[] = {
24320 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24321 };
24322
24323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24325 if (!SWIG_IsOK(res1)) {
24326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24327 }
24328 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24329 ecode2 = SWIG_AsVal_int(obj1, &val2);
24330 if (!SWIG_IsOK(ecode2)) {
24331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24332 }
24333 arg2 = static_cast< int >(val2);
24334 if (obj2) {
24335 ecode3 = SWIG_AsVal_int(obj2, &val3);
24336 if (!SWIG_IsOK(ecode3)) {
24337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24338 }
24339 arg3 = static_cast< int >(val3);
24340 }
24341 if (obj3) {
24342 ecode4 = SWIG_AsVal_int(obj3, &val4);
24343 if (!SWIG_IsOK(ecode4)) {
24344 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24345 }
24346 arg4 = static_cast< int >(val4);
24347 }
24348 if (obj4) {
24349 ecode5 = SWIG_AsVal_int(obj4, &val5);
24350 if (!SWIG_IsOK(ecode5)) {
24351 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24352 }
24353 arg5 = static_cast< int >(val5);
24354 }
24355 {
24356 PyThreadState* __tstate = wxPyBeginAllowThreads();
24357 {
24358 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24359 result = (wxDateTime *) &_result_ref;
24360 }
24361 wxPyEndAllowThreads(__tstate);
24362 if (PyErr_Occurred()) SWIG_fail;
24363 }
24364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24365 return resultobj;
24366 fail:
24367 return NULL;
24368 }
24369
24370
24371 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24372 PyObject *resultobj = 0;
24373 wxDateTime *arg1 = (wxDateTime *) 0 ;
24374 int arg2 ;
24375 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24376 int arg4 = (int) wxDateTime::Inv_Year ;
24377 int arg5 = (int) 0 ;
24378 int arg6 = (int) 0 ;
24379 int arg7 = (int) 0 ;
24380 int arg8 = (int) 0 ;
24381 wxDateTime *result = 0 ;
24382 void *argp1 = 0 ;
24383 int res1 = 0 ;
24384 int val2 ;
24385 int ecode2 = 0 ;
24386 int val3 ;
24387 int ecode3 = 0 ;
24388 int val4 ;
24389 int ecode4 = 0 ;
24390 int val5 ;
24391 int ecode5 = 0 ;
24392 int val6 ;
24393 int ecode6 = 0 ;
24394 int val7 ;
24395 int ecode7 = 0 ;
24396 int val8 ;
24397 int ecode8 = 0 ;
24398 PyObject * obj0 = 0 ;
24399 PyObject * obj1 = 0 ;
24400 PyObject * obj2 = 0 ;
24401 PyObject * obj3 = 0 ;
24402 PyObject * obj4 = 0 ;
24403 PyObject * obj5 = 0 ;
24404 PyObject * obj6 = 0 ;
24405 PyObject * obj7 = 0 ;
24406 char * kwnames[] = {
24407 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24408 };
24409
24410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24412 if (!SWIG_IsOK(res1)) {
24413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24414 }
24415 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24416 ecode2 = SWIG_AsVal_int(obj1, &val2);
24417 if (!SWIG_IsOK(ecode2)) {
24418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24419 }
24420 arg2 = static_cast< int >(val2);
24421 if (obj2) {
24422 ecode3 = SWIG_AsVal_int(obj2, &val3);
24423 if (!SWIG_IsOK(ecode3)) {
24424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24425 }
24426 arg3 = static_cast< wxDateTime::Month >(val3);
24427 }
24428 if (obj3) {
24429 ecode4 = SWIG_AsVal_int(obj3, &val4);
24430 if (!SWIG_IsOK(ecode4)) {
24431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24432 }
24433 arg4 = static_cast< int >(val4);
24434 }
24435 if (obj4) {
24436 ecode5 = SWIG_AsVal_int(obj4, &val5);
24437 if (!SWIG_IsOK(ecode5)) {
24438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24439 }
24440 arg5 = static_cast< int >(val5);
24441 }
24442 if (obj5) {
24443 ecode6 = SWIG_AsVal_int(obj5, &val6);
24444 if (!SWIG_IsOK(ecode6)) {
24445 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24446 }
24447 arg6 = static_cast< int >(val6);
24448 }
24449 if (obj6) {
24450 ecode7 = SWIG_AsVal_int(obj6, &val7);
24451 if (!SWIG_IsOK(ecode7)) {
24452 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24453 }
24454 arg7 = static_cast< int >(val7);
24455 }
24456 if (obj7) {
24457 ecode8 = SWIG_AsVal_int(obj7, &val8);
24458 if (!SWIG_IsOK(ecode8)) {
24459 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24460 }
24461 arg8 = static_cast< int >(val8);
24462 }
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 {
24466 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24467 result = (wxDateTime *) &_result_ref;
24468 }
24469 wxPyEndAllowThreads(__tstate);
24470 if (PyErr_Occurred()) SWIG_fail;
24471 }
24472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24473 return resultobj;
24474 fail:
24475 return NULL;
24476 }
24477
24478
24479 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24480 PyObject *resultobj = 0;
24481 wxDateTime *arg1 = (wxDateTime *) 0 ;
24482 wxDateTime *result = 0 ;
24483 void *argp1 = 0 ;
24484 int res1 = 0 ;
24485 PyObject *swig_obj[1] ;
24486
24487 if (!args) SWIG_fail;
24488 swig_obj[0] = args;
24489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24490 if (!SWIG_IsOK(res1)) {
24491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24492 }
24493 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24494 {
24495 PyThreadState* __tstate = wxPyBeginAllowThreads();
24496 {
24497 wxDateTime &_result_ref = (arg1)->ResetTime();
24498 result = (wxDateTime *) &_result_ref;
24499 }
24500 wxPyEndAllowThreads(__tstate);
24501 if (PyErr_Occurred()) SWIG_fail;
24502 }
24503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24504 return resultobj;
24505 fail:
24506 return NULL;
24507 }
24508
24509
24510 SWIGINTERN PyObject *_wrap_DateTime_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24511 PyObject *resultobj = 0;
24512 wxDateTime *arg1 = (wxDateTime *) 0 ;
24513 wxDateTime result;
24514 void *argp1 = 0 ;
24515 int res1 = 0 ;
24516 PyObject *swig_obj[1] ;
24517
24518 if (!args) SWIG_fail;
24519 swig_obj[0] = args;
24520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24521 if (!SWIG_IsOK(res1)) {
24522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24523 }
24524 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24525 {
24526 PyThreadState* __tstate = wxPyBeginAllowThreads();
24527 result = ((wxDateTime const *)arg1)->GetDateOnly();
24528 wxPyEndAllowThreads(__tstate);
24529 if (PyErr_Occurred()) SWIG_fail;
24530 }
24531 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj = 0;
24540 wxDateTime *arg1 = (wxDateTime *) 0 ;
24541 int arg2 ;
24542 wxDateTime *result = 0 ;
24543 void *argp1 = 0 ;
24544 int res1 = 0 ;
24545 int val2 ;
24546 int ecode2 = 0 ;
24547 PyObject * obj0 = 0 ;
24548 PyObject * obj1 = 0 ;
24549 char * kwnames[] = {
24550 (char *) "self",(char *) "year", NULL
24551 };
24552
24553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24555 if (!SWIG_IsOK(res1)) {
24556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24557 }
24558 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24559 ecode2 = SWIG_AsVal_int(obj1, &val2);
24560 if (!SWIG_IsOK(ecode2)) {
24561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24562 }
24563 arg2 = static_cast< int >(val2);
24564 {
24565 PyThreadState* __tstate = wxPyBeginAllowThreads();
24566 {
24567 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24568 result = (wxDateTime *) &_result_ref;
24569 }
24570 wxPyEndAllowThreads(__tstate);
24571 if (PyErr_Occurred()) SWIG_fail;
24572 }
24573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24581 PyObject *resultobj = 0;
24582 wxDateTime *arg1 = (wxDateTime *) 0 ;
24583 wxDateTime::Month arg2 ;
24584 wxDateTime *result = 0 ;
24585 void *argp1 = 0 ;
24586 int res1 = 0 ;
24587 int val2 ;
24588 int ecode2 = 0 ;
24589 PyObject * obj0 = 0 ;
24590 PyObject * obj1 = 0 ;
24591 char * kwnames[] = {
24592 (char *) "self",(char *) "month", NULL
24593 };
24594
24595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24597 if (!SWIG_IsOK(res1)) {
24598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24599 }
24600 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24601 ecode2 = SWIG_AsVal_int(obj1, &val2);
24602 if (!SWIG_IsOK(ecode2)) {
24603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24604 }
24605 arg2 = static_cast< wxDateTime::Month >(val2);
24606 {
24607 PyThreadState* __tstate = wxPyBeginAllowThreads();
24608 {
24609 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24610 result = (wxDateTime *) &_result_ref;
24611 }
24612 wxPyEndAllowThreads(__tstate);
24613 if (PyErr_Occurred()) SWIG_fail;
24614 }
24615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24616 return resultobj;
24617 fail:
24618 return NULL;
24619 }
24620
24621
24622 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24623 PyObject *resultobj = 0;
24624 wxDateTime *arg1 = (wxDateTime *) 0 ;
24625 int arg2 ;
24626 wxDateTime *result = 0 ;
24627 void *argp1 = 0 ;
24628 int res1 = 0 ;
24629 int val2 ;
24630 int ecode2 = 0 ;
24631 PyObject * obj0 = 0 ;
24632 PyObject * obj1 = 0 ;
24633 char * kwnames[] = {
24634 (char *) "self",(char *) "day", NULL
24635 };
24636
24637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24639 if (!SWIG_IsOK(res1)) {
24640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24641 }
24642 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24643 ecode2 = SWIG_AsVal_int(obj1, &val2);
24644 if (!SWIG_IsOK(ecode2)) {
24645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24646 }
24647 arg2 = static_cast< int >(val2);
24648 {
24649 PyThreadState* __tstate = wxPyBeginAllowThreads();
24650 {
24651 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24652 result = (wxDateTime *) &_result_ref;
24653 }
24654 wxPyEndAllowThreads(__tstate);
24655 if (PyErr_Occurred()) SWIG_fail;
24656 }
24657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24665 PyObject *resultobj = 0;
24666 wxDateTime *arg1 = (wxDateTime *) 0 ;
24667 int arg2 ;
24668 wxDateTime *result = 0 ;
24669 void *argp1 = 0 ;
24670 int res1 = 0 ;
24671 int val2 ;
24672 int ecode2 = 0 ;
24673 PyObject * obj0 = 0 ;
24674 PyObject * obj1 = 0 ;
24675 char * kwnames[] = {
24676 (char *) "self",(char *) "hour", NULL
24677 };
24678
24679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24681 if (!SWIG_IsOK(res1)) {
24682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24683 }
24684 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24685 ecode2 = SWIG_AsVal_int(obj1, &val2);
24686 if (!SWIG_IsOK(ecode2)) {
24687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24688 }
24689 arg2 = static_cast< int >(val2);
24690 {
24691 PyThreadState* __tstate = wxPyBeginAllowThreads();
24692 {
24693 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24694 result = (wxDateTime *) &_result_ref;
24695 }
24696 wxPyEndAllowThreads(__tstate);
24697 if (PyErr_Occurred()) SWIG_fail;
24698 }
24699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24700 return resultobj;
24701 fail:
24702 return NULL;
24703 }
24704
24705
24706 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24707 PyObject *resultobj = 0;
24708 wxDateTime *arg1 = (wxDateTime *) 0 ;
24709 int arg2 ;
24710 wxDateTime *result = 0 ;
24711 void *argp1 = 0 ;
24712 int res1 = 0 ;
24713 int val2 ;
24714 int ecode2 = 0 ;
24715 PyObject * obj0 = 0 ;
24716 PyObject * obj1 = 0 ;
24717 char * kwnames[] = {
24718 (char *) "self",(char *) "minute", NULL
24719 };
24720
24721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24723 if (!SWIG_IsOK(res1)) {
24724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24725 }
24726 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24727 ecode2 = SWIG_AsVal_int(obj1, &val2);
24728 if (!SWIG_IsOK(ecode2)) {
24729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24730 }
24731 arg2 = static_cast< int >(val2);
24732 {
24733 PyThreadState* __tstate = wxPyBeginAllowThreads();
24734 {
24735 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24736 result = (wxDateTime *) &_result_ref;
24737 }
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24749 PyObject *resultobj = 0;
24750 wxDateTime *arg1 = (wxDateTime *) 0 ;
24751 int arg2 ;
24752 wxDateTime *result = 0 ;
24753 void *argp1 = 0 ;
24754 int res1 = 0 ;
24755 int val2 ;
24756 int ecode2 = 0 ;
24757 PyObject * obj0 = 0 ;
24758 PyObject * obj1 = 0 ;
24759 char * kwnames[] = {
24760 (char *) "self",(char *) "second", NULL
24761 };
24762
24763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24767 }
24768 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24769 ecode2 = SWIG_AsVal_int(obj1, &val2);
24770 if (!SWIG_IsOK(ecode2)) {
24771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24772 }
24773 arg2 = static_cast< int >(val2);
24774 {
24775 PyThreadState* __tstate = wxPyBeginAllowThreads();
24776 {
24777 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24778 result = (wxDateTime *) &_result_ref;
24779 }
24780 wxPyEndAllowThreads(__tstate);
24781 if (PyErr_Occurred()) SWIG_fail;
24782 }
24783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24791 PyObject *resultobj = 0;
24792 wxDateTime *arg1 = (wxDateTime *) 0 ;
24793 int arg2 ;
24794 wxDateTime *result = 0 ;
24795 void *argp1 = 0 ;
24796 int res1 = 0 ;
24797 int val2 ;
24798 int ecode2 = 0 ;
24799 PyObject * obj0 = 0 ;
24800 PyObject * obj1 = 0 ;
24801 char * kwnames[] = {
24802 (char *) "self",(char *) "millisecond", NULL
24803 };
24804
24805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24807 if (!SWIG_IsOK(res1)) {
24808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24809 }
24810 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24811 ecode2 = SWIG_AsVal_int(obj1, &val2);
24812 if (!SWIG_IsOK(ecode2)) {
24813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24814 }
24815 arg2 = static_cast< int >(val2);
24816 {
24817 PyThreadState* __tstate = wxPyBeginAllowThreads();
24818 {
24819 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24820 result = (wxDateTime *) &_result_ref;
24821 }
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24833 PyObject *resultobj = 0;
24834 wxDateTime *arg1 = (wxDateTime *) 0 ;
24835 wxDateTime::WeekDay arg2 ;
24836 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24837 wxDateTime *result = 0 ;
24838 void *argp1 = 0 ;
24839 int res1 = 0 ;
24840 int val2 ;
24841 int ecode2 = 0 ;
24842 int val3 ;
24843 int ecode3 = 0 ;
24844 PyObject * obj0 = 0 ;
24845 PyObject * obj1 = 0 ;
24846 PyObject * obj2 = 0 ;
24847 char * kwnames[] = {
24848 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24849 };
24850
24851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24853 if (!SWIG_IsOK(res1)) {
24854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24855 }
24856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24857 ecode2 = SWIG_AsVal_int(obj1, &val2);
24858 if (!SWIG_IsOK(ecode2)) {
24859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24860 }
24861 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24862 if (obj2) {
24863 ecode3 = SWIG_AsVal_int(obj2, &val3);
24864 if (!SWIG_IsOK(ecode3)) {
24865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24866 }
24867 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24868 }
24869 {
24870 PyThreadState* __tstate = wxPyBeginAllowThreads();
24871 {
24872 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24873 result = (wxDateTime *) &_result_ref;
24874 }
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24879 return resultobj;
24880 fail:
24881 return NULL;
24882 }
24883
24884
24885 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24886 PyObject *resultobj = 0;
24887 wxDateTime *arg1 = (wxDateTime *) 0 ;
24888 wxDateTime::WeekDay arg2 ;
24889 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24890 wxDateTime result;
24891 void *argp1 = 0 ;
24892 int res1 = 0 ;
24893 int val2 ;
24894 int ecode2 = 0 ;
24895 int val3 ;
24896 int ecode3 = 0 ;
24897 PyObject * obj0 = 0 ;
24898 PyObject * obj1 = 0 ;
24899 PyObject * obj2 = 0 ;
24900 char * kwnames[] = {
24901 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24902 };
24903
24904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24906 if (!SWIG_IsOK(res1)) {
24907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24908 }
24909 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24910 ecode2 = SWIG_AsVal_int(obj1, &val2);
24911 if (!SWIG_IsOK(ecode2)) {
24912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24913 }
24914 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24915 if (obj2) {
24916 ecode3 = SWIG_AsVal_int(obj2, &val3);
24917 if (!SWIG_IsOK(ecode3)) {
24918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24919 }
24920 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24921 }
24922 {
24923 PyThreadState* __tstate = wxPyBeginAllowThreads();
24924 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24925 wxPyEndAllowThreads(__tstate);
24926 if (PyErr_Occurred()) SWIG_fail;
24927 }
24928 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24929 return resultobj;
24930 fail:
24931 return NULL;
24932 }
24933
24934
24935 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24936 PyObject *resultobj = 0;
24937 wxDateTime *arg1 = (wxDateTime *) 0 ;
24938 wxDateTime::WeekDay arg2 ;
24939 wxDateTime *result = 0 ;
24940 void *argp1 = 0 ;
24941 int res1 = 0 ;
24942 int val2 ;
24943 int ecode2 = 0 ;
24944 PyObject * obj0 = 0 ;
24945 PyObject * obj1 = 0 ;
24946 char * kwnames[] = {
24947 (char *) "self",(char *) "weekday", NULL
24948 };
24949
24950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24952 if (!SWIG_IsOK(res1)) {
24953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24954 }
24955 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24956 ecode2 = SWIG_AsVal_int(obj1, &val2);
24957 if (!SWIG_IsOK(ecode2)) {
24958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24959 }
24960 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 {
24964 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24965 result = (wxDateTime *) &_result_ref;
24966 }
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24971 return resultobj;
24972 fail:
24973 return NULL;
24974 }
24975
24976
24977 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24978 PyObject *resultobj = 0;
24979 wxDateTime *arg1 = (wxDateTime *) 0 ;
24980 wxDateTime::WeekDay arg2 ;
24981 wxDateTime result;
24982 void *argp1 = 0 ;
24983 int res1 = 0 ;
24984 int val2 ;
24985 int ecode2 = 0 ;
24986 PyObject * obj0 = 0 ;
24987 PyObject * obj1 = 0 ;
24988 char * kwnames[] = {
24989 (char *) "self",(char *) "weekday", NULL
24990 };
24991
24992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24994 if (!SWIG_IsOK(res1)) {
24995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24996 }
24997 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24998 ecode2 = SWIG_AsVal_int(obj1, &val2);
24999 if (!SWIG_IsOK(ecode2)) {
25000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25001 }
25002 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25003 {
25004 PyThreadState* __tstate = wxPyBeginAllowThreads();
25005 result = (arg1)->GetNextWeekDay(arg2);
25006 wxPyEndAllowThreads(__tstate);
25007 if (PyErr_Occurred()) SWIG_fail;
25008 }
25009 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25010 return resultobj;
25011 fail:
25012 return NULL;
25013 }
25014
25015
25016 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25017 PyObject *resultobj = 0;
25018 wxDateTime *arg1 = (wxDateTime *) 0 ;
25019 wxDateTime::WeekDay arg2 ;
25020 wxDateTime *result = 0 ;
25021 void *argp1 = 0 ;
25022 int res1 = 0 ;
25023 int val2 ;
25024 int ecode2 = 0 ;
25025 PyObject * obj0 = 0 ;
25026 PyObject * obj1 = 0 ;
25027 char * kwnames[] = {
25028 (char *) "self",(char *) "weekday", NULL
25029 };
25030
25031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25033 if (!SWIG_IsOK(res1)) {
25034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25035 }
25036 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25037 ecode2 = SWIG_AsVal_int(obj1, &val2);
25038 if (!SWIG_IsOK(ecode2)) {
25039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25040 }
25041 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25042 {
25043 PyThreadState* __tstate = wxPyBeginAllowThreads();
25044 {
25045 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
25046 result = (wxDateTime *) &_result_ref;
25047 }
25048 wxPyEndAllowThreads(__tstate);
25049 if (PyErr_Occurred()) SWIG_fail;
25050 }
25051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25052 return resultobj;
25053 fail:
25054 return NULL;
25055 }
25056
25057
25058 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25059 PyObject *resultobj = 0;
25060 wxDateTime *arg1 = (wxDateTime *) 0 ;
25061 wxDateTime::WeekDay arg2 ;
25062 wxDateTime result;
25063 void *argp1 = 0 ;
25064 int res1 = 0 ;
25065 int val2 ;
25066 int ecode2 = 0 ;
25067 PyObject * obj0 = 0 ;
25068 PyObject * obj1 = 0 ;
25069 char * kwnames[] = {
25070 (char *) "self",(char *) "weekday", NULL
25071 };
25072
25073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25075 if (!SWIG_IsOK(res1)) {
25076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25077 }
25078 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25079 ecode2 = SWIG_AsVal_int(obj1, &val2);
25080 if (!SWIG_IsOK(ecode2)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25082 }
25083 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 result = (arg1)->GetPrevWeekDay(arg2);
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 wxDateTime *arg1 = (wxDateTime *) 0 ;
25100 wxDateTime::WeekDay arg2 ;
25101 int arg3 = (int) 1 ;
25102 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25103 int arg5 = (int) wxDateTime::Inv_Year ;
25104 bool result;
25105 void *argp1 = 0 ;
25106 int res1 = 0 ;
25107 int val2 ;
25108 int ecode2 = 0 ;
25109 int val3 ;
25110 int ecode3 = 0 ;
25111 int val4 ;
25112 int ecode4 = 0 ;
25113 int val5 ;
25114 int ecode5 = 0 ;
25115 PyObject * obj0 = 0 ;
25116 PyObject * obj1 = 0 ;
25117 PyObject * obj2 = 0 ;
25118 PyObject * obj3 = 0 ;
25119 PyObject * obj4 = 0 ;
25120 char * kwnames[] = {
25121 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25122 };
25123
25124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25126 if (!SWIG_IsOK(res1)) {
25127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25128 }
25129 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25130 ecode2 = SWIG_AsVal_int(obj1, &val2);
25131 if (!SWIG_IsOK(ecode2)) {
25132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25133 }
25134 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25135 if (obj2) {
25136 ecode3 = SWIG_AsVal_int(obj2, &val3);
25137 if (!SWIG_IsOK(ecode3)) {
25138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25139 }
25140 arg3 = static_cast< int >(val3);
25141 }
25142 if (obj3) {
25143 ecode4 = SWIG_AsVal_int(obj3, &val4);
25144 if (!SWIG_IsOK(ecode4)) {
25145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25146 }
25147 arg4 = static_cast< wxDateTime::Month >(val4);
25148 }
25149 if (obj4) {
25150 ecode5 = SWIG_AsVal_int(obj4, &val5);
25151 if (!SWIG_IsOK(ecode5)) {
25152 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25153 }
25154 arg5 = static_cast< int >(val5);
25155 }
25156 {
25157 PyThreadState* __tstate = wxPyBeginAllowThreads();
25158 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25159 wxPyEndAllowThreads(__tstate);
25160 if (PyErr_Occurred()) SWIG_fail;
25161 }
25162 {
25163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25164 }
25165 return resultobj;
25166 fail:
25167 return NULL;
25168 }
25169
25170
25171 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25172 PyObject *resultobj = 0;
25173 wxDateTime *arg1 = (wxDateTime *) 0 ;
25174 wxDateTime::WeekDay arg2 ;
25175 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25176 int arg4 = (int) wxDateTime::Inv_Year ;
25177 bool result;
25178 void *argp1 = 0 ;
25179 int res1 = 0 ;
25180 int val2 ;
25181 int ecode2 = 0 ;
25182 int val3 ;
25183 int ecode3 = 0 ;
25184 int val4 ;
25185 int ecode4 = 0 ;
25186 PyObject * obj0 = 0 ;
25187 PyObject * obj1 = 0 ;
25188 PyObject * obj2 = 0 ;
25189 PyObject * obj3 = 0 ;
25190 char * kwnames[] = {
25191 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25192 };
25193
25194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25196 if (!SWIG_IsOK(res1)) {
25197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25198 }
25199 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25200 ecode2 = SWIG_AsVal_int(obj1, &val2);
25201 if (!SWIG_IsOK(ecode2)) {
25202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25203 }
25204 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25205 if (obj2) {
25206 ecode3 = SWIG_AsVal_int(obj2, &val3);
25207 if (!SWIG_IsOK(ecode3)) {
25208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25209 }
25210 arg3 = static_cast< wxDateTime::Month >(val3);
25211 }
25212 if (obj3) {
25213 ecode4 = SWIG_AsVal_int(obj3, &val4);
25214 if (!SWIG_IsOK(ecode4)) {
25215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25216 }
25217 arg4 = static_cast< int >(val4);
25218 }
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 {
25226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25227 }
25228 return resultobj;
25229 fail:
25230 return NULL;
25231 }
25232
25233
25234 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25235 PyObject *resultobj = 0;
25236 wxDateTime *arg1 = (wxDateTime *) 0 ;
25237 wxDateTime::WeekDay arg2 ;
25238 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25239 int arg4 = (int) wxDateTime::Inv_Year ;
25240 wxDateTime result;
25241 void *argp1 = 0 ;
25242 int res1 = 0 ;
25243 int val2 ;
25244 int ecode2 = 0 ;
25245 int val3 ;
25246 int ecode3 = 0 ;
25247 int val4 ;
25248 int ecode4 = 0 ;
25249 PyObject * obj0 = 0 ;
25250 PyObject * obj1 = 0 ;
25251 PyObject * obj2 = 0 ;
25252 PyObject * obj3 = 0 ;
25253 char * kwnames[] = {
25254 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25255 };
25256
25257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25259 if (!SWIG_IsOK(res1)) {
25260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25261 }
25262 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25263 ecode2 = SWIG_AsVal_int(obj1, &val2);
25264 if (!SWIG_IsOK(ecode2)) {
25265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25266 }
25267 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25268 if (obj2) {
25269 ecode3 = SWIG_AsVal_int(obj2, &val3);
25270 if (!SWIG_IsOK(ecode3)) {
25271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25272 }
25273 arg3 = static_cast< wxDateTime::Month >(val3);
25274 }
25275 if (obj3) {
25276 ecode4 = SWIG_AsVal_int(obj3, &val4);
25277 if (!SWIG_IsOK(ecode4)) {
25278 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25279 }
25280 arg4 = static_cast< int >(val4);
25281 }
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25296 PyObject *resultobj = 0;
25297 int arg1 ;
25298 int arg2 ;
25299 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25300 wxDateTime result;
25301 int val1 ;
25302 int ecode1 = 0 ;
25303 int val2 ;
25304 int ecode2 = 0 ;
25305 int val3 ;
25306 int ecode3 = 0 ;
25307 PyObject * obj0 = 0 ;
25308 PyObject * obj1 = 0 ;
25309 PyObject * obj2 = 0 ;
25310 char * kwnames[] = {
25311 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25312 };
25313
25314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25315 ecode1 = SWIG_AsVal_int(obj0, &val1);
25316 if (!SWIG_IsOK(ecode1)) {
25317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25318 }
25319 arg1 = static_cast< int >(val1);
25320 ecode2 = SWIG_AsVal_int(obj1, &val2);
25321 if (!SWIG_IsOK(ecode2)) {
25322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25323 }
25324 arg2 = static_cast< int >(val2);
25325 if (obj2) {
25326 ecode3 = SWIG_AsVal_int(obj2, &val3);
25327 if (!SWIG_IsOK(ecode3)) {
25328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25329 }
25330 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25331 }
25332 {
25333 PyThreadState* __tstate = wxPyBeginAllowThreads();
25334 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25335 wxPyEndAllowThreads(__tstate);
25336 if (PyErr_Occurred()) SWIG_fail;
25337 }
25338 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25339 return resultobj;
25340 fail:
25341 return NULL;
25342 }
25343
25344
25345 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25346 PyObject *resultobj = 0;
25347 wxDateTime *arg1 = (wxDateTime *) 0 ;
25348 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25349 int arg3 = (int) wxDateTime::Inv_Year ;
25350 wxDateTime *result = 0 ;
25351 void *argp1 = 0 ;
25352 int res1 = 0 ;
25353 int val2 ;
25354 int ecode2 = 0 ;
25355 int val3 ;
25356 int ecode3 = 0 ;
25357 PyObject * obj0 = 0 ;
25358 PyObject * obj1 = 0 ;
25359 PyObject * obj2 = 0 ;
25360 char * kwnames[] = {
25361 (char *) "self",(char *) "month",(char *) "year", NULL
25362 };
25363
25364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25366 if (!SWIG_IsOK(res1)) {
25367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25368 }
25369 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25370 if (obj1) {
25371 ecode2 = SWIG_AsVal_int(obj1, &val2);
25372 if (!SWIG_IsOK(ecode2)) {
25373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25374 }
25375 arg2 = static_cast< wxDateTime::Month >(val2);
25376 }
25377 if (obj2) {
25378 ecode3 = SWIG_AsVal_int(obj2, &val3);
25379 if (!SWIG_IsOK(ecode3)) {
25380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25381 }
25382 arg3 = static_cast< int >(val3);
25383 }
25384 {
25385 PyThreadState* __tstate = wxPyBeginAllowThreads();
25386 {
25387 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25388 result = (wxDateTime *) &_result_ref;
25389 }
25390 wxPyEndAllowThreads(__tstate);
25391 if (PyErr_Occurred()) SWIG_fail;
25392 }
25393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25394 return resultobj;
25395 fail:
25396 return NULL;
25397 }
25398
25399
25400 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj = 0;
25402 wxDateTime *arg1 = (wxDateTime *) 0 ;
25403 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25404 int arg3 = (int) wxDateTime::Inv_Year ;
25405 wxDateTime result;
25406 void *argp1 = 0 ;
25407 int res1 = 0 ;
25408 int val2 ;
25409 int ecode2 = 0 ;
25410 int val3 ;
25411 int ecode3 = 0 ;
25412 PyObject * obj0 = 0 ;
25413 PyObject * obj1 = 0 ;
25414 PyObject * obj2 = 0 ;
25415 char * kwnames[] = {
25416 (char *) "self",(char *) "month",(char *) "year", NULL
25417 };
25418
25419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25421 if (!SWIG_IsOK(res1)) {
25422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25423 }
25424 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25425 if (obj1) {
25426 ecode2 = SWIG_AsVal_int(obj1, &val2);
25427 if (!SWIG_IsOK(ecode2)) {
25428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25429 }
25430 arg2 = static_cast< wxDateTime::Month >(val2);
25431 }
25432 if (obj2) {
25433 ecode3 = SWIG_AsVal_int(obj2, &val3);
25434 if (!SWIG_IsOK(ecode3)) {
25435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25436 }
25437 arg3 = static_cast< int >(val3);
25438 }
25439 {
25440 PyThreadState* __tstate = wxPyBeginAllowThreads();
25441 result = (arg1)->GetLastMonthDay(arg2,arg3);
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25446 return resultobj;
25447 fail:
25448 return NULL;
25449 }
25450
25451
25452 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25453 PyObject *resultobj = 0;
25454 wxDateTime *arg1 = (wxDateTime *) 0 ;
25455 int arg2 ;
25456 wxDateTime *result = 0 ;
25457 void *argp1 = 0 ;
25458 int res1 = 0 ;
25459 int val2 ;
25460 int ecode2 = 0 ;
25461 PyObject * obj0 = 0 ;
25462 PyObject * obj1 = 0 ;
25463 char * kwnames[] = {
25464 (char *) "self",(char *) "yday", NULL
25465 };
25466
25467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25469 if (!SWIG_IsOK(res1)) {
25470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25471 }
25472 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25473 ecode2 = SWIG_AsVal_int(obj1, &val2);
25474 if (!SWIG_IsOK(ecode2)) {
25475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25476 }
25477 arg2 = static_cast< int >(val2);
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 {
25481 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25482 result = (wxDateTime *) &_result_ref;
25483 }
25484 wxPyEndAllowThreads(__tstate);
25485 if (PyErr_Occurred()) SWIG_fail;
25486 }
25487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25495 PyObject *resultobj = 0;
25496 wxDateTime *arg1 = (wxDateTime *) 0 ;
25497 int arg2 ;
25498 wxDateTime result;
25499 void *argp1 = 0 ;
25500 int res1 = 0 ;
25501 int val2 ;
25502 int ecode2 = 0 ;
25503 PyObject * obj0 = 0 ;
25504 PyObject * obj1 = 0 ;
25505 char * kwnames[] = {
25506 (char *) "self",(char *) "yday", NULL
25507 };
25508
25509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25511 if (!SWIG_IsOK(res1)) {
25512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25513 }
25514 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25515 ecode2 = SWIG_AsVal_int(obj1, &val2);
25516 if (!SWIG_IsOK(ecode2)) {
25517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25518 }
25519 arg2 = static_cast< int >(val2);
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 result = (arg1)->GetYearDay(arg2);
25523 wxPyEndAllowThreads(__tstate);
25524 if (PyErr_Occurred()) SWIG_fail;
25525 }
25526 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25534 PyObject *resultobj = 0;
25535 wxDateTime *arg1 = (wxDateTime *) 0 ;
25536 double result;
25537 void *argp1 = 0 ;
25538 int res1 = 0 ;
25539 PyObject *swig_obj[1] ;
25540
25541 if (!args) SWIG_fail;
25542 swig_obj[0] = args;
25543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25544 if (!SWIG_IsOK(res1)) {
25545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25546 }
25547 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25548 {
25549 PyThreadState* __tstate = wxPyBeginAllowThreads();
25550 result = (double)(arg1)->GetJulianDayNumber();
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 resultobj = SWIG_From_double(static_cast< double >(result));
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25562 PyObject *resultobj = 0;
25563 wxDateTime *arg1 = (wxDateTime *) 0 ;
25564 double result;
25565 void *argp1 = 0 ;
25566 int res1 = 0 ;
25567 PyObject *swig_obj[1] ;
25568
25569 if (!args) SWIG_fail;
25570 swig_obj[0] = args;
25571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25572 if (!SWIG_IsOK(res1)) {
25573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25574 }
25575 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (double)(arg1)->GetJDN();
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_From_double(static_cast< double >(result));
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25590 PyObject *resultobj = 0;
25591 wxDateTime *arg1 = (wxDateTime *) 0 ;
25592 double result;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 PyObject *swig_obj[1] ;
25596
25597 if (!args) SWIG_fail;
25598 swig_obj[0] = args;
25599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25600 if (!SWIG_IsOK(res1)) {
25601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25602 }
25603 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25604 {
25605 PyThreadState* __tstate = wxPyBeginAllowThreads();
25606 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25607 wxPyEndAllowThreads(__tstate);
25608 if (PyErr_Occurred()) SWIG_fail;
25609 }
25610 resultobj = SWIG_From_double(static_cast< double >(result));
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25618 PyObject *resultobj = 0;
25619 wxDateTime *arg1 = (wxDateTime *) 0 ;
25620 double result;
25621 void *argp1 = 0 ;
25622 int res1 = 0 ;
25623 PyObject *swig_obj[1] ;
25624
25625 if (!args) SWIG_fail;
25626 swig_obj[0] = args;
25627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25628 if (!SWIG_IsOK(res1)) {
25629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25630 }
25631 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25632 {
25633 PyThreadState* __tstate = wxPyBeginAllowThreads();
25634 result = (double)(arg1)->GetMJD();
25635 wxPyEndAllowThreads(__tstate);
25636 if (PyErr_Occurred()) SWIG_fail;
25637 }
25638 resultobj = SWIG_From_double(static_cast< double >(result));
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646 PyObject *resultobj = 0;
25647 wxDateTime *arg1 = (wxDateTime *) 0 ;
25648 double result;
25649 void *argp1 = 0 ;
25650 int res1 = 0 ;
25651 PyObject *swig_obj[1] ;
25652
25653 if (!args) SWIG_fail;
25654 swig_obj[0] = args;
25655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25656 if (!SWIG_IsOK(res1)) {
25657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25658 }
25659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 result = (double)(arg1)->GetRataDie();
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 resultobj = SWIG_From_double(static_cast< double >(result));
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25674 PyObject *resultobj = 0;
25675 wxDateTime *arg1 = (wxDateTime *) 0 ;
25676 wxDateTime::TimeZone *arg2 = 0 ;
25677 bool arg3 = (bool) false ;
25678 wxDateTime result;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 bool temp2 = false ;
25682 bool val3 ;
25683 int ecode3 = 0 ;
25684 PyObject * obj0 = 0 ;
25685 PyObject * obj1 = 0 ;
25686 PyObject * obj2 = 0 ;
25687 char * kwnames[] = {
25688 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25689 };
25690
25691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25693 if (!SWIG_IsOK(res1)) {
25694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25695 }
25696 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25697 {
25698 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25699 temp2 = true;
25700 }
25701 if (obj2) {
25702 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25703 if (!SWIG_IsOK(ecode3)) {
25704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25705 }
25706 arg3 = static_cast< bool >(val3);
25707 }
25708 {
25709 PyThreadState* __tstate = wxPyBeginAllowThreads();
25710 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25715 {
25716 if (temp2) delete arg2;
25717 }
25718 return resultobj;
25719 fail:
25720 {
25721 if (temp2) delete arg2;
25722 }
25723 return NULL;
25724 }
25725
25726
25727 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj = 0;
25729 wxDateTime *arg1 = (wxDateTime *) 0 ;
25730 wxDateTime::TimeZone *arg2 = 0 ;
25731 bool arg3 = (bool) false ;
25732 wxDateTime *result = 0 ;
25733 void *argp1 = 0 ;
25734 int res1 = 0 ;
25735 bool temp2 = false ;
25736 bool val3 ;
25737 int ecode3 = 0 ;
25738 PyObject * obj0 = 0 ;
25739 PyObject * obj1 = 0 ;
25740 PyObject * obj2 = 0 ;
25741 char * kwnames[] = {
25742 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25743 };
25744
25745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25747 if (!SWIG_IsOK(res1)) {
25748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25749 }
25750 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25751 {
25752 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25753 temp2 = true;
25754 }
25755 if (obj2) {
25756 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25757 if (!SWIG_IsOK(ecode3)) {
25758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25759 }
25760 arg3 = static_cast< bool >(val3);
25761 }
25762 {
25763 PyThreadState* __tstate = wxPyBeginAllowThreads();
25764 {
25765 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25766 result = (wxDateTime *) &_result_ref;
25767 }
25768 wxPyEndAllowThreads(__tstate);
25769 if (PyErr_Occurred()) SWIG_fail;
25770 }
25771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25772 {
25773 if (temp2) delete arg2;
25774 }
25775 return resultobj;
25776 fail:
25777 {
25778 if (temp2) delete arg2;
25779 }
25780 return NULL;
25781 }
25782
25783
25784 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25785 PyObject *resultobj = 0;
25786 wxDateTime *arg1 = (wxDateTime *) 0 ;
25787 wxDateTime::TimeZone *arg2 = 0 ;
25788 bool arg3 = (bool) false ;
25789 wxDateTime result;
25790 void *argp1 = 0 ;
25791 int res1 = 0 ;
25792 bool temp2 = false ;
25793 bool val3 ;
25794 int ecode3 = 0 ;
25795 PyObject * obj0 = 0 ;
25796 PyObject * obj1 = 0 ;
25797 PyObject * obj2 = 0 ;
25798 char * kwnames[] = {
25799 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25800 };
25801
25802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25804 if (!SWIG_IsOK(res1)) {
25805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25806 }
25807 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25808 {
25809 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25810 temp2 = true;
25811 }
25812 if (obj2) {
25813 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25814 if (!SWIG_IsOK(ecode3)) {
25815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25816 }
25817 arg3 = static_cast< bool >(val3);
25818 }
25819 {
25820 PyThreadState* __tstate = wxPyBeginAllowThreads();
25821 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25822 wxPyEndAllowThreads(__tstate);
25823 if (PyErr_Occurred()) SWIG_fail;
25824 }
25825 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25826 {
25827 if (temp2) delete arg2;
25828 }
25829 return resultobj;
25830 fail:
25831 {
25832 if (temp2) delete arg2;
25833 }
25834 return NULL;
25835 }
25836
25837
25838 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25839 PyObject *resultobj = 0;
25840 wxDateTime *arg1 = (wxDateTime *) 0 ;
25841 wxDateTime::TimeZone *arg2 = 0 ;
25842 bool arg3 = (bool) false ;
25843 wxDateTime *result = 0 ;
25844 void *argp1 = 0 ;
25845 int res1 = 0 ;
25846 bool temp2 = false ;
25847 bool val3 ;
25848 int ecode3 = 0 ;
25849 PyObject * obj0 = 0 ;
25850 PyObject * obj1 = 0 ;
25851 PyObject * obj2 = 0 ;
25852 char * kwnames[] = {
25853 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25854 };
25855
25856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25858 if (!SWIG_IsOK(res1)) {
25859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25860 }
25861 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25862 {
25863 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25864 temp2 = true;
25865 }
25866 if (obj2) {
25867 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25868 if (!SWIG_IsOK(ecode3)) {
25869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25870 }
25871 arg3 = static_cast< bool >(val3);
25872 }
25873 {
25874 PyThreadState* __tstate = wxPyBeginAllowThreads();
25875 {
25876 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25877 result = (wxDateTime *) &_result_ref;
25878 }
25879 wxPyEndAllowThreads(__tstate);
25880 if (PyErr_Occurred()) SWIG_fail;
25881 }
25882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25883 {
25884 if (temp2) delete arg2;
25885 }
25886 return resultobj;
25887 fail:
25888 {
25889 if (temp2) delete arg2;
25890 }
25891 return NULL;
25892 }
25893
25894
25895 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj = 0;
25897 wxDateTime *arg1 = (wxDateTime *) 0 ;
25898 bool arg2 = (bool) false ;
25899 wxDateTime result;
25900 void *argp1 = 0 ;
25901 int res1 = 0 ;
25902 bool val2 ;
25903 int ecode2 = 0 ;
25904 PyObject * obj0 = 0 ;
25905 PyObject * obj1 = 0 ;
25906 char * kwnames[] = {
25907 (char *) "self",(char *) "noDST", NULL
25908 };
25909
25910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25912 if (!SWIG_IsOK(res1)) {
25913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25914 }
25915 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25916 if (obj1) {
25917 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25918 if (!SWIG_IsOK(ecode2)) {
25919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25920 }
25921 arg2 = static_cast< bool >(val2);
25922 }
25923 {
25924 PyThreadState* __tstate = wxPyBeginAllowThreads();
25925 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25930 return resultobj;
25931 fail:
25932 return NULL;
25933 }
25934
25935
25936 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25937 PyObject *resultobj = 0;
25938 wxDateTime *arg1 = (wxDateTime *) 0 ;
25939 bool arg2 = (bool) false ;
25940 wxDateTime *result = 0 ;
25941 void *argp1 = 0 ;
25942 int res1 = 0 ;
25943 bool val2 ;
25944 int ecode2 = 0 ;
25945 PyObject * obj0 = 0 ;
25946 PyObject * obj1 = 0 ;
25947 char * kwnames[] = {
25948 (char *) "self",(char *) "noDST", NULL
25949 };
25950
25951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25953 if (!SWIG_IsOK(res1)) {
25954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25955 }
25956 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25957 if (obj1) {
25958 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25959 if (!SWIG_IsOK(ecode2)) {
25960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25961 }
25962 arg2 = static_cast< bool >(val2);
25963 }
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 {
25967 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25968 result = (wxDateTime *) &_result_ref;
25969 }
25970 wxPyEndAllowThreads(__tstate);
25971 if (PyErr_Occurred()) SWIG_fail;
25972 }
25973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25974 return resultobj;
25975 fail:
25976 return NULL;
25977 }
25978
25979
25980 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25981 PyObject *resultobj = 0;
25982 wxDateTime *arg1 = (wxDateTime *) 0 ;
25983 bool arg2 = (bool) false ;
25984 wxDateTime result;
25985 void *argp1 = 0 ;
25986 int res1 = 0 ;
25987 bool val2 ;
25988 int ecode2 = 0 ;
25989 PyObject * obj0 = 0 ;
25990 PyObject * obj1 = 0 ;
25991 char * kwnames[] = {
25992 (char *) "self",(char *) "noDST", NULL
25993 };
25994
25995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25997 if (!SWIG_IsOK(res1)) {
25998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25999 }
26000 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26001 if (obj1) {
26002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26003 if (!SWIG_IsOK(ecode2)) {
26004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26005 }
26006 arg2 = static_cast< bool >(val2);
26007 }
26008 {
26009 PyThreadState* __tstate = wxPyBeginAllowThreads();
26010 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26011 wxPyEndAllowThreads(__tstate);
26012 if (PyErr_Occurred()) SWIG_fail;
26013 }
26014 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26015 return resultobj;
26016 fail:
26017 return NULL;
26018 }
26019
26020
26021 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26022 PyObject *resultobj = 0;
26023 wxDateTime *arg1 = (wxDateTime *) 0 ;
26024 bool arg2 = (bool) false ;
26025 wxDateTime *result = 0 ;
26026 void *argp1 = 0 ;
26027 int res1 = 0 ;
26028 bool val2 ;
26029 int ecode2 = 0 ;
26030 PyObject * obj0 = 0 ;
26031 PyObject * obj1 = 0 ;
26032 char * kwnames[] = {
26033 (char *) "self",(char *) "noDST", NULL
26034 };
26035
26036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26038 if (!SWIG_IsOK(res1)) {
26039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26040 }
26041 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26042 if (obj1) {
26043 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26044 if (!SWIG_IsOK(ecode2)) {
26045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26046 }
26047 arg2 = static_cast< bool >(val2);
26048 }
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 {
26052 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26053 result = (wxDateTime *) &_result_ref;
26054 }
26055 wxPyEndAllowThreads(__tstate);
26056 if (PyErr_Occurred()) SWIG_fail;
26057 }
26058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26059 return resultobj;
26060 fail:
26061 return NULL;
26062 }
26063
26064
26065 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26066 PyObject *resultobj = 0;
26067 wxDateTime *arg1 = (wxDateTime *) 0 ;
26068 bool arg2 = (bool) false ;
26069 wxDateTime result;
26070 void *argp1 = 0 ;
26071 int res1 = 0 ;
26072 bool val2 ;
26073 int ecode2 = 0 ;
26074 PyObject * obj0 = 0 ;
26075 PyObject * obj1 = 0 ;
26076 char * kwnames[] = {
26077 (char *) "self",(char *) "noDST", NULL
26078 };
26079
26080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26082 if (!SWIG_IsOK(res1)) {
26083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26084 }
26085 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26086 if (obj1) {
26087 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26088 if (!SWIG_IsOK(ecode2)) {
26089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26090 }
26091 arg2 = static_cast< bool >(val2);
26092 }
26093 {
26094 PyThreadState* __tstate = wxPyBeginAllowThreads();
26095 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26096 wxPyEndAllowThreads(__tstate);
26097 if (PyErr_Occurred()) SWIG_fail;
26098 }
26099 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26107 PyObject *resultobj = 0;
26108 wxDateTime *arg1 = (wxDateTime *) 0 ;
26109 bool arg2 = (bool) false ;
26110 wxDateTime *result = 0 ;
26111 void *argp1 = 0 ;
26112 int res1 = 0 ;
26113 bool val2 ;
26114 int ecode2 = 0 ;
26115 PyObject * obj0 = 0 ;
26116 PyObject * obj1 = 0 ;
26117 char * kwnames[] = {
26118 (char *) "self",(char *) "noDST", NULL
26119 };
26120
26121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26123 if (!SWIG_IsOK(res1)) {
26124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26125 }
26126 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26127 if (obj1) {
26128 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26129 if (!SWIG_IsOK(ecode2)) {
26130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26131 }
26132 arg2 = static_cast< bool >(val2);
26133 }
26134 {
26135 PyThreadState* __tstate = wxPyBeginAllowThreads();
26136 {
26137 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26138 result = (wxDateTime *) &_result_ref;
26139 }
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26144 return resultobj;
26145 fail:
26146 return NULL;
26147 }
26148
26149
26150 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26151 PyObject *resultobj = 0;
26152 wxDateTime *arg1 = (wxDateTime *) 0 ;
26153 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26154 int result;
26155 void *argp1 = 0 ;
26156 int res1 = 0 ;
26157 int val2 ;
26158 int ecode2 = 0 ;
26159 PyObject * obj0 = 0 ;
26160 PyObject * obj1 = 0 ;
26161 char * kwnames[] = {
26162 (char *) "self",(char *) "country", NULL
26163 };
26164
26165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26167 if (!SWIG_IsOK(res1)) {
26168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26169 }
26170 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26171 if (obj1) {
26172 ecode2 = SWIG_AsVal_int(obj1, &val2);
26173 if (!SWIG_IsOK(ecode2)) {
26174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26175 }
26176 arg2 = static_cast< wxDateTime::Country >(val2);
26177 }
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 result = (int)(arg1)->IsDST(arg2);
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 resultobj = SWIG_From_int(static_cast< int >(result));
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26192 PyObject *resultobj = 0;
26193 wxDateTime *arg1 = (wxDateTime *) 0 ;
26194 bool result;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 PyObject *swig_obj[1] ;
26198
26199 if (!args) SWIG_fail;
26200 swig_obj[0] = args;
26201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26202 if (!SWIG_IsOK(res1)) {
26203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26204 }
26205 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (bool)((wxDateTime const *)arg1)->IsValid();
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 {
26213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26214 }
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 PyObject *resultobj = 0;
26223 wxDateTime *arg1 = (wxDateTime *) 0 ;
26224 time_t result;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 PyObject *swig_obj[1] ;
26228
26229 if (!args) SWIG_fail;
26230 swig_obj[0] = args;
26231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26232 if (!SWIG_IsOK(res1)) {
26233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26234 }
26235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26236 {
26237 PyThreadState* __tstate = wxPyBeginAllowThreads();
26238 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj = 0;
26251 wxDateTime *arg1 = (wxDateTime *) 0 ;
26252 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26253 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26254 int result;
26255 void *argp1 = 0 ;
26256 int res1 = 0 ;
26257 bool temp2 = false ;
26258 PyObject * obj0 = 0 ;
26259 PyObject * obj1 = 0 ;
26260 char * kwnames[] = {
26261 (char *) "self",(char *) "tz", NULL
26262 };
26263
26264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26266 if (!SWIG_IsOK(res1)) {
26267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26268 }
26269 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26270 if (obj1) {
26271 {
26272 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26273 temp2 = true;
26274 }
26275 }
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_From_int(static_cast< int >(result));
26283 {
26284 if (temp2) delete arg2;
26285 }
26286 return resultobj;
26287 fail:
26288 {
26289 if (temp2) delete arg2;
26290 }
26291 return NULL;
26292 }
26293
26294
26295 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26296 PyObject *resultobj = 0;
26297 wxDateTime *arg1 = (wxDateTime *) 0 ;
26298 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26299 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26300 wxDateTime::Month result;
26301 void *argp1 = 0 ;
26302 int res1 = 0 ;
26303 bool temp2 = false ;
26304 PyObject * obj0 = 0 ;
26305 PyObject * obj1 = 0 ;
26306 char * kwnames[] = {
26307 (char *) "self",(char *) "tz", NULL
26308 };
26309
26310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26312 if (!SWIG_IsOK(res1)) {
26313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26314 }
26315 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26316 if (obj1) {
26317 {
26318 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26319 temp2 = true;
26320 }
26321 }
26322 {
26323 PyThreadState* __tstate = wxPyBeginAllowThreads();
26324 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26325 wxPyEndAllowThreads(__tstate);
26326 if (PyErr_Occurred()) SWIG_fail;
26327 }
26328 resultobj = SWIG_From_int(static_cast< int >(result));
26329 {
26330 if (temp2) delete arg2;
26331 }
26332 return resultobj;
26333 fail:
26334 {
26335 if (temp2) delete arg2;
26336 }
26337 return NULL;
26338 }
26339
26340
26341 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj = 0;
26343 wxDateTime *arg1 = (wxDateTime *) 0 ;
26344 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26345 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26346 int result;
26347 void *argp1 = 0 ;
26348 int res1 = 0 ;
26349 bool temp2 = false ;
26350 PyObject * obj0 = 0 ;
26351 PyObject * obj1 = 0 ;
26352 char * kwnames[] = {
26353 (char *) "self",(char *) "tz", NULL
26354 };
26355
26356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26360 }
26361 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26362 if (obj1) {
26363 {
26364 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26365 temp2 = true;
26366 }
26367 }
26368 {
26369 PyThreadState* __tstate = wxPyBeginAllowThreads();
26370 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26371 wxPyEndAllowThreads(__tstate);
26372 if (PyErr_Occurred()) SWIG_fail;
26373 }
26374 resultobj = SWIG_From_int(static_cast< int >(result));
26375 {
26376 if (temp2) delete arg2;
26377 }
26378 return resultobj;
26379 fail:
26380 {
26381 if (temp2) delete arg2;
26382 }
26383 return NULL;
26384 }
26385
26386
26387 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26388 PyObject *resultobj = 0;
26389 wxDateTime *arg1 = (wxDateTime *) 0 ;
26390 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26391 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26392 wxDateTime::WeekDay result;
26393 void *argp1 = 0 ;
26394 int res1 = 0 ;
26395 bool temp2 = false ;
26396 PyObject * obj0 = 0 ;
26397 PyObject * obj1 = 0 ;
26398 char * kwnames[] = {
26399 (char *) "self",(char *) "tz", NULL
26400 };
26401
26402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26404 if (!SWIG_IsOK(res1)) {
26405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26406 }
26407 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26408 if (obj1) {
26409 {
26410 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26411 temp2 = true;
26412 }
26413 }
26414 {
26415 PyThreadState* __tstate = wxPyBeginAllowThreads();
26416 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26417 wxPyEndAllowThreads(__tstate);
26418 if (PyErr_Occurred()) SWIG_fail;
26419 }
26420 resultobj = SWIG_From_int(static_cast< int >(result));
26421 {
26422 if (temp2) delete arg2;
26423 }
26424 return resultobj;
26425 fail:
26426 {
26427 if (temp2) delete arg2;
26428 }
26429 return NULL;
26430 }
26431
26432
26433 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj = 0;
26435 wxDateTime *arg1 = (wxDateTime *) 0 ;
26436 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26437 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26438 int result;
26439 void *argp1 = 0 ;
26440 int res1 = 0 ;
26441 bool temp2 = false ;
26442 PyObject * obj0 = 0 ;
26443 PyObject * obj1 = 0 ;
26444 char * kwnames[] = {
26445 (char *) "self",(char *) "tz", NULL
26446 };
26447
26448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26450 if (!SWIG_IsOK(res1)) {
26451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26452 }
26453 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26454 if (obj1) {
26455 {
26456 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26457 temp2 = true;
26458 }
26459 }
26460 {
26461 PyThreadState* __tstate = wxPyBeginAllowThreads();
26462 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26463 wxPyEndAllowThreads(__tstate);
26464 if (PyErr_Occurred()) SWIG_fail;
26465 }
26466 resultobj = SWIG_From_int(static_cast< int >(result));
26467 {
26468 if (temp2) delete arg2;
26469 }
26470 return resultobj;
26471 fail:
26472 {
26473 if (temp2) delete arg2;
26474 }
26475 return NULL;
26476 }
26477
26478
26479 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26480 PyObject *resultobj = 0;
26481 wxDateTime *arg1 = (wxDateTime *) 0 ;
26482 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26483 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26484 int result;
26485 void *argp1 = 0 ;
26486 int res1 = 0 ;
26487 bool temp2 = false ;
26488 PyObject * obj0 = 0 ;
26489 PyObject * obj1 = 0 ;
26490 char * kwnames[] = {
26491 (char *) "self",(char *) "tz", NULL
26492 };
26493
26494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26496 if (!SWIG_IsOK(res1)) {
26497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26498 }
26499 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26500 if (obj1) {
26501 {
26502 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26503 temp2 = true;
26504 }
26505 }
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 resultobj = SWIG_From_int(static_cast< int >(result));
26513 {
26514 if (temp2) delete arg2;
26515 }
26516 return resultobj;
26517 fail:
26518 {
26519 if (temp2) delete arg2;
26520 }
26521 return NULL;
26522 }
26523
26524
26525 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26526 PyObject *resultobj = 0;
26527 wxDateTime *arg1 = (wxDateTime *) 0 ;
26528 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26529 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26530 int result;
26531 void *argp1 = 0 ;
26532 int res1 = 0 ;
26533 bool temp2 = false ;
26534 PyObject * obj0 = 0 ;
26535 PyObject * obj1 = 0 ;
26536 char * kwnames[] = {
26537 (char *) "self",(char *) "tz", NULL
26538 };
26539
26540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26542 if (!SWIG_IsOK(res1)) {
26543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26544 }
26545 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26546 if (obj1) {
26547 {
26548 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26549 temp2 = true;
26550 }
26551 }
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 resultobj = SWIG_From_int(static_cast< int >(result));
26559 {
26560 if (temp2) delete arg2;
26561 }
26562 return resultobj;
26563 fail:
26564 {
26565 if (temp2) delete arg2;
26566 }
26567 return NULL;
26568 }
26569
26570
26571 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26572 PyObject *resultobj = 0;
26573 wxDateTime *arg1 = (wxDateTime *) 0 ;
26574 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26575 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26576 int result;
26577 void *argp1 = 0 ;
26578 int res1 = 0 ;
26579 bool temp2 = false ;
26580 PyObject * obj0 = 0 ;
26581 PyObject * obj1 = 0 ;
26582 char * kwnames[] = {
26583 (char *) "self",(char *) "tz", NULL
26584 };
26585
26586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26588 if (!SWIG_IsOK(res1)) {
26589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26590 }
26591 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26592 if (obj1) {
26593 {
26594 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26595 temp2 = true;
26596 }
26597 }
26598 {
26599 PyThreadState* __tstate = wxPyBeginAllowThreads();
26600 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26601 wxPyEndAllowThreads(__tstate);
26602 if (PyErr_Occurred()) SWIG_fail;
26603 }
26604 resultobj = SWIG_From_int(static_cast< int >(result));
26605 {
26606 if (temp2) delete arg2;
26607 }
26608 return resultobj;
26609 fail:
26610 {
26611 if (temp2) delete arg2;
26612 }
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26618 PyObject *resultobj = 0;
26619 wxDateTime *arg1 = (wxDateTime *) 0 ;
26620 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26621 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26622 int result;
26623 void *argp1 = 0 ;
26624 int res1 = 0 ;
26625 bool temp2 = false ;
26626 PyObject * obj0 = 0 ;
26627 PyObject * obj1 = 0 ;
26628 char * kwnames[] = {
26629 (char *) "self",(char *) "tz", NULL
26630 };
26631
26632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",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_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26636 }
26637 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26638 if (obj1) {
26639 {
26640 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26641 temp2 = true;
26642 }
26643 }
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26647 wxPyEndAllowThreads(__tstate);
26648 if (PyErr_Occurred()) SWIG_fail;
26649 }
26650 resultobj = SWIG_From_int(static_cast< int >(result));
26651 {
26652 if (temp2) delete arg2;
26653 }
26654 return resultobj;
26655 fail:
26656 {
26657 if (temp2) delete arg2;
26658 }
26659 return NULL;
26660 }
26661
26662
26663 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26664 PyObject *resultobj = 0;
26665 wxDateTime *arg1 = (wxDateTime *) 0 ;
26666 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26667 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26668 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26669 int result;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 int val2 ;
26673 int ecode2 = 0 ;
26674 bool temp3 = false ;
26675 PyObject * obj0 = 0 ;
26676 PyObject * obj1 = 0 ;
26677 PyObject * obj2 = 0 ;
26678 char * kwnames[] = {
26679 (char *) "self",(char *) "flags",(char *) "tz", NULL
26680 };
26681
26682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26684 if (!SWIG_IsOK(res1)) {
26685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26686 }
26687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26688 if (obj1) {
26689 ecode2 = SWIG_AsVal_int(obj1, &val2);
26690 if (!SWIG_IsOK(ecode2)) {
26691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26692 }
26693 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26694 }
26695 if (obj2) {
26696 {
26697 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26698 temp3 = true;
26699 }
26700 }
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 resultobj = SWIG_From_int(static_cast< int >(result));
26708 {
26709 if (temp3) delete arg3;
26710 }
26711 return resultobj;
26712 fail:
26713 {
26714 if (temp3) delete arg3;
26715 }
26716 return NULL;
26717 }
26718
26719
26720 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26721 PyObject *resultobj = 0;
26722 wxDateTime *arg1 = (wxDateTime *) 0 ;
26723 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26724 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26725 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26726 int result;
26727 void *argp1 = 0 ;
26728 int res1 = 0 ;
26729 int val2 ;
26730 int ecode2 = 0 ;
26731 bool temp3 = false ;
26732 PyObject * obj0 = 0 ;
26733 PyObject * obj1 = 0 ;
26734 PyObject * obj2 = 0 ;
26735 char * kwnames[] = {
26736 (char *) "self",(char *) "flags",(char *) "tz", NULL
26737 };
26738
26739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26741 if (!SWIG_IsOK(res1)) {
26742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26743 }
26744 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26745 if (obj1) {
26746 ecode2 = SWIG_AsVal_int(obj1, &val2);
26747 if (!SWIG_IsOK(ecode2)) {
26748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26749 }
26750 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26751 }
26752 if (obj2) {
26753 {
26754 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26755 temp3 = true;
26756 }
26757 }
26758 {
26759 PyThreadState* __tstate = wxPyBeginAllowThreads();
26760 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26761 wxPyEndAllowThreads(__tstate);
26762 if (PyErr_Occurred()) SWIG_fail;
26763 }
26764 resultobj = SWIG_From_int(static_cast< int >(result));
26765 {
26766 if (temp3) delete arg3;
26767 }
26768 return resultobj;
26769 fail:
26770 {
26771 if (temp3) delete arg3;
26772 }
26773 return NULL;
26774 }
26775
26776
26777 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26778 PyObject *resultobj = 0;
26779 wxDateTime *arg1 = (wxDateTime *) 0 ;
26780 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26781 bool result;
26782 void *argp1 = 0 ;
26783 int res1 = 0 ;
26784 int val2 ;
26785 int ecode2 = 0 ;
26786 PyObject * obj0 = 0 ;
26787 PyObject * obj1 = 0 ;
26788 char * kwnames[] = {
26789 (char *) "self",(char *) "country", NULL
26790 };
26791
26792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26794 if (!SWIG_IsOK(res1)) {
26795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26796 }
26797 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26798 if (obj1) {
26799 ecode2 = SWIG_AsVal_int(obj1, &val2);
26800 if (!SWIG_IsOK(ecode2)) {
26801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26802 }
26803 arg2 = static_cast< wxDateTime::Country >(val2);
26804 }
26805 {
26806 PyThreadState* __tstate = wxPyBeginAllowThreads();
26807 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26808 wxPyEndAllowThreads(__tstate);
26809 if (PyErr_Occurred()) SWIG_fail;
26810 }
26811 {
26812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26813 }
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj = 0;
26822 wxDateTime *arg1 = (wxDateTime *) 0 ;
26823 wxDateTime *arg2 = 0 ;
26824 bool result;
26825 void *argp1 = 0 ;
26826 int res1 = 0 ;
26827 void *argp2 = 0 ;
26828 int res2 = 0 ;
26829 PyObject * obj0 = 0 ;
26830 PyObject * obj1 = 0 ;
26831 char * kwnames[] = {
26832 (char *) "self",(char *) "datetime", NULL
26833 };
26834
26835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26837 if (!SWIG_IsOK(res1)) {
26838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26839 }
26840 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26842 if (!SWIG_IsOK(res2)) {
26843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26844 }
26845 if (!argp2) {
26846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26847 }
26848 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26849 {
26850 PyThreadState* __tstate = wxPyBeginAllowThreads();
26851 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26852 wxPyEndAllowThreads(__tstate);
26853 if (PyErr_Occurred()) SWIG_fail;
26854 }
26855 {
26856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26857 }
26858 return resultobj;
26859 fail:
26860 return NULL;
26861 }
26862
26863
26864 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26865 PyObject *resultobj = 0;
26866 wxDateTime *arg1 = (wxDateTime *) 0 ;
26867 wxDateTime *arg2 = 0 ;
26868 bool result;
26869 void *argp1 = 0 ;
26870 int res1 = 0 ;
26871 void *argp2 = 0 ;
26872 int res2 = 0 ;
26873 PyObject * obj0 = 0 ;
26874 PyObject * obj1 = 0 ;
26875 char * kwnames[] = {
26876 (char *) "self",(char *) "datetime", NULL
26877 };
26878
26879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26881 if (!SWIG_IsOK(res1)) {
26882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26883 }
26884 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26885 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26886 if (!SWIG_IsOK(res2)) {
26887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26888 }
26889 if (!argp2) {
26890 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26891 }
26892 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26893 {
26894 PyThreadState* __tstate = wxPyBeginAllowThreads();
26895 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26896 wxPyEndAllowThreads(__tstate);
26897 if (PyErr_Occurred()) SWIG_fail;
26898 }
26899 {
26900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26901 }
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26909 PyObject *resultobj = 0;
26910 wxDateTime *arg1 = (wxDateTime *) 0 ;
26911 wxDateTime *arg2 = 0 ;
26912 bool result;
26913 void *argp1 = 0 ;
26914 int res1 = 0 ;
26915 void *argp2 = 0 ;
26916 int res2 = 0 ;
26917 PyObject * obj0 = 0 ;
26918 PyObject * obj1 = 0 ;
26919 char * kwnames[] = {
26920 (char *) "self",(char *) "datetime", NULL
26921 };
26922
26923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26925 if (!SWIG_IsOK(res1)) {
26926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26927 }
26928 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26929 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26930 if (!SWIG_IsOK(res2)) {
26931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26932 }
26933 if (!argp2) {
26934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26935 }
26936 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26937 {
26938 PyThreadState* __tstate = wxPyBeginAllowThreads();
26939 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26940 wxPyEndAllowThreads(__tstate);
26941 if (PyErr_Occurred()) SWIG_fail;
26942 }
26943 {
26944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26945 }
26946 return resultobj;
26947 fail:
26948 return NULL;
26949 }
26950
26951
26952 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26953 PyObject *resultobj = 0;
26954 wxDateTime *arg1 = (wxDateTime *) 0 ;
26955 wxDateTime *arg2 = 0 ;
26956 wxDateTime *arg3 = 0 ;
26957 bool result;
26958 void *argp1 = 0 ;
26959 int res1 = 0 ;
26960 void *argp2 = 0 ;
26961 int res2 = 0 ;
26962 void *argp3 = 0 ;
26963 int res3 = 0 ;
26964 PyObject * obj0 = 0 ;
26965 PyObject * obj1 = 0 ;
26966 PyObject * obj2 = 0 ;
26967 char * kwnames[] = {
26968 (char *) "self",(char *) "t1",(char *) "t2", NULL
26969 };
26970
26971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26973 if (!SWIG_IsOK(res1)) {
26974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26975 }
26976 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26978 if (!SWIG_IsOK(res2)) {
26979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26980 }
26981 if (!argp2) {
26982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26983 }
26984 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26985 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26986 if (!SWIG_IsOK(res3)) {
26987 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26988 }
26989 if (!argp3) {
26990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26991 }
26992 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26993 {
26994 PyThreadState* __tstate = wxPyBeginAllowThreads();
26995 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 {
27000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27001 }
27002 return resultobj;
27003 fail:
27004 return NULL;
27005 }
27006
27007
27008 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27009 PyObject *resultobj = 0;
27010 wxDateTime *arg1 = (wxDateTime *) 0 ;
27011 wxDateTime *arg2 = 0 ;
27012 wxDateTime *arg3 = 0 ;
27013 bool result;
27014 void *argp1 = 0 ;
27015 int res1 = 0 ;
27016 void *argp2 = 0 ;
27017 int res2 = 0 ;
27018 void *argp3 = 0 ;
27019 int res3 = 0 ;
27020 PyObject * obj0 = 0 ;
27021 PyObject * obj1 = 0 ;
27022 PyObject * obj2 = 0 ;
27023 char * kwnames[] = {
27024 (char *) "self",(char *) "t1",(char *) "t2", NULL
27025 };
27026
27027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27029 if (!SWIG_IsOK(res1)) {
27030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27031 }
27032 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27033 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27034 if (!SWIG_IsOK(res2)) {
27035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27036 }
27037 if (!argp2) {
27038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27039 }
27040 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27041 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27042 if (!SWIG_IsOK(res3)) {
27043 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27044 }
27045 if (!argp3) {
27046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27047 }
27048 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27049 {
27050 PyThreadState* __tstate = wxPyBeginAllowThreads();
27051 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27052 wxPyEndAllowThreads(__tstate);
27053 if (PyErr_Occurred()) SWIG_fail;
27054 }
27055 {
27056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27057 }
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj = 0;
27066 wxDateTime *arg1 = (wxDateTime *) 0 ;
27067 wxDateTime *arg2 = 0 ;
27068 bool result;
27069 void *argp1 = 0 ;
27070 int res1 = 0 ;
27071 void *argp2 = 0 ;
27072 int res2 = 0 ;
27073 PyObject * obj0 = 0 ;
27074 PyObject * obj1 = 0 ;
27075 char * kwnames[] = {
27076 (char *) "self",(char *) "dt", NULL
27077 };
27078
27079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27081 if (!SWIG_IsOK(res1)) {
27082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27083 }
27084 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27085 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27086 if (!SWIG_IsOK(res2)) {
27087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27088 }
27089 if (!argp2) {
27090 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27091 }
27092 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27093 {
27094 PyThreadState* __tstate = wxPyBeginAllowThreads();
27095 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27096 wxPyEndAllowThreads(__tstate);
27097 if (PyErr_Occurred()) SWIG_fail;
27098 }
27099 {
27100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27101 }
27102 return resultobj;
27103 fail:
27104 return NULL;
27105 }
27106
27107
27108 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27109 PyObject *resultobj = 0;
27110 wxDateTime *arg1 = (wxDateTime *) 0 ;
27111 wxDateTime *arg2 = 0 ;
27112 bool result;
27113 void *argp1 = 0 ;
27114 int res1 = 0 ;
27115 void *argp2 = 0 ;
27116 int res2 = 0 ;
27117 PyObject * obj0 = 0 ;
27118 PyObject * obj1 = 0 ;
27119 char * kwnames[] = {
27120 (char *) "self",(char *) "dt", NULL
27121 };
27122
27123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27125 if (!SWIG_IsOK(res1)) {
27126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27127 }
27128 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27129 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27130 if (!SWIG_IsOK(res2)) {
27131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27132 }
27133 if (!argp2) {
27134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27135 }
27136 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27137 {
27138 PyThreadState* __tstate = wxPyBeginAllowThreads();
27139 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj = 0;
27154 wxDateTime *arg1 = (wxDateTime *) 0 ;
27155 wxDateTime *arg2 = 0 ;
27156 wxTimeSpan *arg3 = 0 ;
27157 bool result;
27158 void *argp1 = 0 ;
27159 int res1 = 0 ;
27160 void *argp2 = 0 ;
27161 int res2 = 0 ;
27162 void *argp3 = 0 ;
27163 int res3 = 0 ;
27164 PyObject * obj0 = 0 ;
27165 PyObject * obj1 = 0 ;
27166 PyObject * obj2 = 0 ;
27167 char * kwnames[] = {
27168 (char *) "self",(char *) "dt",(char *) "ts", NULL
27169 };
27170
27171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27173 if (!SWIG_IsOK(res1)) {
27174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27175 }
27176 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27177 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27178 if (!SWIG_IsOK(res2)) {
27179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27180 }
27181 if (!argp2) {
27182 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27183 }
27184 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27185 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27186 if (!SWIG_IsOK(res3)) {
27187 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27188 }
27189 if (!argp3) {
27190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27191 }
27192 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 {
27200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27201 }
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27209 PyObject *resultobj = 0;
27210 wxDateTime *arg1 = (wxDateTime *) 0 ;
27211 wxTimeSpan *arg2 = 0 ;
27212 wxDateTime *result = 0 ;
27213 void *argp1 = 0 ;
27214 int res1 = 0 ;
27215 void *argp2 = 0 ;
27216 int res2 = 0 ;
27217 PyObject * obj0 = 0 ;
27218 PyObject * obj1 = 0 ;
27219 char * kwnames[] = {
27220 (char *) "self",(char *) "diff", NULL
27221 };
27222
27223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27225 if (!SWIG_IsOK(res1)) {
27226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27227 }
27228 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27229 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27230 if (!SWIG_IsOK(res2)) {
27231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27232 }
27233 if (!argp2) {
27234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27235 }
27236 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 {
27240 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27241 result = (wxDateTime *) &_result_ref;
27242 }
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj = 0;
27255 wxDateTime *arg1 = (wxDateTime *) 0 ;
27256 wxDateSpan *arg2 = 0 ;
27257 wxDateTime *result = 0 ;
27258 void *argp1 = 0 ;
27259 int res1 = 0 ;
27260 void *argp2 = 0 ;
27261 int res2 = 0 ;
27262 PyObject * obj0 = 0 ;
27263 PyObject * obj1 = 0 ;
27264 char * kwnames[] = {
27265 (char *) "self",(char *) "diff", NULL
27266 };
27267
27268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27270 if (!SWIG_IsOK(res1)) {
27271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27272 }
27273 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27274 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27275 if (!SWIG_IsOK(res2)) {
27276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27277 }
27278 if (!argp2) {
27279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27280 }
27281 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27282 {
27283 PyThreadState* __tstate = wxPyBeginAllowThreads();
27284 {
27285 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27286 result = (wxDateTime *) &_result_ref;
27287 }
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27299 PyObject *resultobj = 0;
27300 wxDateTime *arg1 = (wxDateTime *) 0 ;
27301 wxTimeSpan *arg2 = 0 ;
27302 wxDateTime *result = 0 ;
27303 void *argp1 = 0 ;
27304 int res1 = 0 ;
27305 void *argp2 = 0 ;
27306 int res2 = 0 ;
27307 PyObject * obj0 = 0 ;
27308 PyObject * obj1 = 0 ;
27309 char * kwnames[] = {
27310 (char *) "self",(char *) "diff", NULL
27311 };
27312
27313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27315 if (!SWIG_IsOK(res1)) {
27316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27317 }
27318 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27319 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27320 if (!SWIG_IsOK(res2)) {
27321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27322 }
27323 if (!argp2) {
27324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27325 }
27326 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27327 {
27328 PyThreadState* __tstate = wxPyBeginAllowThreads();
27329 {
27330 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27331 result = (wxDateTime *) &_result_ref;
27332 }
27333 wxPyEndAllowThreads(__tstate);
27334 if (PyErr_Occurred()) SWIG_fail;
27335 }
27336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27337 return resultobj;
27338 fail:
27339 return NULL;
27340 }
27341
27342
27343 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27344 PyObject *resultobj = 0;
27345 wxDateTime *arg1 = (wxDateTime *) 0 ;
27346 wxDateSpan *arg2 = 0 ;
27347 wxDateTime *result = 0 ;
27348 void *argp1 = 0 ;
27349 int res1 = 0 ;
27350 void *argp2 = 0 ;
27351 int res2 = 0 ;
27352 PyObject * obj0 = 0 ;
27353 PyObject * obj1 = 0 ;
27354 char * kwnames[] = {
27355 (char *) "self",(char *) "diff", NULL
27356 };
27357
27358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27360 if (!SWIG_IsOK(res1)) {
27361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27362 }
27363 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27365 if (!SWIG_IsOK(res2)) {
27366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27367 }
27368 if (!argp2) {
27369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27370 }
27371 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27372 {
27373 PyThreadState* __tstate = wxPyBeginAllowThreads();
27374 {
27375 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27376 result = (wxDateTime *) &_result_ref;
27377 }
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27389 PyObject *resultobj = 0;
27390 wxDateTime *arg1 = (wxDateTime *) 0 ;
27391 wxDateTime *arg2 = 0 ;
27392 wxTimeSpan result;
27393 void *argp1 = 0 ;
27394 int res1 = 0 ;
27395 void *argp2 = 0 ;
27396 int res2 = 0 ;
27397 PyObject * obj0 = 0 ;
27398 PyObject * obj1 = 0 ;
27399 char * kwnames[] = {
27400 (char *) "self",(char *) "dt", NULL
27401 };
27402
27403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27405 if (!SWIG_IsOK(res1)) {
27406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27407 }
27408 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27409 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27410 if (!SWIG_IsOK(res2)) {
27411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27412 }
27413 if (!argp2) {
27414 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27415 }
27416 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27417 {
27418 PyThreadState* __tstate = wxPyBeginAllowThreads();
27419 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27431 PyObject *resultobj = 0;
27432 wxDateTime *arg1 = (wxDateTime *) 0 ;
27433 wxTimeSpan *arg2 = 0 ;
27434 wxDateTime *result = 0 ;
27435 void *argp1 = 0 ;
27436 int res1 = 0 ;
27437 void *argp2 = 0 ;
27438 int res2 = 0 ;
27439
27440 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27442 if (!SWIG_IsOK(res1)) {
27443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27444 }
27445 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27446 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27447 if (!SWIG_IsOK(res2)) {
27448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27449 }
27450 if (!argp2) {
27451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27452 }
27453 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 {
27457 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27458 result = (wxDateTime *) &_result_ref;
27459 }
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27471 PyObject *resultobj = 0;
27472 wxDateTime *arg1 = (wxDateTime *) 0 ;
27473 wxDateSpan *arg2 = 0 ;
27474 wxDateTime *result = 0 ;
27475 void *argp1 = 0 ;
27476 int res1 = 0 ;
27477 void *argp2 = 0 ;
27478 int res2 = 0 ;
27479
27480 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27482 if (!SWIG_IsOK(res1)) {
27483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27484 }
27485 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27486 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27487 if (!SWIG_IsOK(res2)) {
27488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27489 }
27490 if (!argp2) {
27491 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27492 }
27493 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27494 {
27495 PyThreadState* __tstate = wxPyBeginAllowThreads();
27496 {
27497 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27498 result = (wxDateTime *) &_result_ref;
27499 }
27500 wxPyEndAllowThreads(__tstate);
27501 if (PyErr_Occurred()) SWIG_fail;
27502 }
27503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27504 return resultobj;
27505 fail:
27506 return NULL;
27507 }
27508
27509
27510 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27511 int argc;
27512 PyObject *argv[3];
27513
27514 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27515 --argc;
27516 if (argc == 2) {
27517 int _v = 0;
27518 {
27519 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27520 _v = SWIG_CheckState(res);
27521 }
27522 if (!_v) goto check_1;
27523 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27524 }
27525 check_1:
27526
27527 if (argc == 2) {
27528 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27529 }
27530
27531 fail:
27532 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27538 PyObject *resultobj = 0;
27539 wxDateTime *arg1 = (wxDateTime *) 0 ;
27540 wxTimeSpan *arg2 = 0 ;
27541 wxDateTime *result = 0 ;
27542 void *argp1 = 0 ;
27543 int res1 = 0 ;
27544 void *argp2 = 0 ;
27545 int res2 = 0 ;
27546
27547 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27549 if (!SWIG_IsOK(res1)) {
27550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27551 }
27552 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27553 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27554 if (!SWIG_IsOK(res2)) {
27555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27556 }
27557 if (!argp2) {
27558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27559 }
27560 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27561 {
27562 PyThreadState* __tstate = wxPyBeginAllowThreads();
27563 {
27564 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27565 result = (wxDateTime *) &_result_ref;
27566 }
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27571 return resultobj;
27572 fail:
27573 return NULL;
27574 }
27575
27576
27577 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27578 PyObject *resultobj = 0;
27579 wxDateTime *arg1 = (wxDateTime *) 0 ;
27580 wxDateSpan *arg2 = 0 ;
27581 wxDateTime *result = 0 ;
27582 void *argp1 = 0 ;
27583 int res1 = 0 ;
27584 void *argp2 = 0 ;
27585 int res2 = 0 ;
27586
27587 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27589 if (!SWIG_IsOK(res1)) {
27590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27591 }
27592 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27593 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27594 if (!SWIG_IsOK(res2)) {
27595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27596 }
27597 if (!argp2) {
27598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27599 }
27600 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 {
27604 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27605 result = (wxDateTime *) &_result_ref;
27606 }
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27618 int argc;
27619 PyObject *argv[3];
27620
27621 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27622 --argc;
27623 if (argc == 2) {
27624 int _v = 0;
27625 {
27626 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27627 _v = SWIG_CheckState(res);
27628 }
27629 if (!_v) goto check_1;
27630 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27631 }
27632 check_1:
27633
27634 if (argc == 2) {
27635 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27636 }
27637
27638 fail:
27639 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27640 return NULL;
27641 }
27642
27643
27644 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27645 PyObject *resultobj = 0;
27646 wxDateTime *arg1 = (wxDateTime *) 0 ;
27647 wxTimeSpan *arg2 = 0 ;
27648 wxDateTime result;
27649 void *argp1 = 0 ;
27650 int res1 = 0 ;
27651 void *argp2 = 0 ;
27652 int res2 = 0 ;
27653
27654 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27656 if (!SWIG_IsOK(res1)) {
27657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27658 }
27659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27660 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27661 if (!SWIG_IsOK(res2)) {
27662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27663 }
27664 if (!argp2) {
27665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27666 }
27667 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27682 PyObject *resultobj = 0;
27683 wxDateTime *arg1 = (wxDateTime *) 0 ;
27684 wxDateSpan *arg2 = 0 ;
27685 wxDateTime result;
27686 void *argp1 = 0 ;
27687 int res1 = 0 ;
27688 void *argp2 = 0 ;
27689 int res2 = 0 ;
27690
27691 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27693 if (!SWIG_IsOK(res1)) {
27694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27695 }
27696 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27697 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27698 if (!SWIG_IsOK(res2)) {
27699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27700 }
27701 if (!argp2) {
27702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27703 }
27704 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27708 wxPyEndAllowThreads(__tstate);
27709 if (PyErr_Occurred()) SWIG_fail;
27710 }
27711 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27719 int argc;
27720 PyObject *argv[3];
27721
27722 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27723 --argc;
27724 if (argc == 2) {
27725 int _v = 0;
27726 {
27727 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27728 _v = SWIG_CheckState(res);
27729 }
27730 if (!_v) goto check_1;
27731 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27732 }
27733 check_1:
27734
27735 if (argc == 2) {
27736 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27737 }
27738
27739 fail:
27740 Py_INCREF(Py_NotImplemented);
27741 return Py_NotImplemented;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27746 PyObject *resultobj = 0;
27747 wxDateTime *arg1 = (wxDateTime *) 0 ;
27748 wxDateTime *arg2 = 0 ;
27749 wxTimeSpan result;
27750 void *argp1 = 0 ;
27751 int res1 = 0 ;
27752 void *argp2 = 0 ;
27753 int res2 = 0 ;
27754
27755 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27757 if (!SWIG_IsOK(res1)) {
27758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27759 }
27760 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27761 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27762 if (!SWIG_IsOK(res2)) {
27763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27764 }
27765 if (!argp2) {
27766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27767 }
27768 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27769 {
27770 PyThreadState* __tstate = wxPyBeginAllowThreads();
27771 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27772 wxPyEndAllowThreads(__tstate);
27773 if (PyErr_Occurred()) SWIG_fail;
27774 }
27775 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27776 return resultobj;
27777 fail:
27778 return NULL;
27779 }
27780
27781
27782 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27783 PyObject *resultobj = 0;
27784 wxDateTime *arg1 = (wxDateTime *) 0 ;
27785 wxTimeSpan *arg2 = 0 ;
27786 wxDateTime result;
27787 void *argp1 = 0 ;
27788 int res1 = 0 ;
27789 void *argp2 = 0 ;
27790 int res2 = 0 ;
27791
27792 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27794 if (!SWIG_IsOK(res1)) {
27795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27796 }
27797 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27798 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27799 if (!SWIG_IsOK(res2)) {
27800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27801 }
27802 if (!argp2) {
27803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27804 }
27805 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27809 wxPyEndAllowThreads(__tstate);
27810 if (PyErr_Occurred()) SWIG_fail;
27811 }
27812 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27813 return resultobj;
27814 fail:
27815 return NULL;
27816 }
27817
27818
27819 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27820 PyObject *resultobj = 0;
27821 wxDateTime *arg1 = (wxDateTime *) 0 ;
27822 wxDateSpan *arg2 = 0 ;
27823 wxDateTime result;
27824 void *argp1 = 0 ;
27825 int res1 = 0 ;
27826 void *argp2 = 0 ;
27827 int res2 = 0 ;
27828
27829 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27831 if (!SWIG_IsOK(res1)) {
27832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27833 }
27834 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27835 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27836 if (!SWIG_IsOK(res2)) {
27837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27838 }
27839 if (!argp2) {
27840 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27841 }
27842 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27843 {
27844 PyThreadState* __tstate = wxPyBeginAllowThreads();
27845 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27850 return resultobj;
27851 fail:
27852 return NULL;
27853 }
27854
27855
27856 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27857 int argc;
27858 PyObject *argv[3];
27859
27860 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27861 --argc;
27862 if (argc == 2) {
27863 int _v = 0;
27864 {
27865 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27866 _v = SWIG_CheckState(res);
27867 }
27868 if (!_v) goto check_1;
27869 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27870 }
27871 check_1:
27872
27873 if (argc == 2) {
27874 int _v = 0;
27875 {
27876 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27877 _v = SWIG_CheckState(res);
27878 }
27879 if (!_v) goto check_2;
27880 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27881 }
27882 check_2:
27883
27884 if (argc == 2) {
27885 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27886 }
27887
27888 fail:
27889 Py_INCREF(Py_NotImplemented);
27890 return Py_NotImplemented;
27891 }
27892
27893
27894 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27895 PyObject *resultobj = 0;
27896 wxDateTime *arg1 = (wxDateTime *) 0 ;
27897 wxDateTime *arg2 = (wxDateTime *) 0 ;
27898 bool result;
27899 void *argp1 = 0 ;
27900 int res1 = 0 ;
27901 void *argp2 = 0 ;
27902 int res2 = 0 ;
27903 PyObject * obj0 = 0 ;
27904 PyObject * obj1 = 0 ;
27905 char * kwnames[] = {
27906 (char *) "self",(char *) "other", NULL
27907 };
27908
27909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27911 if (!SWIG_IsOK(res1)) {
27912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27913 }
27914 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27916 if (!SWIG_IsOK(res2)) {
27917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27918 }
27919 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27920 {
27921 PyThreadState* __tstate = wxPyBeginAllowThreads();
27922 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 {
27927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27928 }
27929 return resultobj;
27930 fail:
27931 return NULL;
27932 }
27933
27934
27935 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27936 PyObject *resultobj = 0;
27937 wxDateTime *arg1 = (wxDateTime *) 0 ;
27938 wxDateTime *arg2 = (wxDateTime *) 0 ;
27939 bool result;
27940 void *argp1 = 0 ;
27941 int res1 = 0 ;
27942 void *argp2 = 0 ;
27943 int res2 = 0 ;
27944 PyObject * obj0 = 0 ;
27945 PyObject * obj1 = 0 ;
27946 char * kwnames[] = {
27947 (char *) "self",(char *) "other", NULL
27948 };
27949
27950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27952 if (!SWIG_IsOK(res1)) {
27953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27954 }
27955 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27956 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27957 if (!SWIG_IsOK(res2)) {
27958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27959 }
27960 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 {
27968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27969 }
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27977 PyObject *resultobj = 0;
27978 wxDateTime *arg1 = (wxDateTime *) 0 ;
27979 wxDateTime *arg2 = (wxDateTime *) 0 ;
27980 bool result;
27981 void *argp1 = 0 ;
27982 int res1 = 0 ;
27983 void *argp2 = 0 ;
27984 int res2 = 0 ;
27985 PyObject * obj0 = 0 ;
27986 PyObject * obj1 = 0 ;
27987 char * kwnames[] = {
27988 (char *) "self",(char *) "other", NULL
27989 };
27990
27991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27993 if (!SWIG_IsOK(res1)) {
27994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27995 }
27996 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27998 if (!SWIG_IsOK(res2)) {
27999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28000 }
28001 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28002 {
28003 PyThreadState* __tstate = wxPyBeginAllowThreads();
28004 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28005 wxPyEndAllowThreads(__tstate);
28006 if (PyErr_Occurred()) SWIG_fail;
28007 }
28008 {
28009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28010 }
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj = 0;
28019 wxDateTime *arg1 = (wxDateTime *) 0 ;
28020 wxDateTime *arg2 = (wxDateTime *) 0 ;
28021 bool result;
28022 void *argp1 = 0 ;
28023 int res1 = 0 ;
28024 void *argp2 = 0 ;
28025 int res2 = 0 ;
28026 PyObject * obj0 = 0 ;
28027 PyObject * obj1 = 0 ;
28028 char * kwnames[] = {
28029 (char *) "self",(char *) "other", NULL
28030 };
28031
28032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28034 if (!SWIG_IsOK(res1)) {
28035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28036 }
28037 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28039 if (!SWIG_IsOK(res2)) {
28040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28041 }
28042 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28043 {
28044 PyThreadState* __tstate = wxPyBeginAllowThreads();
28045 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28046 wxPyEndAllowThreads(__tstate);
28047 if (PyErr_Occurred()) SWIG_fail;
28048 }
28049 {
28050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28051 }
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj = 0;
28060 wxDateTime *arg1 = (wxDateTime *) 0 ;
28061 wxDateTime *arg2 = (wxDateTime *) 0 ;
28062 bool result;
28063 void *argp1 = 0 ;
28064 int res1 = 0 ;
28065 void *argp2 = 0 ;
28066 int res2 = 0 ;
28067 PyObject * obj0 = 0 ;
28068 PyObject * obj1 = 0 ;
28069 char * kwnames[] = {
28070 (char *) "self",(char *) "other", NULL
28071 };
28072
28073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28075 if (!SWIG_IsOK(res1)) {
28076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28077 }
28078 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28080 if (!SWIG_IsOK(res2)) {
28081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28082 }
28083 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28087 wxPyEndAllowThreads(__tstate);
28088 if (PyErr_Occurred()) SWIG_fail;
28089 }
28090 {
28091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28092 }
28093 return resultobj;
28094 fail:
28095 return NULL;
28096 }
28097
28098
28099 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28100 PyObject *resultobj = 0;
28101 wxDateTime *arg1 = (wxDateTime *) 0 ;
28102 wxDateTime *arg2 = (wxDateTime *) 0 ;
28103 bool result;
28104 void *argp1 = 0 ;
28105 int res1 = 0 ;
28106 void *argp2 = 0 ;
28107 int res2 = 0 ;
28108 PyObject * obj0 = 0 ;
28109 PyObject * obj1 = 0 ;
28110 char * kwnames[] = {
28111 (char *) "self",(char *) "other", NULL
28112 };
28113
28114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28116 if (!SWIG_IsOK(res1)) {
28117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28118 }
28119 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28121 if (!SWIG_IsOK(res2)) {
28122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28123 }
28124 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 {
28132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28133 }
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28141 PyObject *resultobj = 0;
28142 wxDateTime *arg1 = (wxDateTime *) 0 ;
28143 wxString *arg2 = 0 ;
28144 int result;
28145 void *argp1 = 0 ;
28146 int res1 = 0 ;
28147 bool temp2 = false ;
28148 PyObject * obj0 = 0 ;
28149 PyObject * obj1 = 0 ;
28150 char * kwnames[] = {
28151 (char *) "self",(char *) "date", NULL
28152 };
28153
28154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28156 if (!SWIG_IsOK(res1)) {
28157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28158 }
28159 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28160 {
28161 arg2 = wxString_in_helper(obj1);
28162 if (arg2 == NULL) SWIG_fail;
28163 temp2 = true;
28164 }
28165 {
28166 PyThreadState* __tstate = wxPyBeginAllowThreads();
28167 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28168 wxPyEndAllowThreads(__tstate);
28169 if (PyErr_Occurred()) SWIG_fail;
28170 }
28171 resultobj = SWIG_From_int(static_cast< int >(result));
28172 {
28173 if (temp2)
28174 delete arg2;
28175 }
28176 return resultobj;
28177 fail:
28178 {
28179 if (temp2)
28180 delete arg2;
28181 }
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28187 PyObject *resultobj = 0;
28188 wxDateTime *arg1 = (wxDateTime *) 0 ;
28189 wxString *arg2 = 0 ;
28190 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28191 wxString *arg3 = (wxString *) &arg3_defvalue ;
28192 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28193 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28194 int result;
28195 void *argp1 = 0 ;
28196 int res1 = 0 ;
28197 bool temp2 = false ;
28198 bool temp3 = false ;
28199 void *argp4 = 0 ;
28200 int res4 = 0 ;
28201 PyObject * obj0 = 0 ;
28202 PyObject * obj1 = 0 ;
28203 PyObject * obj2 = 0 ;
28204 PyObject * obj3 = 0 ;
28205 char * kwnames[] = {
28206 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28207 };
28208
28209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28211 if (!SWIG_IsOK(res1)) {
28212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28213 }
28214 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28215 {
28216 arg2 = wxString_in_helper(obj1);
28217 if (arg2 == NULL) SWIG_fail;
28218 temp2 = true;
28219 }
28220 if (obj2) {
28221 {
28222 arg3 = wxString_in_helper(obj2);
28223 if (arg3 == NULL) SWIG_fail;
28224 temp3 = true;
28225 }
28226 }
28227 if (obj3) {
28228 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28229 if (!SWIG_IsOK(res4)) {
28230 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28231 }
28232 if (!argp4) {
28233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28234 }
28235 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28236 }
28237 {
28238 PyThreadState* __tstate = wxPyBeginAllowThreads();
28239 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 resultobj = SWIG_From_int(static_cast< int >(result));
28244 {
28245 if (temp2)
28246 delete arg2;
28247 }
28248 {
28249 if (temp3)
28250 delete arg3;
28251 }
28252 return resultobj;
28253 fail:
28254 {
28255 if (temp2)
28256 delete arg2;
28257 }
28258 {
28259 if (temp3)
28260 delete arg3;
28261 }
28262 return NULL;
28263 }
28264
28265
28266 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28267 PyObject *resultobj = 0;
28268 wxDateTime *arg1 = (wxDateTime *) 0 ;
28269 wxString *arg2 = 0 ;
28270 int result;
28271 void *argp1 = 0 ;
28272 int res1 = 0 ;
28273 bool temp2 = false ;
28274 PyObject * obj0 = 0 ;
28275 PyObject * obj1 = 0 ;
28276 char * kwnames[] = {
28277 (char *) "self",(char *) "datetime", NULL
28278 };
28279
28280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28282 if (!SWIG_IsOK(res1)) {
28283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28284 }
28285 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28286 {
28287 arg2 = wxString_in_helper(obj1);
28288 if (arg2 == NULL) SWIG_fail;
28289 temp2 = true;
28290 }
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 resultobj = SWIG_From_int(static_cast< int >(result));
28298 {
28299 if (temp2)
28300 delete arg2;
28301 }
28302 return resultobj;
28303 fail:
28304 {
28305 if (temp2)
28306 delete arg2;
28307 }
28308 return NULL;
28309 }
28310
28311
28312 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28313 PyObject *resultobj = 0;
28314 wxDateTime *arg1 = (wxDateTime *) 0 ;
28315 wxString *arg2 = 0 ;
28316 int result;
28317 void *argp1 = 0 ;
28318 int res1 = 0 ;
28319 bool temp2 = false ;
28320 PyObject * obj0 = 0 ;
28321 PyObject * obj1 = 0 ;
28322 char * kwnames[] = {
28323 (char *) "self",(char *) "date", NULL
28324 };
28325
28326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28328 if (!SWIG_IsOK(res1)) {
28329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28330 }
28331 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28332 {
28333 arg2 = wxString_in_helper(obj1);
28334 if (arg2 == NULL) SWIG_fail;
28335 temp2 = true;
28336 }
28337 {
28338 PyThreadState* __tstate = wxPyBeginAllowThreads();
28339 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28340 wxPyEndAllowThreads(__tstate);
28341 if (PyErr_Occurred()) SWIG_fail;
28342 }
28343 resultobj = SWIG_From_int(static_cast< int >(result));
28344 {
28345 if (temp2)
28346 delete arg2;
28347 }
28348 return resultobj;
28349 fail:
28350 {
28351 if (temp2)
28352 delete arg2;
28353 }
28354 return NULL;
28355 }
28356
28357
28358 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28359 PyObject *resultobj = 0;
28360 wxDateTime *arg1 = (wxDateTime *) 0 ;
28361 wxString *arg2 = 0 ;
28362 int result;
28363 void *argp1 = 0 ;
28364 int res1 = 0 ;
28365 bool temp2 = false ;
28366 PyObject * obj0 = 0 ;
28367 PyObject * obj1 = 0 ;
28368 char * kwnames[] = {
28369 (char *) "self",(char *) "time", NULL
28370 };
28371
28372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28374 if (!SWIG_IsOK(res1)) {
28375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28376 }
28377 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28378 {
28379 arg2 = wxString_in_helper(obj1);
28380 if (arg2 == NULL) SWIG_fail;
28381 temp2 = true;
28382 }
28383 {
28384 PyThreadState* __tstate = wxPyBeginAllowThreads();
28385 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 resultobj = SWIG_From_int(static_cast< int >(result));
28390 {
28391 if (temp2)
28392 delete arg2;
28393 }
28394 return resultobj;
28395 fail:
28396 {
28397 if (temp2)
28398 delete arg2;
28399 }
28400 return NULL;
28401 }
28402
28403
28404 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28405 PyObject *resultobj = 0;
28406 wxDateTime *arg1 = (wxDateTime *) 0 ;
28407 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28408 wxString *arg2 = (wxString *) &arg2_defvalue ;
28409 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28410 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28411 wxString result;
28412 void *argp1 = 0 ;
28413 int res1 = 0 ;
28414 bool temp2 = false ;
28415 bool temp3 = false ;
28416 PyObject * obj0 = 0 ;
28417 PyObject * obj1 = 0 ;
28418 PyObject * obj2 = 0 ;
28419 char * kwnames[] = {
28420 (char *) "self",(char *) "format",(char *) "tz", NULL
28421 };
28422
28423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28425 if (!SWIG_IsOK(res1)) {
28426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28427 }
28428 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28429 if (obj1) {
28430 {
28431 arg2 = wxString_in_helper(obj1);
28432 if (arg2 == NULL) SWIG_fail;
28433 temp2 = true;
28434 }
28435 }
28436 if (obj2) {
28437 {
28438 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28439 temp3 = true;
28440 }
28441 }
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28445 wxPyEndAllowThreads(__tstate);
28446 if (PyErr_Occurred()) SWIG_fail;
28447 }
28448 {
28449 #if wxUSE_UNICODE
28450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28451 #else
28452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28453 #endif
28454 }
28455 {
28456 if (temp2)
28457 delete arg2;
28458 }
28459 {
28460 if (temp3) delete arg3;
28461 }
28462 return resultobj;
28463 fail:
28464 {
28465 if (temp2)
28466 delete arg2;
28467 }
28468 {
28469 if (temp3) delete arg3;
28470 }
28471 return NULL;
28472 }
28473
28474
28475 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28476 PyObject *resultobj = 0;
28477 wxDateTime *arg1 = (wxDateTime *) 0 ;
28478 wxString result;
28479 void *argp1 = 0 ;
28480 int res1 = 0 ;
28481 PyObject *swig_obj[1] ;
28482
28483 if (!args) SWIG_fail;
28484 swig_obj[0] = args;
28485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28486 if (!SWIG_IsOK(res1)) {
28487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28488 }
28489 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 result = ((wxDateTime const *)arg1)->FormatDate();
28493 wxPyEndAllowThreads(__tstate);
28494 if (PyErr_Occurred()) SWIG_fail;
28495 }
28496 {
28497 #if wxUSE_UNICODE
28498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28499 #else
28500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28501 #endif
28502 }
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28510 PyObject *resultobj = 0;
28511 wxDateTime *arg1 = (wxDateTime *) 0 ;
28512 wxString result;
28513 void *argp1 = 0 ;
28514 int res1 = 0 ;
28515 PyObject *swig_obj[1] ;
28516
28517 if (!args) SWIG_fail;
28518 swig_obj[0] = args;
28519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28520 if (!SWIG_IsOK(res1)) {
28521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28522 }
28523 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 result = ((wxDateTime const *)arg1)->FormatTime();
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 {
28531 #if wxUSE_UNICODE
28532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28533 #else
28534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28535 #endif
28536 }
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28544 PyObject *resultobj = 0;
28545 wxDateTime *arg1 = (wxDateTime *) 0 ;
28546 wxString result;
28547 void *argp1 = 0 ;
28548 int res1 = 0 ;
28549 PyObject *swig_obj[1] ;
28550
28551 if (!args) SWIG_fail;
28552 swig_obj[0] = args;
28553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28554 if (!SWIG_IsOK(res1)) {
28555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28556 }
28557 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = ((wxDateTime const *)arg1)->FormatISODate();
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 {
28565 #if wxUSE_UNICODE
28566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28567 #else
28568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28569 #endif
28570 }
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28578 PyObject *resultobj = 0;
28579 wxDateTime *arg1 = (wxDateTime *) 0 ;
28580 wxString result;
28581 void *argp1 = 0 ;
28582 int res1 = 0 ;
28583 PyObject *swig_obj[1] ;
28584
28585 if (!args) SWIG_fail;
28586 swig_obj[0] = args;
28587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28588 if (!SWIG_IsOK(res1)) {
28589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28590 }
28591 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 result = ((wxDateTime const *)arg1)->FormatISOTime();
28595 wxPyEndAllowThreads(__tstate);
28596 if (PyErr_Occurred()) SWIG_fail;
28597 }
28598 {
28599 #if wxUSE_UNICODE
28600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28601 #else
28602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28603 #endif
28604 }
28605 return resultobj;
28606 fail:
28607 return NULL;
28608 }
28609
28610
28611 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28612 PyObject *obj;
28613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28614 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28615 return SWIG_Py_Void();
28616 }
28617
28618 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28619 return SWIG_Python_InitShadowInstance(args);
28620 }
28621
28622 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28623 PyObject *resultobj = 0;
28624 long arg1 ;
28625 wxTimeSpan result;
28626 long val1 ;
28627 int ecode1 = 0 ;
28628 PyObject * obj0 = 0 ;
28629 char * kwnames[] = {
28630 (char *) "ms", NULL
28631 };
28632
28633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28634 ecode1 = SWIG_AsVal_long(obj0, &val1);
28635 if (!SWIG_IsOK(ecode1)) {
28636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28637 }
28638 arg1 = static_cast< long >(val1);
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 result = wxTimeSpan::Milliseconds(arg1);
28642 wxPyEndAllowThreads(__tstate);
28643 if (PyErr_Occurred()) SWIG_fail;
28644 }
28645 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28646 return resultobj;
28647 fail:
28648 return NULL;
28649 }
28650
28651
28652 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28653 PyObject *resultobj = 0;
28654 wxTimeSpan result;
28655
28656 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28657 {
28658 PyThreadState* __tstate = wxPyBeginAllowThreads();
28659 result = wxTimeSpan::Millisecond();
28660 wxPyEndAllowThreads(__tstate);
28661 if (PyErr_Occurred()) SWIG_fail;
28662 }
28663 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28664 return resultobj;
28665 fail:
28666 return NULL;
28667 }
28668
28669
28670 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28671 PyObject *resultobj = 0;
28672 long arg1 ;
28673 wxTimeSpan result;
28674 long val1 ;
28675 int ecode1 = 0 ;
28676 PyObject * obj0 = 0 ;
28677 char * kwnames[] = {
28678 (char *) "sec", NULL
28679 };
28680
28681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28682 ecode1 = SWIG_AsVal_long(obj0, &val1);
28683 if (!SWIG_IsOK(ecode1)) {
28684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28685 }
28686 arg1 = static_cast< long >(val1);
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 result = wxTimeSpan::Seconds(arg1);
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28701 PyObject *resultobj = 0;
28702 wxTimeSpan result;
28703
28704 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 result = wxTimeSpan::Second();
28708 wxPyEndAllowThreads(__tstate);
28709 if (PyErr_Occurred()) SWIG_fail;
28710 }
28711 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28719 PyObject *resultobj = 0;
28720 long arg1 ;
28721 wxTimeSpan result;
28722 long val1 ;
28723 int ecode1 = 0 ;
28724 PyObject * obj0 = 0 ;
28725 char * kwnames[] = {
28726 (char *) "min", NULL
28727 };
28728
28729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28730 ecode1 = SWIG_AsVal_long(obj0, &val1);
28731 if (!SWIG_IsOK(ecode1)) {
28732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28733 }
28734 arg1 = static_cast< long >(val1);
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = wxTimeSpan::Minutes(arg1);
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28749 PyObject *resultobj = 0;
28750 wxTimeSpan result;
28751
28752 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28753 {
28754 PyThreadState* __tstate = wxPyBeginAllowThreads();
28755 result = wxTimeSpan::Minute();
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj = 0;
28768 long arg1 ;
28769 wxTimeSpan result;
28770 long val1 ;
28771 int ecode1 = 0 ;
28772 PyObject * obj0 = 0 ;
28773 char * kwnames[] = {
28774 (char *) "hours", NULL
28775 };
28776
28777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28778 ecode1 = SWIG_AsVal_long(obj0, &val1);
28779 if (!SWIG_IsOK(ecode1)) {
28780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28781 }
28782 arg1 = static_cast< long >(val1);
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = wxTimeSpan::Hours(arg1);
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28797 PyObject *resultobj = 0;
28798 wxTimeSpan result;
28799
28800 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28801 {
28802 PyThreadState* __tstate = wxPyBeginAllowThreads();
28803 result = wxTimeSpan::Hour();
28804 wxPyEndAllowThreads(__tstate);
28805 if (PyErr_Occurred()) SWIG_fail;
28806 }
28807 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28808 return resultobj;
28809 fail:
28810 return NULL;
28811 }
28812
28813
28814 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28815 PyObject *resultobj = 0;
28816 long arg1 ;
28817 wxTimeSpan result;
28818 long val1 ;
28819 int ecode1 = 0 ;
28820 PyObject * obj0 = 0 ;
28821 char * kwnames[] = {
28822 (char *) "days", NULL
28823 };
28824
28825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28826 ecode1 = SWIG_AsVal_long(obj0, &val1);
28827 if (!SWIG_IsOK(ecode1)) {
28828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28829 }
28830 arg1 = static_cast< long >(val1);
28831 {
28832 PyThreadState* __tstate = wxPyBeginAllowThreads();
28833 result = wxTimeSpan::Days(arg1);
28834 wxPyEndAllowThreads(__tstate);
28835 if (PyErr_Occurred()) SWIG_fail;
28836 }
28837 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28845 PyObject *resultobj = 0;
28846 wxTimeSpan result;
28847
28848 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 result = wxTimeSpan::Day();
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28863 PyObject *resultobj = 0;
28864 long arg1 ;
28865 wxTimeSpan result;
28866 long val1 ;
28867 int ecode1 = 0 ;
28868 PyObject * obj0 = 0 ;
28869 char * kwnames[] = {
28870 (char *) "days", NULL
28871 };
28872
28873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28874 ecode1 = SWIG_AsVal_long(obj0, &val1);
28875 if (!SWIG_IsOK(ecode1)) {
28876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28877 }
28878 arg1 = static_cast< long >(val1);
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 result = wxTimeSpan::Weeks(arg1);
28882 wxPyEndAllowThreads(__tstate);
28883 if (PyErr_Occurred()) SWIG_fail;
28884 }
28885 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28886 return resultobj;
28887 fail:
28888 return NULL;
28889 }
28890
28891
28892 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28893 PyObject *resultobj = 0;
28894 wxTimeSpan result;
28895
28896 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 result = wxTimeSpan::Week();
28900 wxPyEndAllowThreads(__tstate);
28901 if (PyErr_Occurred()) SWIG_fail;
28902 }
28903 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28911 PyObject *resultobj = 0;
28912 long arg1 = (long) 0 ;
28913 long arg2 = (long) 0 ;
28914 long arg3 = (long) 0 ;
28915 long arg4 = (long) 0 ;
28916 wxTimeSpan *result = 0 ;
28917 long val1 ;
28918 int ecode1 = 0 ;
28919 long val2 ;
28920 int ecode2 = 0 ;
28921 long val3 ;
28922 int ecode3 = 0 ;
28923 long val4 ;
28924 int ecode4 = 0 ;
28925 PyObject * obj0 = 0 ;
28926 PyObject * obj1 = 0 ;
28927 PyObject * obj2 = 0 ;
28928 PyObject * obj3 = 0 ;
28929 char * kwnames[] = {
28930 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28931 };
28932
28933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28934 if (obj0) {
28935 ecode1 = SWIG_AsVal_long(obj0, &val1);
28936 if (!SWIG_IsOK(ecode1)) {
28937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28938 }
28939 arg1 = static_cast< long >(val1);
28940 }
28941 if (obj1) {
28942 ecode2 = SWIG_AsVal_long(obj1, &val2);
28943 if (!SWIG_IsOK(ecode2)) {
28944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28945 }
28946 arg2 = static_cast< long >(val2);
28947 }
28948 if (obj2) {
28949 ecode3 = SWIG_AsVal_long(obj2, &val3);
28950 if (!SWIG_IsOK(ecode3)) {
28951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28952 }
28953 arg3 = static_cast< long >(val3);
28954 }
28955 if (obj3) {
28956 ecode4 = SWIG_AsVal_long(obj3, &val4);
28957 if (!SWIG_IsOK(ecode4)) {
28958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28959 }
28960 arg4 = static_cast< long >(val4);
28961 }
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28976 PyObject *resultobj = 0;
28977 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28978 void *argp1 = 0 ;
28979 int res1 = 0 ;
28980 PyObject *swig_obj[1] ;
28981
28982 if (!args) SWIG_fail;
28983 swig_obj[0] = args;
28984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28985 if (!SWIG_IsOK(res1)) {
28986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28987 }
28988 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28989 {
28990 PyThreadState* __tstate = wxPyBeginAllowThreads();
28991 delete arg1;
28992
28993 wxPyEndAllowThreads(__tstate);
28994 if (PyErr_Occurred()) SWIG_fail;
28995 }
28996 resultobj = SWIG_Py_Void();
28997 return resultobj;
28998 fail:
28999 return NULL;
29000 }
29001
29002
29003 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29004 PyObject *resultobj = 0;
29005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29006 wxTimeSpan *arg2 = 0 ;
29007 wxTimeSpan *result = 0 ;
29008 void *argp1 = 0 ;
29009 int res1 = 0 ;
29010 void *argp2 = 0 ;
29011 int res2 = 0 ;
29012 PyObject * obj0 = 0 ;
29013 PyObject * obj1 = 0 ;
29014 char * kwnames[] = {
29015 (char *) "self",(char *) "diff", NULL
29016 };
29017
29018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29020 if (!SWIG_IsOK(res1)) {
29021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29022 }
29023 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29025 if (!SWIG_IsOK(res2)) {
29026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29027 }
29028 if (!argp2) {
29029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29030 }
29031 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 {
29035 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29036 result = (wxTimeSpan *) &_result_ref;
29037 }
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29042 return resultobj;
29043 fail:
29044 return NULL;
29045 }
29046
29047
29048 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29049 PyObject *resultobj = 0;
29050 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29051 wxTimeSpan *arg2 = 0 ;
29052 wxTimeSpan *result = 0 ;
29053 void *argp1 = 0 ;
29054 int res1 = 0 ;
29055 void *argp2 = 0 ;
29056 int res2 = 0 ;
29057 PyObject * obj0 = 0 ;
29058 PyObject * obj1 = 0 ;
29059 char * kwnames[] = {
29060 (char *) "self",(char *) "diff", NULL
29061 };
29062
29063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29065 if (!SWIG_IsOK(res1)) {
29066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29067 }
29068 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29069 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29070 if (!SWIG_IsOK(res2)) {
29071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29072 }
29073 if (!argp2) {
29074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29075 }
29076 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29077 {
29078 PyThreadState* __tstate = wxPyBeginAllowThreads();
29079 {
29080 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29081 result = (wxTimeSpan *) &_result_ref;
29082 }
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29094 PyObject *resultobj = 0;
29095 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29096 int arg2 ;
29097 wxTimeSpan *result = 0 ;
29098 void *argp1 = 0 ;
29099 int res1 = 0 ;
29100 int val2 ;
29101 int ecode2 = 0 ;
29102 PyObject * obj0 = 0 ;
29103 PyObject * obj1 = 0 ;
29104 char * kwnames[] = {
29105 (char *) "self",(char *) "n", NULL
29106 };
29107
29108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29110 if (!SWIG_IsOK(res1)) {
29111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29112 }
29113 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29114 ecode2 = SWIG_AsVal_int(obj1, &val2);
29115 if (!SWIG_IsOK(ecode2)) {
29116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29117 }
29118 arg2 = static_cast< int >(val2);
29119 {
29120 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 {
29122 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29123 result = (wxTimeSpan *) &_result_ref;
29124 }
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29136 PyObject *resultobj = 0;
29137 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29138 wxTimeSpan *result = 0 ;
29139 void *argp1 = 0 ;
29140 int res1 = 0 ;
29141 PyObject *swig_obj[1] ;
29142
29143 if (!args) SWIG_fail;
29144 swig_obj[0] = args;
29145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29146 if (!SWIG_IsOK(res1)) {
29147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29148 }
29149 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 {
29153 wxTimeSpan &_result_ref = (arg1)->Neg();
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, 0 | 0 );
29160 return resultobj;
29161 fail:
29162 return NULL;
29163 }
29164
29165
29166 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29167 PyObject *resultobj = 0;
29168 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29169 wxTimeSpan result;
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_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29179 }
29180 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 result = ((wxTimeSpan const *)arg1)->Abs();
29184 wxPyEndAllowThreads(__tstate);
29185 if (PyErr_Occurred()) SWIG_fail;
29186 }
29187 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29188 return resultobj;
29189 fail:
29190 return NULL;
29191 }
29192
29193
29194 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29195 PyObject *resultobj = 0;
29196 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29197 wxTimeSpan *arg2 = 0 ;
29198 wxTimeSpan *result = 0 ;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 void *argp2 = 0 ;
29202 int res2 = 0 ;
29203 PyObject * obj0 = 0 ;
29204 PyObject * obj1 = 0 ;
29205 char * kwnames[] = {
29206 (char *) "self",(char *) "diff", NULL
29207 };
29208
29209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29211 if (!SWIG_IsOK(res1)) {
29212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29213 }
29214 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29216 if (!SWIG_IsOK(res2)) {
29217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29218 }
29219 if (!argp2) {
29220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29221 }
29222 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29223 {
29224 PyThreadState* __tstate = wxPyBeginAllowThreads();
29225 {
29226 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29227 result = (wxTimeSpan *) &_result_ref;
29228 }
29229 wxPyEndAllowThreads(__tstate);
29230 if (PyErr_Occurred()) SWIG_fail;
29231 }
29232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29233 return resultobj;
29234 fail:
29235 return NULL;
29236 }
29237
29238
29239 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29240 PyObject *resultobj = 0;
29241 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29242 wxTimeSpan *arg2 = 0 ;
29243 wxTimeSpan *result = 0 ;
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 *) "diff", NULL
29252 };
29253
29254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29256 if (!SWIG_IsOK(res1)) {
29257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', 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___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29263 }
29264 if (!argp2) {
29265 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29266 }
29267 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29268 {
29269 PyThreadState* __tstate = wxPyBeginAllowThreads();
29270 {
29271 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29272 result = (wxTimeSpan *) &_result_ref;
29273 }
29274 wxPyEndAllowThreads(__tstate);
29275 if (PyErr_Occurred()) SWIG_fail;
29276 }
29277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29278 return resultobj;
29279 fail:
29280 return NULL;
29281 }
29282
29283
29284 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29285 PyObject *resultobj = 0;
29286 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29287 int arg2 ;
29288 wxTimeSpan *result = 0 ;
29289 void *argp1 = 0 ;
29290 int res1 = 0 ;
29291 int val2 ;
29292 int ecode2 = 0 ;
29293 PyObject * obj0 = 0 ;
29294 PyObject * obj1 = 0 ;
29295 char * kwnames[] = {
29296 (char *) "self",(char *) "n", NULL
29297 };
29298
29299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29301 if (!SWIG_IsOK(res1)) {
29302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29303 }
29304 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29305 ecode2 = SWIG_AsVal_int(obj1, &val2);
29306 if (!SWIG_IsOK(ecode2)) {
29307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29308 }
29309 arg2 = static_cast< int >(val2);
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 {
29313 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29314 result = (wxTimeSpan *) &_result_ref;
29315 }
29316 wxPyEndAllowThreads(__tstate);
29317 if (PyErr_Occurred()) SWIG_fail;
29318 }
29319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29320 return resultobj;
29321 fail:
29322 return NULL;
29323 }
29324
29325
29326 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29327 PyObject *resultobj = 0;
29328 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29329 wxTimeSpan *result = 0 ;
29330 void *argp1 = 0 ;
29331 int res1 = 0 ;
29332 PyObject *swig_obj[1] ;
29333
29334 if (!args) SWIG_fail;
29335 swig_obj[0] = args;
29336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29337 if (!SWIG_IsOK(res1)) {
29338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29339 }
29340 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 {
29344 wxTimeSpan &_result_ref = (arg1)->operator -();
29345 result = (wxTimeSpan *) &_result_ref;
29346 }
29347 wxPyEndAllowThreads(__tstate);
29348 if (PyErr_Occurred()) SWIG_fail;
29349 }
29350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29351 return resultobj;
29352 fail:
29353 return NULL;
29354 }
29355
29356
29357 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29358 PyObject *resultobj = 0;
29359 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29360 wxTimeSpan *arg2 = 0 ;
29361 wxTimeSpan result;
29362 void *argp1 = 0 ;
29363 int res1 = 0 ;
29364 void *argp2 = 0 ;
29365 int res2 = 0 ;
29366 PyObject * obj0 = 0 ;
29367 PyObject * obj1 = 0 ;
29368 char * kwnames[] = {
29369 (char *) "self",(char *) "other", NULL
29370 };
29371
29372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29374 if (!SWIG_IsOK(res1)) {
29375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29376 }
29377 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29378 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29379 if (!SWIG_IsOK(res2)) {
29380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29381 }
29382 if (!argp2) {
29383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29384 }
29385 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29386 {
29387 PyThreadState* __tstate = wxPyBeginAllowThreads();
29388 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29389 wxPyEndAllowThreads(__tstate);
29390 if (PyErr_Occurred()) SWIG_fail;
29391 }
29392 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29393 return resultobj;
29394 fail:
29395 return NULL;
29396 }
29397
29398
29399 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29400 PyObject *resultobj = 0;
29401 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29402 wxTimeSpan *arg2 = 0 ;
29403 wxTimeSpan result;
29404 void *argp1 = 0 ;
29405 int res1 = 0 ;
29406 void *argp2 = 0 ;
29407 int res2 = 0 ;
29408 PyObject * obj0 = 0 ;
29409 PyObject * obj1 = 0 ;
29410 char * kwnames[] = {
29411 (char *) "self",(char *) "other", NULL
29412 };
29413
29414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29416 if (!SWIG_IsOK(res1)) {
29417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29418 }
29419 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29420 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29421 if (!SWIG_IsOK(res2)) {
29422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29423 }
29424 if (!argp2) {
29425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29426 }
29427 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29428 {
29429 PyThreadState* __tstate = wxPyBeginAllowThreads();
29430 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29431 wxPyEndAllowThreads(__tstate);
29432 if (PyErr_Occurred()) SWIG_fail;
29433 }
29434 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29442 PyObject *resultobj = 0;
29443 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29444 int arg2 ;
29445 wxTimeSpan result;
29446 void *argp1 = 0 ;
29447 int res1 = 0 ;
29448 int val2 ;
29449 int ecode2 = 0 ;
29450 PyObject * obj0 = 0 ;
29451 PyObject * obj1 = 0 ;
29452 char * kwnames[] = {
29453 (char *) "self",(char *) "n", NULL
29454 };
29455
29456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",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___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29460 }
29461 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29462 ecode2 = SWIG_AsVal_int(obj1, &val2);
29463 if (!SWIG_IsOK(ecode2)) {
29464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29465 }
29466 arg2 = static_cast< int >(val2);
29467 {
29468 PyThreadState* __tstate = wxPyBeginAllowThreads();
29469 result = wxTimeSpan___mul__(arg1,arg2);
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29474 return resultobj;
29475 fail:
29476 return NULL;
29477 }
29478
29479
29480 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29481 PyObject *resultobj = 0;
29482 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29483 int arg2 ;
29484 wxTimeSpan result;
29485 void *argp1 = 0 ;
29486 int res1 = 0 ;
29487 int val2 ;
29488 int ecode2 = 0 ;
29489 PyObject * obj0 = 0 ;
29490 PyObject * obj1 = 0 ;
29491 char * kwnames[] = {
29492 (char *) "self",(char *) "n", NULL
29493 };
29494
29495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29497 if (!SWIG_IsOK(res1)) {
29498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29499 }
29500 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29501 ecode2 = SWIG_AsVal_int(obj1, &val2);
29502 if (!SWIG_IsOK(ecode2)) {
29503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29504 }
29505 arg2 = static_cast< int >(val2);
29506 {
29507 PyThreadState* __tstate = wxPyBeginAllowThreads();
29508 result = wxTimeSpan___rmul__(arg1,arg2);
29509 wxPyEndAllowThreads(__tstate);
29510 if (PyErr_Occurred()) SWIG_fail;
29511 }
29512 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29513 return resultobj;
29514 fail:
29515 return NULL;
29516 }
29517
29518
29519 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29520 PyObject *resultobj = 0;
29521 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29522 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29523 bool result;
29524 void *argp1 = 0 ;
29525 int res1 = 0 ;
29526 void *argp2 = 0 ;
29527 int res2 = 0 ;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 char * kwnames[] = {
29531 (char *) "self",(char *) "other", NULL
29532 };
29533
29534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29536 if (!SWIG_IsOK(res1)) {
29537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29538 }
29539 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29541 if (!SWIG_IsOK(res2)) {
29542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29543 }
29544 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 {
29552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29553 }
29554 return resultobj;
29555 fail:
29556 return NULL;
29557 }
29558
29559
29560 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29561 PyObject *resultobj = 0;
29562 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29563 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29564 bool result;
29565 void *argp1 = 0 ;
29566 int res1 = 0 ;
29567 void *argp2 = 0 ;
29568 int res2 = 0 ;
29569 PyObject * obj0 = 0 ;
29570 PyObject * obj1 = 0 ;
29571 char * kwnames[] = {
29572 (char *) "self",(char *) "other", NULL
29573 };
29574
29575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29577 if (!SWIG_IsOK(res1)) {
29578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29579 }
29580 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29582 if (!SWIG_IsOK(res2)) {
29583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29584 }
29585 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 {
29593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29594 }
29595 return resultobj;
29596 fail:
29597 return NULL;
29598 }
29599
29600
29601 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29602 PyObject *resultobj = 0;
29603 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29604 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29605 bool result;
29606 void *argp1 = 0 ;
29607 int res1 = 0 ;
29608 void *argp2 = 0 ;
29609 int res2 = 0 ;
29610 PyObject * obj0 = 0 ;
29611 PyObject * obj1 = 0 ;
29612 char * kwnames[] = {
29613 (char *) "self",(char *) "other", NULL
29614 };
29615
29616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29618 if (!SWIG_IsOK(res1)) {
29619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29620 }
29621 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29623 if (!SWIG_IsOK(res2)) {
29624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29625 }
29626 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29627 {
29628 PyThreadState* __tstate = wxPyBeginAllowThreads();
29629 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29630 wxPyEndAllowThreads(__tstate);
29631 if (PyErr_Occurred()) SWIG_fail;
29632 }
29633 {
29634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29635 }
29636 return resultobj;
29637 fail:
29638 return NULL;
29639 }
29640
29641
29642 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29643 PyObject *resultobj = 0;
29644 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29645 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29646 bool result;
29647 void *argp1 = 0 ;
29648 int res1 = 0 ;
29649 void *argp2 = 0 ;
29650 int res2 = 0 ;
29651 PyObject * obj0 = 0 ;
29652 PyObject * obj1 = 0 ;
29653 char * kwnames[] = {
29654 (char *) "self",(char *) "other", NULL
29655 };
29656
29657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29659 if (!SWIG_IsOK(res1)) {
29660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29661 }
29662 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29663 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29664 if (!SWIG_IsOK(res2)) {
29665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29666 }
29667 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29668 {
29669 PyThreadState* __tstate = wxPyBeginAllowThreads();
29670 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29671 wxPyEndAllowThreads(__tstate);
29672 if (PyErr_Occurred()) SWIG_fail;
29673 }
29674 {
29675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29676 }
29677 return resultobj;
29678 fail:
29679 return NULL;
29680 }
29681
29682
29683 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29684 PyObject *resultobj = 0;
29685 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29686 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29687 bool result;
29688 void *argp1 = 0 ;
29689 int res1 = 0 ;
29690 void *argp2 = 0 ;
29691 int res2 = 0 ;
29692 PyObject * obj0 = 0 ;
29693 PyObject * obj1 = 0 ;
29694 char * kwnames[] = {
29695 (char *) "self",(char *) "other", NULL
29696 };
29697
29698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29700 if (!SWIG_IsOK(res1)) {
29701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29702 }
29703 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29705 if (!SWIG_IsOK(res2)) {
29706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29707 }
29708 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29712 wxPyEndAllowThreads(__tstate);
29713 if (PyErr_Occurred()) SWIG_fail;
29714 }
29715 {
29716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29717 }
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj = 0;
29726 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29727 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29728 bool result;
29729 void *argp1 = 0 ;
29730 int res1 = 0 ;
29731 void *argp2 = 0 ;
29732 int res2 = 0 ;
29733 PyObject * obj0 = 0 ;
29734 PyObject * obj1 = 0 ;
29735 char * kwnames[] = {
29736 (char *) "self",(char *) "other", NULL
29737 };
29738
29739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29741 if (!SWIG_IsOK(res1)) {
29742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29743 }
29744 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29746 if (!SWIG_IsOK(res2)) {
29747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29748 }
29749 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 {
29757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29758 }
29759 return resultobj;
29760 fail:
29761 return NULL;
29762 }
29763
29764
29765 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29766 PyObject *resultobj = 0;
29767 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29768 bool result;
29769 void *argp1 = 0 ;
29770 int res1 = 0 ;
29771 PyObject *swig_obj[1] ;
29772
29773 if (!args) SWIG_fail;
29774 swig_obj[0] = args;
29775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29776 if (!SWIG_IsOK(res1)) {
29777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29778 }
29779 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29780 {
29781 PyThreadState* __tstate = wxPyBeginAllowThreads();
29782 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 {
29787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29788 }
29789 return resultobj;
29790 fail:
29791 return NULL;
29792 }
29793
29794
29795 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29796 PyObject *resultobj = 0;
29797 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29798 bool result;
29799 void *argp1 = 0 ;
29800 int res1 = 0 ;
29801 PyObject *swig_obj[1] ;
29802
29803 if (!args) SWIG_fail;
29804 swig_obj[0] = args;
29805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29806 if (!SWIG_IsOK(res1)) {
29807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29808 }
29809 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29810 {
29811 PyThreadState* __tstate = wxPyBeginAllowThreads();
29812 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29813 wxPyEndAllowThreads(__tstate);
29814 if (PyErr_Occurred()) SWIG_fail;
29815 }
29816 {
29817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29818 }
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29826 PyObject *resultobj = 0;
29827 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29828 bool result;
29829 void *argp1 = 0 ;
29830 int res1 = 0 ;
29831 PyObject *swig_obj[1] ;
29832
29833 if (!args) SWIG_fail;
29834 swig_obj[0] = args;
29835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29836 if (!SWIG_IsOK(res1)) {
29837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29838 }
29839 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29840 {
29841 PyThreadState* __tstate = wxPyBeginAllowThreads();
29842 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29843 wxPyEndAllowThreads(__tstate);
29844 if (PyErr_Occurred()) SWIG_fail;
29845 }
29846 {
29847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29848 }
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29856 PyObject *resultobj = 0;
29857 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29858 wxTimeSpan *arg2 = 0 ;
29859 bool result;
29860 void *argp1 = 0 ;
29861 int res1 = 0 ;
29862 void *argp2 = 0 ;
29863 int res2 = 0 ;
29864 PyObject * obj0 = 0 ;
29865 PyObject * obj1 = 0 ;
29866 char * kwnames[] = {
29867 (char *) "self",(char *) "ts", NULL
29868 };
29869
29870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29872 if (!SWIG_IsOK(res1)) {
29873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29874 }
29875 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29876 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29877 if (!SWIG_IsOK(res2)) {
29878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29879 }
29880 if (!argp2) {
29881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29882 }
29883 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 {
29891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29892 }
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29900 PyObject *resultobj = 0;
29901 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29902 wxTimeSpan *arg2 = 0 ;
29903 bool result;
29904 void *argp1 = 0 ;
29905 int res1 = 0 ;
29906 void *argp2 = 0 ;
29907 int res2 = 0 ;
29908 PyObject * obj0 = 0 ;
29909 PyObject * obj1 = 0 ;
29910 char * kwnames[] = {
29911 (char *) "self",(char *) "ts", NULL
29912 };
29913
29914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29916 if (!SWIG_IsOK(res1)) {
29917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29918 }
29919 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29920 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29921 if (!SWIG_IsOK(res2)) {
29922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29923 }
29924 if (!argp2) {
29925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29926 }
29927 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29928 {
29929 PyThreadState* __tstate = wxPyBeginAllowThreads();
29930 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 {
29935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29936 }
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj = 0;
29945 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29946 wxTimeSpan *arg2 = 0 ;
29947 bool result;
29948 void *argp1 = 0 ;
29949 int res1 = 0 ;
29950 void *argp2 = 0 ;
29951 int res2 = 0 ;
29952 PyObject * obj0 = 0 ;
29953 PyObject * obj1 = 0 ;
29954 char * kwnames[] = {
29955 (char *) "self",(char *) "t", NULL
29956 };
29957
29958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29960 if (!SWIG_IsOK(res1)) {
29961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29962 }
29963 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29965 if (!SWIG_IsOK(res2)) {
29966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29967 }
29968 if (!argp2) {
29969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29970 }
29971 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29972 {
29973 PyThreadState* __tstate = wxPyBeginAllowThreads();
29974 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 {
29979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29988 PyObject *resultobj = 0;
29989 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29990 int result;
29991 void *argp1 = 0 ;
29992 int res1 = 0 ;
29993 PyObject *swig_obj[1] ;
29994
29995 if (!args) SWIG_fail;
29996 swig_obj[0] = args;
29997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29998 if (!SWIG_IsOK(res1)) {
29999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30000 }
30001 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30005 wxPyEndAllowThreads(__tstate);
30006 if (PyErr_Occurred()) SWIG_fail;
30007 }
30008 resultobj = SWIG_From_int(static_cast< int >(result));
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30016 PyObject *resultobj = 0;
30017 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30018 int result;
30019 void *argp1 = 0 ;
30020 int res1 = 0 ;
30021 PyObject *swig_obj[1] ;
30022
30023 if (!args) SWIG_fail;
30024 swig_obj[0] = args;
30025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30026 if (!SWIG_IsOK(res1)) {
30027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30028 }
30029 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 resultobj = SWIG_From_int(static_cast< int >(result));
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30044 PyObject *resultobj = 0;
30045 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30046 int result;
30047 void *argp1 = 0 ;
30048 int res1 = 0 ;
30049 PyObject *swig_obj[1] ;
30050
30051 if (!args) SWIG_fail;
30052 swig_obj[0] = args;
30053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30056 }
30057 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 resultobj = SWIG_From_int(static_cast< int >(result));
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30072 PyObject *resultobj = 0;
30073 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30074 int result;
30075 void *argp1 = 0 ;
30076 int res1 = 0 ;
30077 PyObject *swig_obj[1] ;
30078
30079 if (!args) SWIG_fail;
30080 swig_obj[0] = args;
30081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30082 if (!SWIG_IsOK(res1)) {
30083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30084 }
30085 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_From_int(static_cast< int >(result));
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *resultobj = 0;
30101 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30102 wxLongLong result;
30103 void *argp1 = 0 ;
30104 int res1 = 0 ;
30105 PyObject *swig_obj[1] ;
30106
30107 if (!args) SWIG_fail;
30108 swig_obj[0] = args;
30109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30110 if (!SWIG_IsOK(res1)) {
30111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30112 }
30113 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30114 {
30115 PyThreadState* __tstate = wxPyBeginAllowThreads();
30116 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30117 wxPyEndAllowThreads(__tstate);
30118 if (PyErr_Occurred()) SWIG_fail;
30119 }
30120 {
30121 PyObject *hi, *lo, *shifter, *shifted;
30122 hi = PyLong_FromLong( (&result)->GetHi() );
30123 lo = PyLong_FromLong( (&result)->GetLo() );
30124 shifter = PyLong_FromLong(32);
30125 shifted = PyNumber_Lshift(hi, shifter);
30126 resultobj = PyNumber_Or(shifted, lo);
30127 Py_DECREF(hi);
30128 Py_DECREF(lo);
30129 Py_DECREF(shifter);
30130 Py_DECREF(shifted);
30131 }
30132 return resultobj;
30133 fail:
30134 return NULL;
30135 }
30136
30137
30138 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30139 PyObject *resultobj = 0;
30140 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30141 wxLongLong result;
30142 void *argp1 = 0 ;
30143 int res1 = 0 ;
30144 PyObject *swig_obj[1] ;
30145
30146 if (!args) SWIG_fail;
30147 swig_obj[0] = args;
30148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30149 if (!SWIG_IsOK(res1)) {
30150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30151 }
30152 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30153 {
30154 PyThreadState* __tstate = wxPyBeginAllowThreads();
30155 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30156 wxPyEndAllowThreads(__tstate);
30157 if (PyErr_Occurred()) SWIG_fail;
30158 }
30159 {
30160 PyObject *hi, *lo, *shifter, *shifted;
30161 hi = PyLong_FromLong( (&result)->GetHi() );
30162 lo = PyLong_FromLong( (&result)->GetLo() );
30163 shifter = PyLong_FromLong(32);
30164 shifted = PyNumber_Lshift(hi, shifter);
30165 resultobj = PyNumber_Or(shifted, lo);
30166 Py_DECREF(hi);
30167 Py_DECREF(lo);
30168 Py_DECREF(shifter);
30169 Py_DECREF(shifted);
30170 }
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj = 0;
30179 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30180 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30181 wxString *arg2 = (wxString *) &arg2_defvalue ;
30182 wxString result;
30183 void *argp1 = 0 ;
30184 int res1 = 0 ;
30185 bool temp2 = false ;
30186 PyObject * obj0 = 0 ;
30187 PyObject * obj1 = 0 ;
30188 char * kwnames[] = {
30189 (char *) "self",(char *) "format", NULL
30190 };
30191
30192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30194 if (!SWIG_IsOK(res1)) {
30195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30196 }
30197 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30198 if (obj1) {
30199 {
30200 arg2 = wxString_in_helper(obj1);
30201 if (arg2 == NULL) SWIG_fail;
30202 temp2 = true;
30203 }
30204 }
30205 {
30206 PyThreadState* __tstate = wxPyBeginAllowThreads();
30207 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30208 wxPyEndAllowThreads(__tstate);
30209 if (PyErr_Occurred()) SWIG_fail;
30210 }
30211 {
30212 #if wxUSE_UNICODE
30213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30214 #else
30215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30216 #endif
30217 }
30218 {
30219 if (temp2)
30220 delete arg2;
30221 }
30222 return resultobj;
30223 fail:
30224 {
30225 if (temp2)
30226 delete arg2;
30227 }
30228 return NULL;
30229 }
30230
30231
30232 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30233 PyObject *obj;
30234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30235 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30236 return SWIG_Py_Void();
30237 }
30238
30239 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30240 return SWIG_Python_InitShadowInstance(args);
30241 }
30242
30243 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30244 PyObject *resultobj = 0;
30245 int arg1 = (int) 0 ;
30246 int arg2 = (int) 0 ;
30247 int arg3 = (int) 0 ;
30248 int arg4 = (int) 0 ;
30249 wxDateSpan *result = 0 ;
30250 int val1 ;
30251 int ecode1 = 0 ;
30252 int val2 ;
30253 int ecode2 = 0 ;
30254 int val3 ;
30255 int ecode3 = 0 ;
30256 int val4 ;
30257 int ecode4 = 0 ;
30258 PyObject * obj0 = 0 ;
30259 PyObject * obj1 = 0 ;
30260 PyObject * obj2 = 0 ;
30261 PyObject * obj3 = 0 ;
30262 char * kwnames[] = {
30263 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30264 };
30265
30266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30267 if (obj0) {
30268 ecode1 = SWIG_AsVal_int(obj0, &val1);
30269 if (!SWIG_IsOK(ecode1)) {
30270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30271 }
30272 arg1 = static_cast< int >(val1);
30273 }
30274 if (obj1) {
30275 ecode2 = SWIG_AsVal_int(obj1, &val2);
30276 if (!SWIG_IsOK(ecode2)) {
30277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30278 }
30279 arg2 = static_cast< int >(val2);
30280 }
30281 if (obj2) {
30282 ecode3 = SWIG_AsVal_int(obj2, &val3);
30283 if (!SWIG_IsOK(ecode3)) {
30284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30285 }
30286 arg3 = static_cast< int >(val3);
30287 }
30288 if (obj3) {
30289 ecode4 = SWIG_AsVal_int(obj3, &val4);
30290 if (!SWIG_IsOK(ecode4)) {
30291 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30292 }
30293 arg4 = static_cast< int >(val4);
30294 }
30295 {
30296 PyThreadState* __tstate = wxPyBeginAllowThreads();
30297 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30298 wxPyEndAllowThreads(__tstate);
30299 if (PyErr_Occurred()) SWIG_fail;
30300 }
30301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30302 return resultobj;
30303 fail:
30304 return NULL;
30305 }
30306
30307
30308 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30309 PyObject *resultobj = 0;
30310 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30311 void *argp1 = 0 ;
30312 int res1 = 0 ;
30313 PyObject *swig_obj[1] ;
30314
30315 if (!args) SWIG_fail;
30316 swig_obj[0] = args;
30317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30318 if (!SWIG_IsOK(res1)) {
30319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30320 }
30321 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 delete arg1;
30325
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 resultobj = SWIG_Py_Void();
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30337 PyObject *resultobj = 0;
30338 int arg1 ;
30339 wxDateSpan result;
30340 int val1 ;
30341 int ecode1 = 0 ;
30342 PyObject * obj0 = 0 ;
30343 char * kwnames[] = {
30344 (char *) "days", NULL
30345 };
30346
30347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30348 ecode1 = SWIG_AsVal_int(obj0, &val1);
30349 if (!SWIG_IsOK(ecode1)) {
30350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30351 }
30352 arg1 = static_cast< int >(val1);
30353 {
30354 PyThreadState* __tstate = wxPyBeginAllowThreads();
30355 result = wxDateSpan::Days(arg1);
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30367 PyObject *resultobj = 0;
30368 wxDateSpan result;
30369
30370 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30371 {
30372 PyThreadState* __tstate = wxPyBeginAllowThreads();
30373 result = wxDateSpan::Day();
30374 wxPyEndAllowThreads(__tstate);
30375 if (PyErr_Occurred()) SWIG_fail;
30376 }
30377 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30378 return resultobj;
30379 fail:
30380 return NULL;
30381 }
30382
30383
30384 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30385 PyObject *resultobj = 0;
30386 int arg1 ;
30387 wxDateSpan result;
30388 int val1 ;
30389 int ecode1 = 0 ;
30390 PyObject * obj0 = 0 ;
30391 char * kwnames[] = {
30392 (char *) "weeks", NULL
30393 };
30394
30395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30396 ecode1 = SWIG_AsVal_int(obj0, &val1);
30397 if (!SWIG_IsOK(ecode1)) {
30398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30399 }
30400 arg1 = static_cast< int >(val1);
30401 {
30402 PyThreadState* __tstate = wxPyBeginAllowThreads();
30403 result = wxDateSpan::Weeks(arg1);
30404 wxPyEndAllowThreads(__tstate);
30405 if (PyErr_Occurred()) SWIG_fail;
30406 }
30407 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30408 return resultobj;
30409 fail:
30410 return NULL;
30411 }
30412
30413
30414 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30415 PyObject *resultobj = 0;
30416 wxDateSpan result;
30417
30418 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30419 {
30420 PyThreadState* __tstate = wxPyBeginAllowThreads();
30421 result = wxDateSpan::Week();
30422 wxPyEndAllowThreads(__tstate);
30423 if (PyErr_Occurred()) SWIG_fail;
30424 }
30425 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj = 0;
30434 int arg1 ;
30435 wxDateSpan result;
30436 int val1 ;
30437 int ecode1 = 0 ;
30438 PyObject * obj0 = 0 ;
30439 char * kwnames[] = {
30440 (char *) "mon", NULL
30441 };
30442
30443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30444 ecode1 = SWIG_AsVal_int(obj0, &val1);
30445 if (!SWIG_IsOK(ecode1)) {
30446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30447 }
30448 arg1 = static_cast< int >(val1);
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 result = wxDateSpan::Months(arg1);
30452 wxPyEndAllowThreads(__tstate);
30453 if (PyErr_Occurred()) SWIG_fail;
30454 }
30455 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30463 PyObject *resultobj = 0;
30464 wxDateSpan result;
30465
30466 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30467 {
30468 PyThreadState* __tstate = wxPyBeginAllowThreads();
30469 result = wxDateSpan::Month();
30470 wxPyEndAllowThreads(__tstate);
30471 if (PyErr_Occurred()) SWIG_fail;
30472 }
30473 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30474 return resultobj;
30475 fail:
30476 return NULL;
30477 }
30478
30479
30480 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30481 PyObject *resultobj = 0;
30482 int arg1 ;
30483 wxDateSpan result;
30484 int val1 ;
30485 int ecode1 = 0 ;
30486 PyObject * obj0 = 0 ;
30487 char * kwnames[] = {
30488 (char *) "years", NULL
30489 };
30490
30491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30492 ecode1 = SWIG_AsVal_int(obj0, &val1);
30493 if (!SWIG_IsOK(ecode1)) {
30494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30495 }
30496 arg1 = static_cast< int >(val1);
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 result = wxDateSpan::Years(arg1);
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxDateSpan result;
30513
30514 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30515 {
30516 PyThreadState* __tstate = wxPyBeginAllowThreads();
30517 result = wxDateSpan::Year();
30518 wxPyEndAllowThreads(__tstate);
30519 if (PyErr_Occurred()) SWIG_fail;
30520 }
30521 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30522 return resultobj;
30523 fail:
30524 return NULL;
30525 }
30526
30527
30528 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30529 PyObject *resultobj = 0;
30530 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30531 int arg2 ;
30532 wxDateSpan *result = 0 ;
30533 void *argp1 = 0 ;
30534 int res1 = 0 ;
30535 int val2 ;
30536 int ecode2 = 0 ;
30537 PyObject * obj0 = 0 ;
30538 PyObject * obj1 = 0 ;
30539 char * kwnames[] = {
30540 (char *) "self",(char *) "n", NULL
30541 };
30542
30543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30545 if (!SWIG_IsOK(res1)) {
30546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30547 }
30548 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30549 ecode2 = SWIG_AsVal_int(obj1, &val2);
30550 if (!SWIG_IsOK(ecode2)) {
30551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30552 }
30553 arg2 = static_cast< int >(val2);
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 {
30557 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30558 result = (wxDateSpan *) &_result_ref;
30559 }
30560 wxPyEndAllowThreads(__tstate);
30561 if (PyErr_Occurred()) SWIG_fail;
30562 }
30563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30564 return resultobj;
30565 fail:
30566 return NULL;
30567 }
30568
30569
30570 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30571 PyObject *resultobj = 0;
30572 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30573 int arg2 ;
30574 wxDateSpan *result = 0 ;
30575 void *argp1 = 0 ;
30576 int res1 = 0 ;
30577 int val2 ;
30578 int ecode2 = 0 ;
30579 PyObject * obj0 = 0 ;
30580 PyObject * obj1 = 0 ;
30581 char * kwnames[] = {
30582 (char *) "self",(char *) "n", NULL
30583 };
30584
30585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30587 if (!SWIG_IsOK(res1)) {
30588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30589 }
30590 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30591 ecode2 = SWIG_AsVal_int(obj1, &val2);
30592 if (!SWIG_IsOK(ecode2)) {
30593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30594 }
30595 arg2 = static_cast< int >(val2);
30596 {
30597 PyThreadState* __tstate = wxPyBeginAllowThreads();
30598 {
30599 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30600 result = (wxDateSpan *) &_result_ref;
30601 }
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30606 return resultobj;
30607 fail:
30608 return NULL;
30609 }
30610
30611
30612 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30613 PyObject *resultobj = 0;
30614 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30615 int arg2 ;
30616 wxDateSpan *result = 0 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 int val2 ;
30620 int ecode2 = 0 ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 char * kwnames[] = {
30624 (char *) "self",(char *) "n", NULL
30625 };
30626
30627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30629 if (!SWIG_IsOK(res1)) {
30630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30631 }
30632 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30633 ecode2 = SWIG_AsVal_int(obj1, &val2);
30634 if (!SWIG_IsOK(ecode2)) {
30635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30636 }
30637 arg2 = static_cast< int >(val2);
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 {
30641 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30642 result = (wxDateSpan *) &_result_ref;
30643 }
30644 wxPyEndAllowThreads(__tstate);
30645 if (PyErr_Occurred()) SWIG_fail;
30646 }
30647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30648 return resultobj;
30649 fail:
30650 return NULL;
30651 }
30652
30653
30654 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30655 PyObject *resultobj = 0;
30656 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30657 int arg2 ;
30658 wxDateSpan *result = 0 ;
30659 void *argp1 = 0 ;
30660 int res1 = 0 ;
30661 int val2 ;
30662 int ecode2 = 0 ;
30663 PyObject * obj0 = 0 ;
30664 PyObject * obj1 = 0 ;
30665 char * kwnames[] = {
30666 (char *) "self",(char *) "n", NULL
30667 };
30668
30669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30673 }
30674 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30675 ecode2 = SWIG_AsVal_int(obj1, &val2);
30676 if (!SWIG_IsOK(ecode2)) {
30677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30678 }
30679 arg2 = static_cast< int >(val2);
30680 {
30681 PyThreadState* __tstate = wxPyBeginAllowThreads();
30682 {
30683 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30684 result = (wxDateSpan *) &_result_ref;
30685 }
30686 wxPyEndAllowThreads(__tstate);
30687 if (PyErr_Occurred()) SWIG_fail;
30688 }
30689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30690 return resultobj;
30691 fail:
30692 return NULL;
30693 }
30694
30695
30696 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30697 PyObject *resultobj = 0;
30698 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30699 int result;
30700 void *argp1 = 0 ;
30701 int res1 = 0 ;
30702 PyObject *swig_obj[1] ;
30703
30704 if (!args) SWIG_fail;
30705 swig_obj[0] = args;
30706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30707 if (!SWIG_IsOK(res1)) {
30708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30709 }
30710 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 result = (int)((wxDateSpan const *)arg1)->GetYears();
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_From_int(static_cast< int >(result));
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30725 PyObject *resultobj = 0;
30726 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30727 int result;
30728 void *argp1 = 0 ;
30729 int res1 = 0 ;
30730 PyObject *swig_obj[1] ;
30731
30732 if (!args) SWIG_fail;
30733 swig_obj[0] = args;
30734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30735 if (!SWIG_IsOK(res1)) {
30736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30737 }
30738 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30742 wxPyEndAllowThreads(__tstate);
30743 if (PyErr_Occurred()) SWIG_fail;
30744 }
30745 resultobj = SWIG_From_int(static_cast< int >(result));
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30753 PyObject *resultobj = 0;
30754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30755 int result;
30756 void *argp1 = 0 ;
30757 int res1 = 0 ;
30758 PyObject *swig_obj[1] ;
30759
30760 if (!args) SWIG_fail;
30761 swig_obj[0] = args;
30762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30763 if (!SWIG_IsOK(res1)) {
30764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30765 }
30766 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_From_int(static_cast< int >(result));
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30781 PyObject *resultobj = 0;
30782 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30783 int result;
30784 void *argp1 = 0 ;
30785 int res1 = 0 ;
30786 PyObject *swig_obj[1] ;
30787
30788 if (!args) SWIG_fail;
30789 swig_obj[0] = args;
30790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30791 if (!SWIG_IsOK(res1)) {
30792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30793 }
30794 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30795 {
30796 PyThreadState* __tstate = wxPyBeginAllowThreads();
30797 result = (int)((wxDateSpan const *)arg1)->GetDays();
30798 wxPyEndAllowThreads(__tstate);
30799 if (PyErr_Occurred()) SWIG_fail;
30800 }
30801 resultobj = SWIG_From_int(static_cast< int >(result));
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30809 PyObject *resultobj = 0;
30810 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30811 int result;
30812 void *argp1 = 0 ;
30813 int res1 = 0 ;
30814 PyObject *swig_obj[1] ;
30815
30816 if (!args) SWIG_fail;
30817 swig_obj[0] = args;
30818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30819 if (!SWIG_IsOK(res1)) {
30820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30821 }
30822 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 resultobj = SWIG_From_int(static_cast< int >(result));
30830 return resultobj;
30831 fail:
30832 return NULL;
30833 }
30834
30835
30836 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30837 PyObject *resultobj = 0;
30838 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30839 wxDateSpan *arg2 = 0 ;
30840 wxDateSpan *result = 0 ;
30841 void *argp1 = 0 ;
30842 int res1 = 0 ;
30843 void *argp2 = 0 ;
30844 int res2 = 0 ;
30845 PyObject * obj0 = 0 ;
30846 PyObject * obj1 = 0 ;
30847 char * kwnames[] = {
30848 (char *) "self",(char *) "other", NULL
30849 };
30850
30851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30853 if (!SWIG_IsOK(res1)) {
30854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30855 }
30856 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30858 if (!SWIG_IsOK(res2)) {
30859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30860 }
30861 if (!argp2) {
30862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30863 }
30864 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 {
30868 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30869 result = (wxDateSpan *) &_result_ref;
30870 }
30871 wxPyEndAllowThreads(__tstate);
30872 if (PyErr_Occurred()) SWIG_fail;
30873 }
30874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30875 return resultobj;
30876 fail:
30877 return NULL;
30878 }
30879
30880
30881 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30882 PyObject *resultobj = 0;
30883 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30884 wxDateSpan *arg2 = 0 ;
30885 wxDateSpan *result = 0 ;
30886 void *argp1 = 0 ;
30887 int res1 = 0 ;
30888 void *argp2 = 0 ;
30889 int res2 = 0 ;
30890 PyObject * obj0 = 0 ;
30891 PyObject * obj1 = 0 ;
30892 char * kwnames[] = {
30893 (char *) "self",(char *) "other", NULL
30894 };
30895
30896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30898 if (!SWIG_IsOK(res1)) {
30899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30900 }
30901 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30902 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30903 if (!SWIG_IsOK(res2)) {
30904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30905 }
30906 if (!argp2) {
30907 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30908 }
30909 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 {
30913 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30914 result = (wxDateSpan *) &_result_ref;
30915 }
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30920 return resultobj;
30921 fail:
30922 return NULL;
30923 }
30924
30925
30926 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30927 PyObject *resultobj = 0;
30928 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30929 wxDateSpan *result = 0 ;
30930 void *argp1 = 0 ;
30931 int res1 = 0 ;
30932 PyObject *swig_obj[1] ;
30933
30934 if (!args) SWIG_fail;
30935 swig_obj[0] = args;
30936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30937 if (!SWIG_IsOK(res1)) {
30938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30939 }
30940 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30941 {
30942 PyThreadState* __tstate = wxPyBeginAllowThreads();
30943 {
30944 wxDateSpan &_result_ref = (arg1)->Neg();
30945 result = (wxDateSpan *) &_result_ref;
30946 }
30947 wxPyEndAllowThreads(__tstate);
30948 if (PyErr_Occurred()) SWIG_fail;
30949 }
30950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30951 return resultobj;
30952 fail:
30953 return NULL;
30954 }
30955
30956
30957 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30958 PyObject *resultobj = 0;
30959 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30960 int arg2 ;
30961 wxDateSpan *result = 0 ;
30962 void *argp1 = 0 ;
30963 int res1 = 0 ;
30964 int val2 ;
30965 int ecode2 = 0 ;
30966 PyObject * obj0 = 0 ;
30967 PyObject * obj1 = 0 ;
30968 char * kwnames[] = {
30969 (char *) "self",(char *) "factor", NULL
30970 };
30971
30972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30974 if (!SWIG_IsOK(res1)) {
30975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30976 }
30977 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30978 ecode2 = SWIG_AsVal_int(obj1, &val2);
30979 if (!SWIG_IsOK(ecode2)) {
30980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30981 }
30982 arg2 = static_cast< int >(val2);
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 {
30986 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30987 result = (wxDateSpan *) &_result_ref;
30988 }
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30993 return resultobj;
30994 fail:
30995 return NULL;
30996 }
30997
30998
30999 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31000 PyObject *resultobj = 0;
31001 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31002 wxDateSpan *arg2 = 0 ;
31003 wxDateSpan *result = 0 ;
31004 void *argp1 = 0 ;
31005 int res1 = 0 ;
31006 void *argp2 = 0 ;
31007 int res2 = 0 ;
31008 PyObject * obj0 = 0 ;
31009 PyObject * obj1 = 0 ;
31010 char * kwnames[] = {
31011 (char *) "self",(char *) "other", NULL
31012 };
31013
31014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31018 }
31019 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31021 if (!SWIG_IsOK(res2)) {
31022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31023 }
31024 if (!argp2) {
31025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31026 }
31027 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31028 {
31029 PyThreadState* __tstate = wxPyBeginAllowThreads();
31030 {
31031 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31032 result = (wxDateSpan *) &_result_ref;
31033 }
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31038 return resultobj;
31039 fail:
31040 return NULL;
31041 }
31042
31043
31044 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31045 PyObject *resultobj = 0;
31046 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31047 wxDateSpan *arg2 = 0 ;
31048 wxDateSpan *result = 0 ;
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___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31061 if (!SWIG_IsOK(res1)) {
31062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', 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___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31068 }
31069 if (!argp2) {
31070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31071 }
31072 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31073 {
31074 PyThreadState* __tstate = wxPyBeginAllowThreads();
31075 {
31076 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31077 result = (wxDateSpan *) &_result_ref;
31078 }
31079 wxPyEndAllowThreads(__tstate);
31080 if (PyErr_Occurred()) SWIG_fail;
31081 }
31082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31090 PyObject *resultobj = 0;
31091 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31092 wxDateSpan *result = 0 ;
31093 void *argp1 = 0 ;
31094 int res1 = 0 ;
31095 PyObject *swig_obj[1] ;
31096
31097 if (!args) SWIG_fail;
31098 swig_obj[0] = args;
31099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31100 if (!SWIG_IsOK(res1)) {
31101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31102 }
31103 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 {
31107 wxDateSpan &_result_ref = (arg1)->operator -();
31108 result = (wxDateSpan *) &_result_ref;
31109 }
31110 wxPyEndAllowThreads(__tstate);
31111 if (PyErr_Occurred()) SWIG_fail;
31112 }
31113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31114 return resultobj;
31115 fail:
31116 return NULL;
31117 }
31118
31119
31120 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31121 PyObject *resultobj = 0;
31122 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31123 int arg2 ;
31124 wxDateSpan *result = 0 ;
31125 void *argp1 = 0 ;
31126 int res1 = 0 ;
31127 int val2 ;
31128 int ecode2 = 0 ;
31129 PyObject * obj0 = 0 ;
31130 PyObject * obj1 = 0 ;
31131 char * kwnames[] = {
31132 (char *) "self",(char *) "factor", NULL
31133 };
31134
31135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31137 if (!SWIG_IsOK(res1)) {
31138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31139 }
31140 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31141 ecode2 = SWIG_AsVal_int(obj1, &val2);
31142 if (!SWIG_IsOK(ecode2)) {
31143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31144 }
31145 arg2 = static_cast< int >(val2);
31146 {
31147 PyThreadState* __tstate = wxPyBeginAllowThreads();
31148 {
31149 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31150 result = (wxDateSpan *) &_result_ref;
31151 }
31152 wxPyEndAllowThreads(__tstate);
31153 if (PyErr_Occurred()) SWIG_fail;
31154 }
31155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31156 return resultobj;
31157 fail:
31158 return NULL;
31159 }
31160
31161
31162 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31163 PyObject *resultobj = 0;
31164 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31165 wxDateSpan *arg2 = 0 ;
31166 wxDateSpan result;
31167 void *argp1 = 0 ;
31168 int res1 = 0 ;
31169 void *argp2 = 0 ;
31170 int res2 = 0 ;
31171 PyObject * obj0 = 0 ;
31172 PyObject * obj1 = 0 ;
31173 char * kwnames[] = {
31174 (char *) "self",(char *) "other", NULL
31175 };
31176
31177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31179 if (!SWIG_IsOK(res1)) {
31180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31181 }
31182 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31183 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31184 if (!SWIG_IsOK(res2)) {
31185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31186 }
31187 if (!argp2) {
31188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31189 }
31190 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31191 {
31192 PyThreadState* __tstate = wxPyBeginAllowThreads();
31193 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31194 wxPyEndAllowThreads(__tstate);
31195 if (PyErr_Occurred()) SWIG_fail;
31196 }
31197 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31198 return resultobj;
31199 fail:
31200 return NULL;
31201 }
31202
31203
31204 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31205 PyObject *resultobj = 0;
31206 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31207 wxDateSpan *arg2 = 0 ;
31208 wxDateSpan result;
31209 void *argp1 = 0 ;
31210 int res1 = 0 ;
31211 void *argp2 = 0 ;
31212 int res2 = 0 ;
31213 PyObject * obj0 = 0 ;
31214 PyObject * obj1 = 0 ;
31215 char * kwnames[] = {
31216 (char *) "self",(char *) "other", NULL
31217 };
31218
31219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31221 if (!SWIG_IsOK(res1)) {
31222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31223 }
31224 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31225 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31226 if (!SWIG_IsOK(res2)) {
31227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31228 }
31229 if (!argp2) {
31230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31231 }
31232 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31247 PyObject *resultobj = 0;
31248 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31249 int arg2 ;
31250 wxDateSpan result;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 int val2 ;
31254 int ecode2 = 0 ;
31255 PyObject * obj0 = 0 ;
31256 PyObject * obj1 = 0 ;
31257 char * kwnames[] = {
31258 (char *) "self",(char *) "n", NULL
31259 };
31260
31261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31263 if (!SWIG_IsOK(res1)) {
31264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31265 }
31266 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31267 ecode2 = SWIG_AsVal_int(obj1, &val2);
31268 if (!SWIG_IsOK(ecode2)) {
31269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31270 }
31271 arg2 = static_cast< int >(val2);
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 result = wxDateSpan___mul__(arg1,arg2);
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj = 0;
31287 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31288 int arg2 ;
31289 wxDateSpan result;
31290 void *argp1 = 0 ;
31291 int res1 = 0 ;
31292 int val2 ;
31293 int ecode2 = 0 ;
31294 PyObject * obj0 = 0 ;
31295 PyObject * obj1 = 0 ;
31296 char * kwnames[] = {
31297 (char *) "self",(char *) "n", NULL
31298 };
31299
31300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31302 if (!SWIG_IsOK(res1)) {
31303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31304 }
31305 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31306 ecode2 = SWIG_AsVal_int(obj1, &val2);
31307 if (!SWIG_IsOK(ecode2)) {
31308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31309 }
31310 arg2 = static_cast< int >(val2);
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 result = wxDateSpan___rmul__(arg1,arg2);
31314 wxPyEndAllowThreads(__tstate);
31315 if (PyErr_Occurred()) SWIG_fail;
31316 }
31317 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31325 PyObject *resultobj = 0;
31326 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31327 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31328 bool result;
31329 void *argp1 = 0 ;
31330 int res1 = 0 ;
31331 void *argp2 = 0 ;
31332 int res2 = 0 ;
31333 PyObject * obj0 = 0 ;
31334 PyObject * obj1 = 0 ;
31335 char * kwnames[] = {
31336 (char *) "self",(char *) "other", NULL
31337 };
31338
31339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31341 if (!SWIG_IsOK(res1)) {
31342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31343 }
31344 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31346 if (!SWIG_IsOK(res2)) {
31347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31348 }
31349 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31353 wxPyEndAllowThreads(__tstate);
31354 if (PyErr_Occurred()) SWIG_fail;
31355 }
31356 {
31357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31358 }
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31366 PyObject *resultobj = 0;
31367 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31368 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31369 bool result;
31370 void *argp1 = 0 ;
31371 int res1 = 0 ;
31372 void *argp2 = 0 ;
31373 int res2 = 0 ;
31374 PyObject * obj0 = 0 ;
31375 PyObject * obj1 = 0 ;
31376 char * kwnames[] = {
31377 (char *) "self",(char *) "other", NULL
31378 };
31379
31380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31382 if (!SWIG_IsOK(res1)) {
31383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31384 }
31385 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31387 if (!SWIG_IsOK(res2)) {
31388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31389 }
31390 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 {
31398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31399 }
31400 return resultobj;
31401 fail:
31402 return NULL;
31403 }
31404
31405
31406 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31407 PyObject *obj;
31408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31409 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31410 return SWIG_Py_Void();
31411 }
31412
31413 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31414 return SWIG_Python_InitShadowInstance(args);
31415 }
31416
31417 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31418 PyObject *resultobj = 0;
31419 long result;
31420
31421 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 result = (long)wxGetLocalTime();
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 resultobj = SWIG_From_long(static_cast< long >(result));
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 PyObject *resultobj = 0;
31437 long result;
31438
31439 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31440 {
31441 PyThreadState* __tstate = wxPyBeginAllowThreads();
31442 result = (long)wxGetUTCTime();
31443 wxPyEndAllowThreads(__tstate);
31444 if (PyErr_Occurred()) SWIG_fail;
31445 }
31446 resultobj = SWIG_From_long(static_cast< long >(result));
31447 return resultobj;
31448 fail:
31449 return NULL;
31450 }
31451
31452
31453 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31454 PyObject *resultobj = 0;
31455 long result;
31456
31457 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 result = (long)wxGetCurrentTime();
31461 wxPyEndAllowThreads(__tstate);
31462 if (PyErr_Occurred()) SWIG_fail;
31463 }
31464 resultobj = SWIG_From_long(static_cast< long >(result));
31465 return resultobj;
31466 fail:
31467 return NULL;
31468 }
31469
31470
31471 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31472 PyObject *resultobj = 0;
31473 wxLongLong result;
31474
31475 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 result = wxGetLocalTimeMillis();
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 {
31483 PyObject *hi, *lo, *shifter, *shifted;
31484 hi = PyLong_FromLong( (&result)->GetHi() );
31485 lo = PyLong_FromLong( (&result)->GetLo() );
31486 shifter = PyLong_FromLong(32);
31487 shifted = PyNumber_Lshift(hi, shifter);
31488 resultobj = PyNumber_Or(shifted, lo);
31489 Py_DECREF(hi);
31490 Py_DECREF(lo);
31491 Py_DECREF(shifter);
31492 Py_DECREF(shifted);
31493 }
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31501 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31502 return 1;
31503 }
31504
31505
31506 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31507 PyObject *pyobj = 0;
31508
31509 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31510 return pyobj;
31511 }
31512
31513
31514 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31515 PyObject *resultobj = 0;
31516 wxDataFormatId arg1 ;
31517 wxDataFormat *result = 0 ;
31518 int val1 ;
31519 int ecode1 = 0 ;
31520 PyObject * obj0 = 0 ;
31521 char * kwnames[] = {
31522 (char *) "type", NULL
31523 };
31524
31525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31526 ecode1 = SWIG_AsVal_int(obj0, &val1);
31527 if (!SWIG_IsOK(ecode1)) {
31528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31529 }
31530 arg1 = static_cast< wxDataFormatId >(val1);
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 result = (wxDataFormat *)new wxDataFormat(arg1);
31534 wxPyEndAllowThreads(__tstate);
31535 if (PyErr_Occurred()) SWIG_fail;
31536 }
31537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31538 return resultobj;
31539 fail:
31540 return NULL;
31541 }
31542
31543
31544 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31545 PyObject *resultobj = 0;
31546 wxString *arg1 = 0 ;
31547 wxDataFormat *result = 0 ;
31548 bool temp1 = false ;
31549 PyObject * obj0 = 0 ;
31550 char * kwnames[] = {
31551 (char *) "format", NULL
31552 };
31553
31554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31555 {
31556 arg1 = wxString_in_helper(obj0);
31557 if (arg1 == NULL) SWIG_fail;
31558 temp1 = true;
31559 }
31560 {
31561 PyThreadState* __tstate = wxPyBeginAllowThreads();
31562 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31563 wxPyEndAllowThreads(__tstate);
31564 if (PyErr_Occurred()) SWIG_fail;
31565 }
31566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31567 {
31568 if (temp1)
31569 delete arg1;
31570 }
31571 return resultobj;
31572 fail:
31573 {
31574 if (temp1)
31575 delete arg1;
31576 }
31577 return NULL;
31578 }
31579
31580
31581 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31582 PyObject *resultobj = 0;
31583 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31584 void *argp1 = 0 ;
31585 int res1 = 0 ;
31586 PyObject *swig_obj[1] ;
31587
31588 if (!args) SWIG_fail;
31589 swig_obj[0] = args;
31590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31591 if (!SWIG_IsOK(res1)) {
31592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31593 }
31594 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31595 {
31596 PyThreadState* __tstate = wxPyBeginAllowThreads();
31597 delete arg1;
31598
31599 wxPyEndAllowThreads(__tstate);
31600 if (PyErr_Occurred()) SWIG_fail;
31601 }
31602 resultobj = SWIG_Py_Void();
31603 return resultobj;
31604 fail:
31605 return NULL;
31606 }
31607
31608
31609 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31610 PyObject *resultobj = 0;
31611 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31612 wxDataFormatId arg2 ;
31613 bool result;
31614 void *argp1 = 0 ;
31615 int res1 = 0 ;
31616 int val2 ;
31617 int ecode2 = 0 ;
31618
31619 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31621 if (!SWIG_IsOK(res1)) {
31622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31623 }
31624 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31625 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31626 if (!SWIG_IsOK(ecode2)) {
31627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31628 }
31629 arg2 = static_cast< wxDataFormatId >(val2);
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 {
31637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31638 }
31639 return resultobj;
31640 fail:
31641 return NULL;
31642 }
31643
31644
31645 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31646 PyObject *resultobj = 0;
31647 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31648 wxDataFormatId arg2 ;
31649 bool result;
31650 void *argp1 = 0 ;
31651 int res1 = 0 ;
31652 int val2 ;
31653 int ecode2 = 0 ;
31654
31655 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31657 if (!SWIG_IsOK(res1)) {
31658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31659 }
31660 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31661 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31662 if (!SWIG_IsOK(ecode2)) {
31663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31664 }
31665 arg2 = static_cast< wxDataFormatId >(val2);
31666 {
31667 PyThreadState* __tstate = wxPyBeginAllowThreads();
31668 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 {
31673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31674 }
31675 return resultobj;
31676 fail:
31677 return NULL;
31678 }
31679
31680
31681 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31682 PyObject *resultobj = 0;
31683 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31684 wxDataFormat *arg2 = 0 ;
31685 bool result;
31686 void *argp1 = 0 ;
31687 int res1 = 0 ;
31688 void *argp2 = 0 ;
31689 int res2 = 0 ;
31690
31691 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31693 if (!SWIG_IsOK(res1)) {
31694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31695 }
31696 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31697 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31698 if (!SWIG_IsOK(res2)) {
31699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31700 }
31701 if (!argp2) {
31702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31703 }
31704 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31708 wxPyEndAllowThreads(__tstate);
31709 if (PyErr_Occurred()) SWIG_fail;
31710 }
31711 {
31712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31713 }
31714 return resultobj;
31715 fail:
31716 return NULL;
31717 }
31718
31719
31720 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31721 int argc;
31722 PyObject *argv[3];
31723
31724 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31725 --argc;
31726 if (argc == 2) {
31727 int _v = 0;
31728 {
31729 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31730 _v = SWIG_CheckState(res);
31731 }
31732 if (!_v) goto check_1;
31733 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31734 }
31735 check_1:
31736
31737 if (argc == 2) {
31738 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31739 }
31740
31741 fail:
31742 Py_INCREF(Py_NotImplemented);
31743 return Py_NotImplemented;
31744 }
31745
31746
31747 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31748 PyObject *resultobj = 0;
31749 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31750 wxDataFormat *arg2 = 0 ;
31751 bool result;
31752 void *argp1 = 0 ;
31753 int res1 = 0 ;
31754 void *argp2 = 0 ;
31755 int res2 = 0 ;
31756
31757 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31759 if (!SWIG_IsOK(res1)) {
31760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31761 }
31762 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31763 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31764 if (!SWIG_IsOK(res2)) {
31765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31766 }
31767 if (!argp2) {
31768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31769 }
31770 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31771 {
31772 PyThreadState* __tstate = wxPyBeginAllowThreads();
31773 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31774 wxPyEndAllowThreads(__tstate);
31775 if (PyErr_Occurred()) SWIG_fail;
31776 }
31777 {
31778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31779 }
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31787 int argc;
31788 PyObject *argv[3];
31789
31790 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31791 --argc;
31792 if (argc == 2) {
31793 int _v = 0;
31794 {
31795 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31796 _v = SWIG_CheckState(res);
31797 }
31798 if (!_v) goto check_1;
31799 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31800 }
31801 check_1:
31802
31803 if (argc == 2) {
31804 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31805 }
31806
31807 fail:
31808 Py_INCREF(Py_NotImplemented);
31809 return Py_NotImplemented;
31810 }
31811
31812
31813 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31814 PyObject *resultobj = 0;
31815 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31816 wxDataFormatId arg2 ;
31817 void *argp1 = 0 ;
31818 int res1 = 0 ;
31819 int val2 ;
31820 int ecode2 = 0 ;
31821 PyObject * obj0 = 0 ;
31822 PyObject * obj1 = 0 ;
31823 char * kwnames[] = {
31824 (char *) "self",(char *) "format", NULL
31825 };
31826
31827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31829 if (!SWIG_IsOK(res1)) {
31830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31831 }
31832 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31833 ecode2 = SWIG_AsVal_int(obj1, &val2);
31834 if (!SWIG_IsOK(ecode2)) {
31835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31836 }
31837 arg2 = static_cast< wxDataFormatId >(val2);
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 (arg1)->SetType(arg2);
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_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31852 PyObject *resultobj = 0;
31853 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31854 wxDataFormatId result;
31855 void *argp1 = 0 ;
31856 int res1 = 0 ;
31857 PyObject *swig_obj[1] ;
31858
31859 if (!args) SWIG_fail;
31860 swig_obj[0] = args;
31861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31862 if (!SWIG_IsOK(res1)) {
31863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31864 }
31865 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_From_int(static_cast< int >(result));
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_DataFormat__GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *resultobj = 0;
31881 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31882 wxString result;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 PyObject *swig_obj[1] ;
31886
31887 if (!args) SWIG_fail;
31888 swig_obj[0] = args;
31889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat__GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31892 }
31893 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 result = ((wxDataFormat const *)arg1)->GetId();
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 {
31901 #if wxUSE_UNICODE
31902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31903 #else
31904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31905 #endif
31906 }
31907 return resultobj;
31908 fail:
31909 return NULL;
31910 }
31911
31912
31913 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31914 PyObject *resultobj = 0;
31915 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31916 wxString *arg2 = 0 ;
31917 void *argp1 = 0 ;
31918 int res1 = 0 ;
31919 bool temp2 = false ;
31920 PyObject * obj0 = 0 ;
31921 PyObject * obj1 = 0 ;
31922 char * kwnames[] = {
31923 (char *) "self",(char *) "format", NULL
31924 };
31925
31926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31928 if (!SWIG_IsOK(res1)) {
31929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31930 }
31931 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31932 {
31933 arg2 = wxString_in_helper(obj1);
31934 if (arg2 == NULL) SWIG_fail;
31935 temp2 = true;
31936 }
31937 {
31938 PyThreadState* __tstate = wxPyBeginAllowThreads();
31939 (arg1)->SetId((wxString const &)*arg2);
31940 wxPyEndAllowThreads(__tstate);
31941 if (PyErr_Occurred()) SWIG_fail;
31942 }
31943 resultobj = SWIG_Py_Void();
31944 {
31945 if (temp2)
31946 delete arg2;
31947 }
31948 return resultobj;
31949 fail:
31950 {
31951 if (temp2)
31952 delete arg2;
31953 }
31954 return NULL;
31955 }
31956
31957
31958 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31959 PyObject *obj;
31960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31961 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31962 return SWIG_Py_Void();
31963 }
31964
31965 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31966 return SWIG_Python_InitShadowInstance(args);
31967 }
31968
31969 SWIGINTERN int FormatInvalid_set(PyObject *) {
31970 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31971 return 1;
31972 }
31973
31974
31975 SWIGINTERN PyObject *FormatInvalid_get(void) {
31976 PyObject *pyobj = 0;
31977
31978 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31979 return pyobj;
31980 }
31981
31982
31983 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31984 PyObject *resultobj = 0;
31985 wxDataObject *arg1 = (wxDataObject *) 0 ;
31986 void *argp1 = 0 ;
31987 int res1 = 0 ;
31988 PyObject *swig_obj[1] ;
31989
31990 if (!args) SWIG_fail;
31991 swig_obj[0] = args;
31992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31993 if (!SWIG_IsOK(res1)) {
31994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31995 }
31996 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31997 {
31998 PyThreadState* __tstate = wxPyBeginAllowThreads();
31999 delete arg1;
32000
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_Py_Void();
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32012 PyObject *resultobj = 0;
32013 wxDataObject *arg1 = (wxDataObject *) 0 ;
32014 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32015 SwigValueWrapper<wxDataFormat > result;
32016 void *argp1 = 0 ;
32017 int res1 = 0 ;
32018 int val2 ;
32019 int ecode2 = 0 ;
32020 PyObject * obj0 = 0 ;
32021 PyObject * obj1 = 0 ;
32022 char * kwnames[] = {
32023 (char *) "self",(char *) "dir", NULL
32024 };
32025
32026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32028 if (!SWIG_IsOK(res1)) {
32029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32030 }
32031 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32032 if (obj1) {
32033 ecode2 = SWIG_AsVal_int(obj1, &val2);
32034 if (!SWIG_IsOK(ecode2)) {
32035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32036 }
32037 arg2 = static_cast< wxDataObject::Direction >(val2);
32038 }
32039 {
32040 PyThreadState* __tstate = wxPyBeginAllowThreads();
32041 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32053 PyObject *resultobj = 0;
32054 wxDataObject *arg1 = (wxDataObject *) 0 ;
32055 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32056 size_t result;
32057 void *argp1 = 0 ;
32058 int res1 = 0 ;
32059 int val2 ;
32060 int ecode2 = 0 ;
32061 PyObject * obj0 = 0 ;
32062 PyObject * obj1 = 0 ;
32063 char * kwnames[] = {
32064 (char *) "self",(char *) "dir", NULL
32065 };
32066
32067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32069 if (!SWIG_IsOK(res1)) {
32070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32071 }
32072 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32073 if (obj1) {
32074 ecode2 = SWIG_AsVal_int(obj1, &val2);
32075 if (!SWIG_IsOK(ecode2)) {
32076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32077 }
32078 arg2 = static_cast< wxDataObject::Direction >(val2);
32079 }
32080 {
32081 PyThreadState* __tstate = wxPyBeginAllowThreads();
32082 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32083 wxPyEndAllowThreads(__tstate);
32084 if (PyErr_Occurred()) SWIG_fail;
32085 }
32086 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32087 return resultobj;
32088 fail:
32089 return NULL;
32090 }
32091
32092
32093 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32094 PyObject *resultobj = 0;
32095 wxDataObject *arg1 = (wxDataObject *) 0 ;
32096 wxDataFormat *arg2 = 0 ;
32097 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32098 bool result;
32099 void *argp1 = 0 ;
32100 int res1 = 0 ;
32101 void *argp2 = 0 ;
32102 int res2 = 0 ;
32103 int val3 ;
32104 int ecode3 = 0 ;
32105 PyObject * obj0 = 0 ;
32106 PyObject * obj1 = 0 ;
32107 PyObject * obj2 = 0 ;
32108 char * kwnames[] = {
32109 (char *) "self",(char *) "format",(char *) "dir", NULL
32110 };
32111
32112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32114 if (!SWIG_IsOK(res1)) {
32115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32116 }
32117 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32119 if (!SWIG_IsOK(res2)) {
32120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32121 }
32122 if (!argp2) {
32123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32124 }
32125 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32126 if (obj2) {
32127 ecode3 = SWIG_AsVal_int(obj2, &val3);
32128 if (!SWIG_IsOK(ecode3)) {
32129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32130 }
32131 arg3 = static_cast< wxDataObject::Direction >(val3);
32132 }
32133 {
32134 PyThreadState* __tstate = wxPyBeginAllowThreads();
32135 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32136 wxPyEndAllowThreads(__tstate);
32137 if (PyErr_Occurred()) SWIG_fail;
32138 }
32139 {
32140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32141 }
32142 return resultobj;
32143 fail:
32144 return NULL;
32145 }
32146
32147
32148 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32149 PyObject *resultobj = 0;
32150 wxDataObject *arg1 = (wxDataObject *) 0 ;
32151 wxDataFormat *arg2 = 0 ;
32152 size_t result;
32153 void *argp1 = 0 ;
32154 int res1 = 0 ;
32155 void *argp2 = 0 ;
32156 int res2 = 0 ;
32157 PyObject * obj0 = 0 ;
32158 PyObject * obj1 = 0 ;
32159 char * kwnames[] = {
32160 (char *) "self",(char *) "format", NULL
32161 };
32162
32163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32165 if (!SWIG_IsOK(res1)) {
32166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32167 }
32168 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32170 if (!SWIG_IsOK(res2)) {
32171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32172 }
32173 if (!argp2) {
32174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32175 }
32176 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32184 return resultobj;
32185 fail:
32186 return NULL;
32187 }
32188
32189
32190 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32191 PyObject *resultobj = 0;
32192 wxDataObject *arg1 = (wxDataObject *) 0 ;
32193 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32194 PyObject *result = 0 ;
32195 void *argp1 = 0 ;
32196 int res1 = 0 ;
32197 int val2 ;
32198 int ecode2 = 0 ;
32199 PyObject * obj0 = 0 ;
32200 PyObject * obj1 = 0 ;
32201 char * kwnames[] = {
32202 (char *) "self",(char *) "dir", NULL
32203 };
32204
32205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32207 if (!SWIG_IsOK(res1)) {
32208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32209 }
32210 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32211 if (obj1) {
32212 ecode2 = SWIG_AsVal_int(obj1, &val2);
32213 if (!SWIG_IsOK(ecode2)) {
32214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32215 }
32216 arg2 = static_cast< wxDataObject::Direction >(val2);
32217 }
32218 {
32219 PyThreadState* __tstate = wxPyBeginAllowThreads();
32220 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32221 wxPyEndAllowThreads(__tstate);
32222 if (PyErr_Occurred()) SWIG_fail;
32223 }
32224 resultobj = result;
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32232 PyObject *resultobj = 0;
32233 wxDataObject *arg1 = (wxDataObject *) 0 ;
32234 wxDataFormat *arg2 = 0 ;
32235 PyObject *result = 0 ;
32236 void *argp1 = 0 ;
32237 int res1 = 0 ;
32238 void *argp2 = 0 ;
32239 int res2 = 0 ;
32240 PyObject * obj0 = 0 ;
32241 PyObject * obj1 = 0 ;
32242 char * kwnames[] = {
32243 (char *) "self",(char *) "format", NULL
32244 };
32245
32246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32248 if (!SWIG_IsOK(res1)) {
32249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32250 }
32251 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32252 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32253 if (!SWIG_IsOK(res2)) {
32254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32255 }
32256 if (!argp2) {
32257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32258 }
32259 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32260 {
32261 PyThreadState* __tstate = wxPyBeginAllowThreads();
32262 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32263 wxPyEndAllowThreads(__tstate);
32264 if (PyErr_Occurred()) SWIG_fail;
32265 }
32266 resultobj = result;
32267 return resultobj;
32268 fail:
32269 return NULL;
32270 }
32271
32272
32273 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32274 PyObject *resultobj = 0;
32275 wxDataObject *arg1 = (wxDataObject *) 0 ;
32276 wxDataFormat *arg2 = 0 ;
32277 PyObject *arg3 = (PyObject *) 0 ;
32278 bool result;
32279 void *argp1 = 0 ;
32280 int res1 = 0 ;
32281 void *argp2 = 0 ;
32282 int res2 = 0 ;
32283 PyObject * obj0 = 0 ;
32284 PyObject * obj1 = 0 ;
32285 PyObject * obj2 = 0 ;
32286 char * kwnames[] = {
32287 (char *) "self",(char *) "format",(char *) "data", NULL
32288 };
32289
32290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32292 if (!SWIG_IsOK(res1)) {
32293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32294 }
32295 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32297 if (!SWIG_IsOK(res2)) {
32298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32299 }
32300 if (!argp2) {
32301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32302 }
32303 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32304 arg3 = obj2;
32305 {
32306 PyThreadState* __tstate = wxPyBeginAllowThreads();
32307 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32308 wxPyEndAllowThreads(__tstate);
32309 if (PyErr_Occurred()) SWIG_fail;
32310 }
32311 {
32312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32313 }
32314 return resultobj;
32315 fail:
32316 return NULL;
32317 }
32318
32319
32320 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32321 PyObject *obj;
32322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32323 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32324 return SWIG_Py_Void();
32325 }
32326
32327 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32328 PyObject *resultobj = 0;
32329 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32330 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32331 wxDataObjectSimple *result = 0 ;
32332 void *argp1 = 0 ;
32333 int res1 = 0 ;
32334 PyObject * obj0 = 0 ;
32335 char * kwnames[] = {
32336 (char *) "format", NULL
32337 };
32338
32339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32340 if (obj0) {
32341 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32342 if (!SWIG_IsOK(res1)) {
32343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32344 }
32345 if (!argp1) {
32346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32347 }
32348 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32349 }
32350 {
32351 PyThreadState* __tstate = wxPyBeginAllowThreads();
32352 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32353 wxPyEndAllowThreads(__tstate);
32354 if (PyErr_Occurred()) SWIG_fail;
32355 }
32356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32357 return resultobj;
32358 fail:
32359 return NULL;
32360 }
32361
32362
32363 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32364 PyObject *resultobj = 0;
32365 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32366 wxDataFormat *result = 0 ;
32367 void *argp1 = 0 ;
32368 int res1 = 0 ;
32369 PyObject *swig_obj[1] ;
32370
32371 if (!args) SWIG_fail;
32372 swig_obj[0] = args;
32373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32374 if (!SWIG_IsOK(res1)) {
32375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32376 }
32377 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32378 {
32379 PyThreadState* __tstate = wxPyBeginAllowThreads();
32380 {
32381 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32382 result = (wxDataFormat *) &_result_ref;
32383 }
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32395 PyObject *resultobj = 0;
32396 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32397 wxDataFormat *arg2 = 0 ;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 void *argp2 = 0 ;
32401 int res2 = 0 ;
32402 PyObject * obj0 = 0 ;
32403 PyObject * obj1 = 0 ;
32404 char * kwnames[] = {
32405 (char *) "self",(char *) "format", NULL
32406 };
32407
32408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32412 }
32413 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32414 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32415 if (!SWIG_IsOK(res2)) {
32416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32417 }
32418 if (!argp2) {
32419 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32420 }
32421 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32422 {
32423 PyThreadState* __tstate = wxPyBeginAllowThreads();
32424 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32425 wxPyEndAllowThreads(__tstate);
32426 if (PyErr_Occurred()) SWIG_fail;
32427 }
32428 resultobj = SWIG_Py_Void();
32429 return resultobj;
32430 fail:
32431 return NULL;
32432 }
32433
32434
32435 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32436 PyObject *resultobj = 0;
32437 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32438 size_t result;
32439 void *argp1 = 0 ;
32440 int res1 = 0 ;
32441 PyObject *swig_obj[1] ;
32442
32443 if (!args) SWIG_fail;
32444 swig_obj[0] = args;
32445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32446 if (!SWIG_IsOK(res1)) {
32447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32448 }
32449 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32453 wxPyEndAllowThreads(__tstate);
32454 if (PyErr_Occurred()) SWIG_fail;
32455 }
32456 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32457 return resultobj;
32458 fail:
32459 return NULL;
32460 }
32461
32462
32463 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32464 PyObject *resultobj = 0;
32465 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32466 PyObject *result = 0 ;
32467 void *argp1 = 0 ;
32468 int res1 = 0 ;
32469 PyObject *swig_obj[1] ;
32470
32471 if (!args) SWIG_fail;
32472 swig_obj[0] = args;
32473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32474 if (!SWIG_IsOK(res1)) {
32475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32476 }
32477 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 resultobj = result;
32485 return resultobj;
32486 fail:
32487 return NULL;
32488 }
32489
32490
32491 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32492 PyObject *resultobj = 0;
32493 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32494 PyObject *arg2 = (PyObject *) 0 ;
32495 bool result;
32496 void *argp1 = 0 ;
32497 int res1 = 0 ;
32498 PyObject * obj0 = 0 ;
32499 PyObject * obj1 = 0 ;
32500 char * kwnames[] = {
32501 (char *) "self",(char *) "data", NULL
32502 };
32503
32504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32506 if (!SWIG_IsOK(res1)) {
32507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32508 }
32509 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32510 arg2 = obj1;
32511 {
32512 PyThreadState* __tstate = wxPyBeginAllowThreads();
32513 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 {
32518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32519 }
32520 return resultobj;
32521 fail:
32522 return NULL;
32523 }
32524
32525
32526 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32527 PyObject *obj;
32528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32529 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32530 return SWIG_Py_Void();
32531 }
32532
32533 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32534 return SWIG_Python_InitShadowInstance(args);
32535 }
32536
32537 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32538 PyObject *resultobj = 0;
32539 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32540 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32541 wxPyDataObjectSimple *result = 0 ;
32542 void *argp1 = 0 ;
32543 int res1 = 0 ;
32544 PyObject * obj0 = 0 ;
32545 char * kwnames[] = {
32546 (char *) "format", NULL
32547 };
32548
32549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32550 if (obj0) {
32551 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32552 if (!SWIG_IsOK(res1)) {
32553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32554 }
32555 if (!argp1) {
32556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32557 }
32558 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32559 }
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32574 PyObject *resultobj = 0;
32575 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32576 PyObject *arg2 = (PyObject *) 0 ;
32577 PyObject *arg3 = (PyObject *) 0 ;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 PyObject * obj0 = 0 ;
32581 PyObject * obj1 = 0 ;
32582 PyObject * obj2 = 0 ;
32583 char * kwnames[] = {
32584 (char *) "self",(char *) "self",(char *) "_class", NULL
32585 };
32586
32587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32589 if (!SWIG_IsOK(res1)) {
32590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32591 }
32592 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32593 arg2 = obj1;
32594 arg3 = obj2;
32595 {
32596 PyThreadState* __tstate = wxPyBeginAllowThreads();
32597 (arg1)->_setCallbackInfo(arg2,arg3);
32598 wxPyEndAllowThreads(__tstate);
32599 if (PyErr_Occurred()) SWIG_fail;
32600 }
32601 resultobj = SWIG_Py_Void();
32602 return resultobj;
32603 fail:
32604 return NULL;
32605 }
32606
32607
32608 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32609 PyObject *obj;
32610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32611 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32612 return SWIG_Py_Void();
32613 }
32614
32615 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32616 return SWIG_Python_InitShadowInstance(args);
32617 }
32618
32619 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32620 PyObject *resultobj = 0;
32621 wxDataObjectComposite *result = 0 ;
32622
32623 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32624 {
32625 PyThreadState* __tstate = wxPyBeginAllowThreads();
32626 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32627 wxPyEndAllowThreads(__tstate);
32628 if (PyErr_Occurred()) SWIG_fail;
32629 }
32630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32631 return resultobj;
32632 fail:
32633 return NULL;
32634 }
32635
32636
32637 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32638 PyObject *resultobj = 0;
32639 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32640 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32641 bool arg3 = (bool) false ;
32642 void *argp1 = 0 ;
32643 int res1 = 0 ;
32644 int res2 = 0 ;
32645 bool val3 ;
32646 int ecode3 = 0 ;
32647 PyObject * obj0 = 0 ;
32648 PyObject * obj1 = 0 ;
32649 PyObject * obj2 = 0 ;
32650 char * kwnames[] = {
32651 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32652 };
32653
32654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32656 if (!SWIG_IsOK(res1)) {
32657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32658 }
32659 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32660 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32661 if (!SWIG_IsOK(res2)) {
32662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32663 }
32664 if (obj2) {
32665 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32666 if (!SWIG_IsOK(ecode3)) {
32667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32668 }
32669 arg3 = static_cast< bool >(val3);
32670 }
32671 {
32672 PyThreadState* __tstate = wxPyBeginAllowThreads();
32673 (arg1)->Add(arg2,arg3);
32674 wxPyEndAllowThreads(__tstate);
32675 if (PyErr_Occurred()) SWIG_fail;
32676 }
32677 resultobj = SWIG_Py_Void();
32678 return resultobj;
32679 fail:
32680 return NULL;
32681 }
32682
32683
32684 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32685 PyObject *resultobj = 0;
32686 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32687 SwigValueWrapper<wxDataFormat > result;
32688 void *argp1 = 0 ;
32689 int res1 = 0 ;
32690 PyObject *swig_obj[1] ;
32691
32692 if (!args) SWIG_fail;
32693 swig_obj[0] = args;
32694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32695 if (!SWIG_IsOK(res1)) {
32696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32697 }
32698 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32713 PyObject *obj;
32714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32715 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32716 return SWIG_Py_Void();
32717 }
32718
32719 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32720 return SWIG_Python_InitShadowInstance(args);
32721 }
32722
32723 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32724 PyObject *resultobj = 0;
32725 wxString const &arg1_defvalue = wxPyEmptyString ;
32726 wxString *arg1 = (wxString *) &arg1_defvalue ;
32727 wxTextDataObject *result = 0 ;
32728 bool temp1 = false ;
32729 PyObject * obj0 = 0 ;
32730 char * kwnames[] = {
32731 (char *) "text", NULL
32732 };
32733
32734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32735 if (obj0) {
32736 {
32737 arg1 = wxString_in_helper(obj0);
32738 if (arg1 == NULL) SWIG_fail;
32739 temp1 = true;
32740 }
32741 }
32742 {
32743 PyThreadState* __tstate = wxPyBeginAllowThreads();
32744 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32749 {
32750 if (temp1)
32751 delete arg1;
32752 }
32753 return resultobj;
32754 fail:
32755 {
32756 if (temp1)
32757 delete arg1;
32758 }
32759 return NULL;
32760 }
32761
32762
32763 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32764 PyObject *resultobj = 0;
32765 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32766 size_t result;
32767 void *argp1 = 0 ;
32768 int res1 = 0 ;
32769 PyObject *swig_obj[1] ;
32770
32771 if (!args) SWIG_fail;
32772 swig_obj[0] = args;
32773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32774 if (!SWIG_IsOK(res1)) {
32775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32776 }
32777 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32778 {
32779 PyThreadState* __tstate = wxPyBeginAllowThreads();
32780 result = (size_t)(arg1)->GetTextLength();
32781 wxPyEndAllowThreads(__tstate);
32782 if (PyErr_Occurred()) SWIG_fail;
32783 }
32784 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32785 return resultobj;
32786 fail:
32787 return NULL;
32788 }
32789
32790
32791 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32792 PyObject *resultobj = 0;
32793 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32794 wxString result;
32795 void *argp1 = 0 ;
32796 int res1 = 0 ;
32797 PyObject *swig_obj[1] ;
32798
32799 if (!args) SWIG_fail;
32800 swig_obj[0] = args;
32801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32802 if (!SWIG_IsOK(res1)) {
32803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32804 }
32805 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32806 {
32807 PyThreadState* __tstate = wxPyBeginAllowThreads();
32808 result = (arg1)->GetText();
32809 wxPyEndAllowThreads(__tstate);
32810 if (PyErr_Occurred()) SWIG_fail;
32811 }
32812 {
32813 #if wxUSE_UNICODE
32814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32815 #else
32816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32817 #endif
32818 }
32819 return resultobj;
32820 fail:
32821 return NULL;
32822 }
32823
32824
32825 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32826 PyObject *resultobj = 0;
32827 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32828 wxString *arg2 = 0 ;
32829 void *argp1 = 0 ;
32830 int res1 = 0 ;
32831 bool temp2 = false ;
32832 PyObject * obj0 = 0 ;
32833 PyObject * obj1 = 0 ;
32834 char * kwnames[] = {
32835 (char *) "self",(char *) "text", NULL
32836 };
32837
32838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32840 if (!SWIG_IsOK(res1)) {
32841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32842 }
32843 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32844 {
32845 arg2 = wxString_in_helper(obj1);
32846 if (arg2 == NULL) SWIG_fail;
32847 temp2 = true;
32848 }
32849 {
32850 PyThreadState* __tstate = wxPyBeginAllowThreads();
32851 (arg1)->SetText((wxString const &)*arg2);
32852 wxPyEndAllowThreads(__tstate);
32853 if (PyErr_Occurred()) SWIG_fail;
32854 }
32855 resultobj = SWIG_Py_Void();
32856 {
32857 if (temp2)
32858 delete arg2;
32859 }
32860 return resultobj;
32861 fail:
32862 {
32863 if (temp2)
32864 delete arg2;
32865 }
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32871 PyObject *obj;
32872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32873 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32874 return SWIG_Py_Void();
32875 }
32876
32877 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32878 return SWIG_Python_InitShadowInstance(args);
32879 }
32880
32881 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32882 PyObject *resultobj = 0;
32883 wxString const &arg1_defvalue = wxPyEmptyString ;
32884 wxString *arg1 = (wxString *) &arg1_defvalue ;
32885 wxPyTextDataObject *result = 0 ;
32886 bool temp1 = false ;
32887 PyObject * obj0 = 0 ;
32888 char * kwnames[] = {
32889 (char *) "text", NULL
32890 };
32891
32892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32893 if (obj0) {
32894 {
32895 arg1 = wxString_in_helper(obj0);
32896 if (arg1 == NULL) SWIG_fail;
32897 temp1 = true;
32898 }
32899 }
32900 {
32901 PyThreadState* __tstate = wxPyBeginAllowThreads();
32902 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32903 wxPyEndAllowThreads(__tstate);
32904 if (PyErr_Occurred()) SWIG_fail;
32905 }
32906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32907 {
32908 if (temp1)
32909 delete arg1;
32910 }
32911 return resultobj;
32912 fail:
32913 {
32914 if (temp1)
32915 delete arg1;
32916 }
32917 return NULL;
32918 }
32919
32920
32921 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32922 PyObject *resultobj = 0;
32923 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32924 PyObject *arg2 = (PyObject *) 0 ;
32925 PyObject *arg3 = (PyObject *) 0 ;
32926 void *argp1 = 0 ;
32927 int res1 = 0 ;
32928 PyObject * obj0 = 0 ;
32929 PyObject * obj1 = 0 ;
32930 PyObject * obj2 = 0 ;
32931 char * kwnames[] = {
32932 (char *) "self",(char *) "self",(char *) "_class", NULL
32933 };
32934
32935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32937 if (!SWIG_IsOK(res1)) {
32938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32939 }
32940 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32941 arg2 = obj1;
32942 arg3 = obj2;
32943 {
32944 PyThreadState* __tstate = wxPyBeginAllowThreads();
32945 (arg1)->_setCallbackInfo(arg2,arg3);
32946 wxPyEndAllowThreads(__tstate);
32947 if (PyErr_Occurred()) SWIG_fail;
32948 }
32949 resultobj = SWIG_Py_Void();
32950 return resultobj;
32951 fail:
32952 return NULL;
32953 }
32954
32955
32956 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32957 PyObject *obj;
32958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32959 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32960 return SWIG_Py_Void();
32961 }
32962
32963 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32964 return SWIG_Python_InitShadowInstance(args);
32965 }
32966
32967 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32968 PyObject *resultobj = 0;
32969 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32970 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32971 wxBitmapDataObject *result = 0 ;
32972 void *argp1 = 0 ;
32973 int res1 = 0 ;
32974 PyObject * obj0 = 0 ;
32975 char * kwnames[] = {
32976 (char *) "bitmap", NULL
32977 };
32978
32979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32980 if (obj0) {
32981 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32982 if (!SWIG_IsOK(res1)) {
32983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32984 }
32985 if (!argp1) {
32986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32987 }
32988 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32989 }
32990 {
32991 PyThreadState* __tstate = wxPyBeginAllowThreads();
32992 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32993 wxPyEndAllowThreads(__tstate);
32994 if (PyErr_Occurred()) SWIG_fail;
32995 }
32996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32997 return resultobj;
32998 fail:
32999 return NULL;
33000 }
33001
33002
33003 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33004 PyObject *resultobj = 0;
33005 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33006 wxBitmap result;
33007 void *argp1 = 0 ;
33008 int res1 = 0 ;
33009 PyObject *swig_obj[1] ;
33010
33011 if (!args) SWIG_fail;
33012 swig_obj[0] = args;
33013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33014 if (!SWIG_IsOK(res1)) {
33015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33016 }
33017 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33018 {
33019 PyThreadState* __tstate = wxPyBeginAllowThreads();
33020 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33021 wxPyEndAllowThreads(__tstate);
33022 if (PyErr_Occurred()) SWIG_fail;
33023 }
33024 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33025 return resultobj;
33026 fail:
33027 return NULL;
33028 }
33029
33030
33031 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33032 PyObject *resultobj = 0;
33033 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33034 wxBitmap *arg2 = 0 ;
33035 void *argp1 = 0 ;
33036 int res1 = 0 ;
33037 void *argp2 = 0 ;
33038 int res2 = 0 ;
33039 PyObject * obj0 = 0 ;
33040 PyObject * obj1 = 0 ;
33041 char * kwnames[] = {
33042 (char *) "self",(char *) "bitmap", NULL
33043 };
33044
33045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33049 }
33050 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33052 if (!SWIG_IsOK(res2)) {
33053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33054 }
33055 if (!argp2) {
33056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33057 }
33058 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33059 {
33060 PyThreadState* __tstate = wxPyBeginAllowThreads();
33061 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33062 wxPyEndAllowThreads(__tstate);
33063 if (PyErr_Occurred()) SWIG_fail;
33064 }
33065 resultobj = SWIG_Py_Void();
33066 return resultobj;
33067 fail:
33068 return NULL;
33069 }
33070
33071
33072 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33073 PyObject *obj;
33074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33075 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33076 return SWIG_Py_Void();
33077 }
33078
33079 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33080 return SWIG_Python_InitShadowInstance(args);
33081 }
33082
33083 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33084 PyObject *resultobj = 0;
33085 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33086 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33087 wxPyBitmapDataObject *result = 0 ;
33088 void *argp1 = 0 ;
33089 int res1 = 0 ;
33090 PyObject * obj0 = 0 ;
33091 char * kwnames[] = {
33092 (char *) "bitmap", NULL
33093 };
33094
33095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33096 if (obj0) {
33097 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33098 if (!SWIG_IsOK(res1)) {
33099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33100 }
33101 if (!argp1) {
33102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33103 }
33104 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33105 }
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33109 wxPyEndAllowThreads(__tstate);
33110 if (PyErr_Occurred()) SWIG_fail;
33111 }
33112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33113 return resultobj;
33114 fail:
33115 return NULL;
33116 }
33117
33118
33119 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33120 PyObject *resultobj = 0;
33121 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33122 PyObject *arg2 = (PyObject *) 0 ;
33123 PyObject *arg3 = (PyObject *) 0 ;
33124 void *argp1 = 0 ;
33125 int res1 = 0 ;
33126 PyObject * obj0 = 0 ;
33127 PyObject * obj1 = 0 ;
33128 PyObject * obj2 = 0 ;
33129 char * kwnames[] = {
33130 (char *) "self",(char *) "self",(char *) "_class", NULL
33131 };
33132
33133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33135 if (!SWIG_IsOK(res1)) {
33136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33137 }
33138 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33139 arg2 = obj1;
33140 arg3 = obj2;
33141 {
33142 PyThreadState* __tstate = wxPyBeginAllowThreads();
33143 (arg1)->_setCallbackInfo(arg2,arg3);
33144 wxPyEndAllowThreads(__tstate);
33145 if (PyErr_Occurred()) SWIG_fail;
33146 }
33147 resultobj = SWIG_Py_Void();
33148 return resultobj;
33149 fail:
33150 return NULL;
33151 }
33152
33153
33154 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33155 PyObject *obj;
33156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33157 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33158 return SWIG_Py_Void();
33159 }
33160
33161 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33162 return SWIG_Python_InitShadowInstance(args);
33163 }
33164
33165 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33166 PyObject *resultobj = 0;
33167 wxFileDataObject *result = 0 ;
33168
33169 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33170 {
33171 PyThreadState* __tstate = wxPyBeginAllowThreads();
33172 result = (wxFileDataObject *)new wxFileDataObject();
33173 wxPyEndAllowThreads(__tstate);
33174 if (PyErr_Occurred()) SWIG_fail;
33175 }
33176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33177 return resultobj;
33178 fail:
33179 return NULL;
33180 }
33181
33182
33183 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33184 PyObject *resultobj = 0;
33185 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33186 wxArrayString *result = 0 ;
33187 void *argp1 = 0 ;
33188 int res1 = 0 ;
33189 PyObject *swig_obj[1] ;
33190
33191 if (!args) SWIG_fail;
33192 swig_obj[0] = args;
33193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33194 if (!SWIG_IsOK(res1)) {
33195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33196 }
33197 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33198 {
33199 PyThreadState* __tstate = wxPyBeginAllowThreads();
33200 {
33201 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33202 result = (wxArrayString *) &_result_ref;
33203 }
33204 wxPyEndAllowThreads(__tstate);
33205 if (PyErr_Occurred()) SWIG_fail;
33206 }
33207 {
33208 resultobj = wxArrayString2PyList_helper(*result);
33209 }
33210 return resultobj;
33211 fail:
33212 return NULL;
33213 }
33214
33215
33216 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33217 PyObject *resultobj = 0;
33218 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33219 wxString *arg2 = 0 ;
33220 void *argp1 = 0 ;
33221 int res1 = 0 ;
33222 bool temp2 = false ;
33223 PyObject * obj0 = 0 ;
33224 PyObject * obj1 = 0 ;
33225 char * kwnames[] = {
33226 (char *) "self",(char *) "filename", NULL
33227 };
33228
33229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33231 if (!SWIG_IsOK(res1)) {
33232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33233 }
33234 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33235 {
33236 arg2 = wxString_in_helper(obj1);
33237 if (arg2 == NULL) SWIG_fail;
33238 temp2 = true;
33239 }
33240 {
33241 PyThreadState* __tstate = wxPyBeginAllowThreads();
33242 (arg1)->AddFile((wxString const &)*arg2);
33243 wxPyEndAllowThreads(__tstate);
33244 if (PyErr_Occurred()) SWIG_fail;
33245 }
33246 resultobj = SWIG_Py_Void();
33247 {
33248 if (temp2)
33249 delete arg2;
33250 }
33251 return resultobj;
33252 fail:
33253 {
33254 if (temp2)
33255 delete arg2;
33256 }
33257 return NULL;
33258 }
33259
33260
33261 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33262 PyObject *obj;
33263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33264 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33265 return SWIG_Py_Void();
33266 }
33267
33268 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33269 return SWIG_Python_InitShadowInstance(args);
33270 }
33271
33272 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33273 PyObject *resultobj = 0;
33274 wxDataFormat *arg1 = 0 ;
33275 wxCustomDataObject *result = 0 ;
33276 void *argp1 = 0 ;
33277 int res1 = 0 ;
33278
33279 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33281 if (!SWIG_IsOK(res1)) {
33282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33283 }
33284 if (!argp1) {
33285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33286 }
33287 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33288 {
33289 PyThreadState* __tstate = wxPyBeginAllowThreads();
33290 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33291 wxPyEndAllowThreads(__tstate);
33292 if (PyErr_Occurred()) SWIG_fail;
33293 }
33294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33295 return resultobj;
33296 fail:
33297 return NULL;
33298 }
33299
33300
33301 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33302 PyObject *resultobj = 0;
33303 wxString *arg1 = 0 ;
33304 wxCustomDataObject *result = 0 ;
33305 bool temp1 = false ;
33306
33307 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33308 {
33309 arg1 = wxString_in_helper(swig_obj[0]);
33310 if (arg1 == NULL) SWIG_fail;
33311 temp1 = true;
33312 }
33313 {
33314 PyThreadState* __tstate = wxPyBeginAllowThreads();
33315 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33316 wxPyEndAllowThreads(__tstate);
33317 if (PyErr_Occurred()) SWIG_fail;
33318 }
33319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33320 {
33321 if (temp1)
33322 delete arg1;
33323 }
33324 return resultobj;
33325 fail:
33326 {
33327 if (temp1)
33328 delete arg1;
33329 }
33330 return NULL;
33331 }
33332
33333
33334 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33335 PyObject *resultobj = 0;
33336 wxCustomDataObject *result = 0 ;
33337
33338 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33339 {
33340 PyThreadState* __tstate = wxPyBeginAllowThreads();
33341 result = (wxCustomDataObject *)new wxCustomDataObject();
33342 wxPyEndAllowThreads(__tstate);
33343 if (PyErr_Occurred()) SWIG_fail;
33344 }
33345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33346 return resultobj;
33347 fail:
33348 return NULL;
33349 }
33350
33351
33352 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33353 int argc;
33354 PyObject *argv[2];
33355
33356 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33357 --argc;
33358 if (argc == 0) {
33359 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33360 }
33361 if (argc == 1) {
33362 int _v = 0;
33363 {
33364 {
33365 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33366 }
33367 }
33368 if (!_v) goto check_2;
33369 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33370 }
33371 check_2:
33372
33373 if (argc == 1) {
33374 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33375 }
33376
33377 fail:
33378 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33379 return NULL;
33380 }
33381
33382
33383 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33384 PyObject *resultobj = 0;
33385 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33386 PyObject *arg2 = (PyObject *) 0 ;
33387 bool result;
33388 void *argp1 = 0 ;
33389 int res1 = 0 ;
33390 PyObject * obj0 = 0 ;
33391 PyObject * obj1 = 0 ;
33392 char * kwnames[] = {
33393 (char *) "self",(char *) "data", NULL
33394 };
33395
33396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33400 }
33401 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33402 arg2 = obj1;
33403 {
33404 PyThreadState* __tstate = wxPyBeginAllowThreads();
33405 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33406 wxPyEndAllowThreads(__tstate);
33407 if (PyErr_Occurred()) SWIG_fail;
33408 }
33409 {
33410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33411 }
33412 return resultobj;
33413 fail:
33414 return NULL;
33415 }
33416
33417
33418 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33419 PyObject *resultobj = 0;
33420 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33421 size_t result;
33422 void *argp1 = 0 ;
33423 int res1 = 0 ;
33424 PyObject *swig_obj[1] ;
33425
33426 if (!args) SWIG_fail;
33427 swig_obj[0] = args;
33428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33429 if (!SWIG_IsOK(res1)) {
33430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33431 }
33432 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33433 {
33434 PyThreadState* __tstate = wxPyBeginAllowThreads();
33435 result = (size_t)(arg1)->GetSize();
33436 wxPyEndAllowThreads(__tstate);
33437 if (PyErr_Occurred()) SWIG_fail;
33438 }
33439 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33440 return resultobj;
33441 fail:
33442 return NULL;
33443 }
33444
33445
33446 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33447 PyObject *resultobj = 0;
33448 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33449 PyObject *result = 0 ;
33450 void *argp1 = 0 ;
33451 int res1 = 0 ;
33452 PyObject *swig_obj[1] ;
33453
33454 if (!args) SWIG_fail;
33455 swig_obj[0] = args;
33456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33457 if (!SWIG_IsOK(res1)) {
33458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33459 }
33460 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 resultobj = result;
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33475 PyObject *obj;
33476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33477 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33478 return SWIG_Py_Void();
33479 }
33480
33481 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33482 return SWIG_Python_InitShadowInstance(args);
33483 }
33484
33485 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33486 PyObject *resultobj = 0;
33487 wxString const &arg1_defvalue = wxPyEmptyString ;
33488 wxString *arg1 = (wxString *) &arg1_defvalue ;
33489 wxURLDataObject *result = 0 ;
33490 bool temp1 = false ;
33491 PyObject * obj0 = 0 ;
33492 char * kwnames[] = {
33493 (char *) "url", NULL
33494 };
33495
33496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33497 if (obj0) {
33498 {
33499 arg1 = wxString_in_helper(obj0);
33500 if (arg1 == NULL) SWIG_fail;
33501 temp1 = true;
33502 }
33503 }
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33511 {
33512 if (temp1)
33513 delete arg1;
33514 }
33515 return resultobj;
33516 fail:
33517 {
33518 if (temp1)
33519 delete arg1;
33520 }
33521 return NULL;
33522 }
33523
33524
33525 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33526 PyObject *resultobj = 0;
33527 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33528 wxString result;
33529 void *argp1 = 0 ;
33530 int res1 = 0 ;
33531 PyObject *swig_obj[1] ;
33532
33533 if (!args) SWIG_fail;
33534 swig_obj[0] = args;
33535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33536 if (!SWIG_IsOK(res1)) {
33537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33538 }
33539 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 result = (arg1)->GetURL();
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 {
33547 #if wxUSE_UNICODE
33548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33549 #else
33550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33551 #endif
33552 }
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33560 PyObject *resultobj = 0;
33561 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33562 wxString *arg2 = 0 ;
33563 void *argp1 = 0 ;
33564 int res1 = 0 ;
33565 bool temp2 = false ;
33566 PyObject * obj0 = 0 ;
33567 PyObject * obj1 = 0 ;
33568 char * kwnames[] = {
33569 (char *) "self",(char *) "url", NULL
33570 };
33571
33572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33574 if (!SWIG_IsOK(res1)) {
33575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33576 }
33577 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33578 {
33579 arg2 = wxString_in_helper(obj1);
33580 if (arg2 == NULL) SWIG_fail;
33581 temp2 = true;
33582 }
33583 {
33584 PyThreadState* __tstate = wxPyBeginAllowThreads();
33585 (arg1)->SetURL((wxString const &)*arg2);
33586 wxPyEndAllowThreads(__tstate);
33587 if (PyErr_Occurred()) SWIG_fail;
33588 }
33589 resultobj = SWIG_Py_Void();
33590 {
33591 if (temp2)
33592 delete arg2;
33593 }
33594 return resultobj;
33595 fail:
33596 {
33597 if (temp2)
33598 delete arg2;
33599 }
33600 return NULL;
33601 }
33602
33603
33604 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33605 PyObject *obj;
33606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33607 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33608 return SWIG_Py_Void();
33609 }
33610
33611 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33612 return SWIG_Python_InitShadowInstance(args);
33613 }
33614
33615 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33616 PyObject *resultobj = 0;
33617 wxMetafileDataObject *result = 0 ;
33618
33619 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33620 {
33621 PyThreadState* __tstate = wxPyBeginAllowThreads();
33622 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33623 wxPyEndAllowThreads(__tstate);
33624 if (PyErr_Occurred()) SWIG_fail;
33625 }
33626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33627 return resultobj;
33628 fail:
33629 return NULL;
33630 }
33631
33632
33633 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33634 PyObject *obj;
33635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33636 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33637 return SWIG_Py_Void();
33638 }
33639
33640 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33641 return SWIG_Python_InitShadowInstance(args);
33642 }
33643
33644 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33645 PyObject *resultobj = 0;
33646 wxDragResult arg1 ;
33647 bool result;
33648 int val1 ;
33649 int ecode1 = 0 ;
33650 PyObject * obj0 = 0 ;
33651 char * kwnames[] = {
33652 (char *) "res", NULL
33653 };
33654
33655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33656 ecode1 = SWIG_AsVal_int(obj0, &val1);
33657 if (!SWIG_IsOK(ecode1)) {
33658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33659 }
33660 arg1 = static_cast< wxDragResult >(val1);
33661 {
33662 PyThreadState* __tstate = wxPyBeginAllowThreads();
33663 result = (bool)wxIsDragResultOk(arg1);
33664 wxPyEndAllowThreads(__tstate);
33665 if (PyErr_Occurred()) SWIG_fail;
33666 }
33667 {
33668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33669 }
33670 return resultobj;
33671 fail:
33672 return NULL;
33673 }
33674
33675
33676 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33677 PyObject *resultobj = 0;
33678 wxWindow *arg1 = (wxWindow *) 0 ;
33679 wxIcon const &arg2_defvalue = wxNullIcon ;
33680 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33681 wxIcon const &arg3_defvalue = wxNullIcon ;
33682 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33683 wxIcon const &arg4_defvalue = wxNullIcon ;
33684 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33685 wxPyDropSource *result = 0 ;
33686 void *argp1 = 0 ;
33687 int res1 = 0 ;
33688 void *argp2 = 0 ;
33689 int res2 = 0 ;
33690 void *argp3 = 0 ;
33691 int res3 = 0 ;
33692 void *argp4 = 0 ;
33693 int res4 = 0 ;
33694 PyObject * obj0 = 0 ;
33695 PyObject * obj1 = 0 ;
33696 PyObject * obj2 = 0 ;
33697 PyObject * obj3 = 0 ;
33698 char * kwnames[] = {
33699 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33700 };
33701
33702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33704 if (!SWIG_IsOK(res1)) {
33705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33706 }
33707 arg1 = reinterpret_cast< wxWindow * >(argp1);
33708 if (obj1) {
33709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33710 if (!SWIG_IsOK(res2)) {
33711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33712 }
33713 if (!argp2) {
33714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33715 }
33716 arg2 = reinterpret_cast< wxIcon * >(argp2);
33717 }
33718 if (obj2) {
33719 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33720 if (!SWIG_IsOK(res3)) {
33721 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33722 }
33723 if (!argp3) {
33724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33725 }
33726 arg3 = reinterpret_cast< wxIcon * >(argp3);
33727 }
33728 if (obj3) {
33729 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33730 if (!SWIG_IsOK(res4)) {
33731 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33732 }
33733 if (!argp4) {
33734 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33735 }
33736 arg4 = reinterpret_cast< wxIcon * >(argp4);
33737 }
33738 {
33739 PyThreadState* __tstate = wxPyBeginAllowThreads();
33740 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33741 wxPyEndAllowThreads(__tstate);
33742 if (PyErr_Occurred()) SWIG_fail;
33743 }
33744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33745 return resultobj;
33746 fail:
33747 return NULL;
33748 }
33749
33750
33751 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33752 PyObject *resultobj = 0;
33753 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33754 PyObject *arg2 = (PyObject *) 0 ;
33755 PyObject *arg3 = (PyObject *) 0 ;
33756 int arg4 = (int) 0 ;
33757 void *argp1 = 0 ;
33758 int res1 = 0 ;
33759 int val4 ;
33760 int ecode4 = 0 ;
33761 PyObject * obj0 = 0 ;
33762 PyObject * obj1 = 0 ;
33763 PyObject * obj2 = 0 ;
33764 PyObject * obj3 = 0 ;
33765 char * kwnames[] = {
33766 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33767 };
33768
33769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33771 if (!SWIG_IsOK(res1)) {
33772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33773 }
33774 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33775 arg2 = obj1;
33776 arg3 = obj2;
33777 if (obj3) {
33778 ecode4 = SWIG_AsVal_int(obj3, &val4);
33779 if (!SWIG_IsOK(ecode4)) {
33780 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33781 }
33782 arg4 = static_cast< int >(val4);
33783 }
33784 {
33785 PyThreadState* __tstate = wxPyBeginAllowThreads();
33786 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33787 wxPyEndAllowThreads(__tstate);
33788 if (PyErr_Occurred()) SWIG_fail;
33789 }
33790 resultobj = SWIG_Py_Void();
33791 return resultobj;
33792 fail:
33793 return NULL;
33794 }
33795
33796
33797 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33798 PyObject *resultobj = 0;
33799 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33800 void *argp1 = 0 ;
33801 int res1 = 0 ;
33802 PyObject *swig_obj[1] ;
33803
33804 if (!args) SWIG_fail;
33805 swig_obj[0] = args;
33806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33807 if (!SWIG_IsOK(res1)) {
33808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33809 }
33810 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33811 {
33812 PyThreadState* __tstate = wxPyBeginAllowThreads();
33813 delete arg1;
33814
33815 wxPyEndAllowThreads(__tstate);
33816 if (PyErr_Occurred()) SWIG_fail;
33817 }
33818 resultobj = SWIG_Py_Void();
33819 return resultobj;
33820 fail:
33821 return NULL;
33822 }
33823
33824
33825 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33826 PyObject *resultobj = 0;
33827 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33828 wxDataObject *arg2 = 0 ;
33829 void *argp1 = 0 ;
33830 int res1 = 0 ;
33831 void *argp2 = 0 ;
33832 int res2 = 0 ;
33833 PyObject * obj0 = 0 ;
33834 PyObject * obj1 = 0 ;
33835 char * kwnames[] = {
33836 (char *) "self",(char *) "data", NULL
33837 };
33838
33839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33841 if (!SWIG_IsOK(res1)) {
33842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33843 }
33844 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33845 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33846 if (!SWIG_IsOK(res2)) {
33847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33848 }
33849 if (!argp2) {
33850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33851 }
33852 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33853 {
33854 PyThreadState* __tstate = wxPyBeginAllowThreads();
33855 (arg1)->SetData(*arg2);
33856 wxPyEndAllowThreads(__tstate);
33857 if (PyErr_Occurred()) SWIG_fail;
33858 }
33859 resultobj = SWIG_Py_Void();
33860 return resultobj;
33861 fail:
33862 return NULL;
33863 }
33864
33865
33866 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33867 PyObject *resultobj = 0;
33868 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33869 wxDataObject *result = 0 ;
33870 void *argp1 = 0 ;
33871 int res1 = 0 ;
33872 PyObject *swig_obj[1] ;
33873
33874 if (!args) SWIG_fail;
33875 swig_obj[0] = args;
33876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33877 if (!SWIG_IsOK(res1)) {
33878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33879 }
33880 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33881 {
33882 PyThreadState* __tstate = wxPyBeginAllowThreads();
33883 result = (wxDataObject *)(arg1)->GetDataObject();
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33895 PyObject *resultobj = 0;
33896 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33897 wxDragResult arg2 ;
33898 wxCursor *arg3 = 0 ;
33899 void *argp1 = 0 ;
33900 int res1 = 0 ;
33901 int val2 ;
33902 int ecode2 = 0 ;
33903 void *argp3 = 0 ;
33904 int res3 = 0 ;
33905 PyObject * obj0 = 0 ;
33906 PyObject * obj1 = 0 ;
33907 PyObject * obj2 = 0 ;
33908 char * kwnames[] = {
33909 (char *) "self",(char *) "res",(char *) "cursor", NULL
33910 };
33911
33912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33914 if (!SWIG_IsOK(res1)) {
33915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33916 }
33917 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33918 ecode2 = SWIG_AsVal_int(obj1, &val2);
33919 if (!SWIG_IsOK(ecode2)) {
33920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33921 }
33922 arg2 = static_cast< wxDragResult >(val2);
33923 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33924 if (!SWIG_IsOK(res3)) {
33925 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33926 }
33927 if (!argp3) {
33928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33929 }
33930 arg3 = reinterpret_cast< wxCursor * >(argp3);
33931 {
33932 PyThreadState* __tstate = wxPyBeginAllowThreads();
33933 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33934 wxPyEndAllowThreads(__tstate);
33935 if (PyErr_Occurred()) SWIG_fail;
33936 }
33937 resultobj = SWIG_Py_Void();
33938 return resultobj;
33939 fail:
33940 return NULL;
33941 }
33942
33943
33944 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33945 PyObject *resultobj = 0;
33946 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33947 int arg2 = (int) wxDrag_CopyOnly ;
33948 wxDragResult result;
33949 void *argp1 = 0 ;
33950 int res1 = 0 ;
33951 int val2 ;
33952 int ecode2 = 0 ;
33953 PyObject * obj0 = 0 ;
33954 PyObject * obj1 = 0 ;
33955 char * kwnames[] = {
33956 (char *) "self",(char *) "flags", NULL
33957 };
33958
33959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33961 if (!SWIG_IsOK(res1)) {
33962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33963 }
33964 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33965 if (obj1) {
33966 ecode2 = SWIG_AsVal_int(obj1, &val2);
33967 if (!SWIG_IsOK(ecode2)) {
33968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33969 }
33970 arg2 = static_cast< int >(val2);
33971 }
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33975 wxPyEndAllowThreads(__tstate);
33976 if (PyErr_Occurred()) SWIG_fail;
33977 }
33978 resultobj = SWIG_From_int(static_cast< int >(result));
33979 return resultobj;
33980 fail:
33981 return NULL;
33982 }
33983
33984
33985 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33986 PyObject *resultobj = 0;
33987 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33988 wxDragResult arg2 ;
33989 bool result;
33990 void *argp1 = 0 ;
33991 int res1 = 0 ;
33992 int val2 ;
33993 int ecode2 = 0 ;
33994 PyObject * obj0 = 0 ;
33995 PyObject * obj1 = 0 ;
33996 char * kwnames[] = {
33997 (char *) "self",(char *) "effect", NULL
33998 };
33999
34000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34002 if (!SWIG_IsOK(res1)) {
34003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34004 }
34005 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34006 ecode2 = SWIG_AsVal_int(obj1, &val2);
34007 if (!SWIG_IsOK(ecode2)) {
34008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34009 }
34010 arg2 = static_cast< wxDragResult >(val2);
34011 {
34012 PyThreadState* __tstate = wxPyBeginAllowThreads();
34013 result = (bool)(arg1)->GiveFeedback(arg2);
34014 wxPyEndAllowThreads(__tstate);
34015 if (PyErr_Occurred()) SWIG_fail;
34016 }
34017 {
34018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34019 }
34020 return resultobj;
34021 fail:
34022 return NULL;
34023 }
34024
34025
34026 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34027 PyObject *obj;
34028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34029 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34030 return SWIG_Py_Void();
34031 }
34032
34033 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34034 return SWIG_Python_InitShadowInstance(args);
34035 }
34036
34037 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34038 PyObject *resultobj = 0;
34039 wxDataObject *arg1 = (wxDataObject *) NULL ;
34040 wxPyDropTarget *result = 0 ;
34041 int res1 = 0 ;
34042 PyObject * obj0 = 0 ;
34043 char * kwnames[] = {
34044 (char *) "dataObject", NULL
34045 };
34046
34047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34048 if (obj0) {
34049 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34050 if (!SWIG_IsOK(res1)) {
34051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34052 }
34053 }
34054 {
34055 PyThreadState* __tstate = wxPyBeginAllowThreads();
34056 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34057 wxPyEndAllowThreads(__tstate);
34058 if (PyErr_Occurred()) SWIG_fail;
34059 }
34060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34061 return resultobj;
34062 fail:
34063 return NULL;
34064 }
34065
34066
34067 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34068 PyObject *resultobj = 0;
34069 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34070 PyObject *arg2 = (PyObject *) 0 ;
34071 PyObject *arg3 = (PyObject *) 0 ;
34072 void *argp1 = 0 ;
34073 int res1 = 0 ;
34074 PyObject * obj0 = 0 ;
34075 PyObject * obj1 = 0 ;
34076 PyObject * obj2 = 0 ;
34077 char * kwnames[] = {
34078 (char *) "self",(char *) "self",(char *) "_class", NULL
34079 };
34080
34081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34083 if (!SWIG_IsOK(res1)) {
34084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34085 }
34086 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34087 arg2 = obj1;
34088 arg3 = obj2;
34089 {
34090 PyThreadState* __tstate = wxPyBeginAllowThreads();
34091 (arg1)->_setCallbackInfo(arg2,arg3);
34092 wxPyEndAllowThreads(__tstate);
34093 if (PyErr_Occurred()) SWIG_fail;
34094 }
34095 resultobj = SWIG_Py_Void();
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34103 PyObject *resultobj = 0;
34104 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34105 void *argp1 = 0 ;
34106 int res1 = 0 ;
34107 PyObject *swig_obj[1] ;
34108
34109 if (!args) SWIG_fail;
34110 swig_obj[0] = args;
34111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34112 if (!SWIG_IsOK(res1)) {
34113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34114 }
34115 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34116 {
34117 PyThreadState* __tstate = wxPyBeginAllowThreads();
34118 delete arg1;
34119
34120 wxPyEndAllowThreads(__tstate);
34121 if (PyErr_Occurred()) SWIG_fail;
34122 }
34123 resultobj = SWIG_Py_Void();
34124 return resultobj;
34125 fail:
34126 return NULL;
34127 }
34128
34129
34130 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34131 PyObject *resultobj = 0;
34132 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34133 wxDataObject *result = 0 ;
34134 void *argp1 = 0 ;
34135 int res1 = 0 ;
34136 PyObject *swig_obj[1] ;
34137
34138 if (!args) SWIG_fail;
34139 swig_obj[0] = args;
34140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34141 if (!SWIG_IsOK(res1)) {
34142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34143 }
34144 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 result = (wxDataObject *)(arg1)->GetDataObject();
34148 wxPyEndAllowThreads(__tstate);
34149 if (PyErr_Occurred()) SWIG_fail;
34150 }
34151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34152 return resultobj;
34153 fail:
34154 return NULL;
34155 }
34156
34157
34158 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34159 PyObject *resultobj = 0;
34160 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34161 wxDataObject *arg2 = (wxDataObject *) 0 ;
34162 void *argp1 = 0 ;
34163 int res1 = 0 ;
34164 int res2 = 0 ;
34165 PyObject * obj0 = 0 ;
34166 PyObject * obj1 = 0 ;
34167 char * kwnames[] = {
34168 (char *) "self",(char *) "dataObject", NULL
34169 };
34170
34171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34173 if (!SWIG_IsOK(res1)) {
34174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34175 }
34176 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34177 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34178 if (!SWIG_IsOK(res2)) {
34179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34180 }
34181 {
34182 PyThreadState* __tstate = wxPyBeginAllowThreads();
34183 (arg1)->SetDataObject(arg2);
34184 wxPyEndAllowThreads(__tstate);
34185 if (PyErr_Occurred()) SWIG_fail;
34186 }
34187 resultobj = SWIG_Py_Void();
34188 return resultobj;
34189 fail:
34190 return NULL;
34191 }
34192
34193
34194 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34195 PyObject *resultobj = 0;
34196 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34197 int arg2 ;
34198 int arg3 ;
34199 wxDragResult arg4 ;
34200 wxDragResult result;
34201 void *argp1 = 0 ;
34202 int res1 = 0 ;
34203 int val2 ;
34204 int ecode2 = 0 ;
34205 int val3 ;
34206 int ecode3 = 0 ;
34207 int val4 ;
34208 int ecode4 = 0 ;
34209 PyObject * obj0 = 0 ;
34210 PyObject * obj1 = 0 ;
34211 PyObject * obj2 = 0 ;
34212 PyObject * obj3 = 0 ;
34213 char * kwnames[] = {
34214 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34215 };
34216
34217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34219 if (!SWIG_IsOK(res1)) {
34220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34221 }
34222 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34223 ecode2 = SWIG_AsVal_int(obj1, &val2);
34224 if (!SWIG_IsOK(ecode2)) {
34225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34226 }
34227 arg2 = static_cast< int >(val2);
34228 ecode3 = SWIG_AsVal_int(obj2, &val3);
34229 if (!SWIG_IsOK(ecode3)) {
34230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34231 }
34232 arg3 = static_cast< int >(val3);
34233 ecode4 = SWIG_AsVal_int(obj3, &val4);
34234 if (!SWIG_IsOK(ecode4)) {
34235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34236 }
34237 arg4 = static_cast< wxDragResult >(val4);
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34241 wxPyEndAllowThreads(__tstate);
34242 if (PyErr_Occurred()) SWIG_fail;
34243 }
34244 resultobj = SWIG_From_int(static_cast< int >(result));
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34252 PyObject *resultobj = 0;
34253 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34254 int arg2 ;
34255 int arg3 ;
34256 wxDragResult arg4 ;
34257 wxDragResult result;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 int val2 ;
34261 int ecode2 = 0 ;
34262 int val3 ;
34263 int ecode3 = 0 ;
34264 int val4 ;
34265 int ecode4 = 0 ;
34266 PyObject * obj0 = 0 ;
34267 PyObject * obj1 = 0 ;
34268 PyObject * obj2 = 0 ;
34269 PyObject * obj3 = 0 ;
34270 char * kwnames[] = {
34271 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34272 };
34273
34274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34276 if (!SWIG_IsOK(res1)) {
34277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34278 }
34279 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34280 ecode2 = SWIG_AsVal_int(obj1, &val2);
34281 if (!SWIG_IsOK(ecode2)) {
34282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34283 }
34284 arg2 = static_cast< int >(val2);
34285 ecode3 = SWIG_AsVal_int(obj2, &val3);
34286 if (!SWIG_IsOK(ecode3)) {
34287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34288 }
34289 arg3 = static_cast< int >(val3);
34290 ecode4 = SWIG_AsVal_int(obj3, &val4);
34291 if (!SWIG_IsOK(ecode4)) {
34292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34293 }
34294 arg4 = static_cast< wxDragResult >(val4);
34295 {
34296 PyThreadState* __tstate = wxPyBeginAllowThreads();
34297 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34298 wxPyEndAllowThreads(__tstate);
34299 if (PyErr_Occurred()) SWIG_fail;
34300 }
34301 resultobj = SWIG_From_int(static_cast< int >(result));
34302 return resultobj;
34303 fail:
34304 return NULL;
34305 }
34306
34307
34308 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34309 PyObject *resultobj = 0;
34310 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34311 void *argp1 = 0 ;
34312 int res1 = 0 ;
34313 PyObject *swig_obj[1] ;
34314
34315 if (!args) SWIG_fail;
34316 swig_obj[0] = args;
34317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34318 if (!SWIG_IsOK(res1)) {
34319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34320 }
34321 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34322 {
34323 PyThreadState* __tstate = wxPyBeginAllowThreads();
34324 (arg1)->OnLeave();
34325 wxPyEndAllowThreads(__tstate);
34326 if (PyErr_Occurred()) SWIG_fail;
34327 }
34328 resultobj = SWIG_Py_Void();
34329 return resultobj;
34330 fail:
34331 return NULL;
34332 }
34333
34334
34335 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34336 PyObject *resultobj = 0;
34337 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34338 int arg2 ;
34339 int arg3 ;
34340 bool result;
34341 void *argp1 = 0 ;
34342 int res1 = 0 ;
34343 int val2 ;
34344 int ecode2 = 0 ;
34345 int val3 ;
34346 int ecode3 = 0 ;
34347 PyObject * obj0 = 0 ;
34348 PyObject * obj1 = 0 ;
34349 PyObject * obj2 = 0 ;
34350 char * kwnames[] = {
34351 (char *) "self",(char *) "x",(char *) "y", NULL
34352 };
34353
34354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34356 if (!SWIG_IsOK(res1)) {
34357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34358 }
34359 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34360 ecode2 = SWIG_AsVal_int(obj1, &val2);
34361 if (!SWIG_IsOK(ecode2)) {
34362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34363 }
34364 arg2 = static_cast< int >(val2);
34365 ecode3 = SWIG_AsVal_int(obj2, &val3);
34366 if (!SWIG_IsOK(ecode3)) {
34367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34368 }
34369 arg3 = static_cast< int >(val3);
34370 {
34371 PyThreadState* __tstate = wxPyBeginAllowThreads();
34372 result = (bool)(arg1)->OnDrop(arg2,arg3);
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 {
34377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34378 }
34379 return resultobj;
34380 fail:
34381 return NULL;
34382 }
34383
34384
34385 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34386 PyObject *resultobj = 0;
34387 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34388 bool result;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 PyObject *swig_obj[1] ;
34392
34393 if (!args) SWIG_fail;
34394 swig_obj[0] = args;
34395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34398 }
34399 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34400 {
34401 PyThreadState* __tstate = wxPyBeginAllowThreads();
34402 result = (bool)(arg1)->GetData();
34403 wxPyEndAllowThreads(__tstate);
34404 if (PyErr_Occurred()) SWIG_fail;
34405 }
34406 {
34407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34408 }
34409 return resultobj;
34410 fail:
34411 return NULL;
34412 }
34413
34414
34415 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34416 PyObject *resultobj = 0;
34417 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34418 wxDragResult arg2 ;
34419 void *argp1 = 0 ;
34420 int res1 = 0 ;
34421 int val2 ;
34422 int ecode2 = 0 ;
34423 PyObject * obj0 = 0 ;
34424 PyObject * obj1 = 0 ;
34425 char * kwnames[] = {
34426 (char *) "self",(char *) "action", NULL
34427 };
34428
34429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34431 if (!SWIG_IsOK(res1)) {
34432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34433 }
34434 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34435 ecode2 = SWIG_AsVal_int(obj1, &val2);
34436 if (!SWIG_IsOK(ecode2)) {
34437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34438 }
34439 arg2 = static_cast< wxDragResult >(val2);
34440 {
34441 PyThreadState* __tstate = wxPyBeginAllowThreads();
34442 (arg1)->SetDefaultAction(arg2);
34443 wxPyEndAllowThreads(__tstate);
34444 if (PyErr_Occurred()) SWIG_fail;
34445 }
34446 resultobj = SWIG_Py_Void();
34447 return resultobj;
34448 fail:
34449 return NULL;
34450 }
34451
34452
34453 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34454 PyObject *resultobj = 0;
34455 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34456 wxDragResult result;
34457 void *argp1 = 0 ;
34458 int res1 = 0 ;
34459 PyObject *swig_obj[1] ;
34460
34461 if (!args) SWIG_fail;
34462 swig_obj[0] = args;
34463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34464 if (!SWIG_IsOK(res1)) {
34465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34466 }
34467 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34468 {
34469 PyThreadState* __tstate = wxPyBeginAllowThreads();
34470 result = (wxDragResult)(arg1)->GetDefaultAction();
34471 wxPyEndAllowThreads(__tstate);
34472 if (PyErr_Occurred()) SWIG_fail;
34473 }
34474 resultobj = SWIG_From_int(static_cast< int >(result));
34475 return resultobj;
34476 fail:
34477 return NULL;
34478 }
34479
34480
34481 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34482 PyObject *obj;
34483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34484 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34485 return SWIG_Py_Void();
34486 }
34487
34488 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34489 return SWIG_Python_InitShadowInstance(args);
34490 }
34491
34492 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34493 PyObject *resultobj = 0;
34494 wxPyTextDropTarget *result = 0 ;
34495
34496 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34497 {
34498 PyThreadState* __tstate = wxPyBeginAllowThreads();
34499 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34500 wxPyEndAllowThreads(__tstate);
34501 if (PyErr_Occurred()) SWIG_fail;
34502 }
34503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34504 return resultobj;
34505 fail:
34506 return NULL;
34507 }
34508
34509
34510 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34511 PyObject *resultobj = 0;
34512 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34513 PyObject *arg2 = (PyObject *) 0 ;
34514 PyObject *arg3 = (PyObject *) 0 ;
34515 void *argp1 = 0 ;
34516 int res1 = 0 ;
34517 PyObject * obj0 = 0 ;
34518 PyObject * obj1 = 0 ;
34519 PyObject * obj2 = 0 ;
34520 char * kwnames[] = {
34521 (char *) "self",(char *) "self",(char *) "_class", NULL
34522 };
34523
34524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34526 if (!SWIG_IsOK(res1)) {
34527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34528 }
34529 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34530 arg2 = obj1;
34531 arg3 = obj2;
34532 {
34533 PyThreadState* __tstate = wxPyBeginAllowThreads();
34534 (arg1)->_setCallbackInfo(arg2,arg3);
34535 wxPyEndAllowThreads(__tstate);
34536 if (PyErr_Occurred()) SWIG_fail;
34537 }
34538 resultobj = SWIG_Py_Void();
34539 return resultobj;
34540 fail:
34541 return NULL;
34542 }
34543
34544
34545 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34546 PyObject *resultobj = 0;
34547 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34548 int arg2 ;
34549 int arg3 ;
34550 wxString *arg4 = 0 ;
34551 bool result;
34552 void *argp1 = 0 ;
34553 int res1 = 0 ;
34554 int val2 ;
34555 int ecode2 = 0 ;
34556 int val3 ;
34557 int ecode3 = 0 ;
34558 bool temp4 = false ;
34559 PyObject * obj0 = 0 ;
34560 PyObject * obj1 = 0 ;
34561 PyObject * obj2 = 0 ;
34562 PyObject * obj3 = 0 ;
34563 char * kwnames[] = {
34564 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34565 };
34566
34567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34569 if (!SWIG_IsOK(res1)) {
34570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34571 }
34572 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34573 ecode2 = SWIG_AsVal_int(obj1, &val2);
34574 if (!SWIG_IsOK(ecode2)) {
34575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34576 }
34577 arg2 = static_cast< int >(val2);
34578 ecode3 = SWIG_AsVal_int(obj2, &val3);
34579 if (!SWIG_IsOK(ecode3)) {
34580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34581 }
34582 arg3 = static_cast< int >(val3);
34583 {
34584 arg4 = wxString_in_helper(obj3);
34585 if (arg4 == NULL) SWIG_fail;
34586 temp4 = true;
34587 }
34588 {
34589 PyThreadState* __tstate = wxPyBeginAllowThreads();
34590 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34591 wxPyEndAllowThreads(__tstate);
34592 if (PyErr_Occurred()) SWIG_fail;
34593 }
34594 {
34595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34596 }
34597 {
34598 if (temp4)
34599 delete arg4;
34600 }
34601 return resultobj;
34602 fail:
34603 {
34604 if (temp4)
34605 delete arg4;
34606 }
34607 return NULL;
34608 }
34609
34610
34611 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34612 PyObject *resultobj = 0;
34613 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34614 int arg2 ;
34615 int arg3 ;
34616 wxDragResult arg4 ;
34617 wxDragResult result;
34618 void *argp1 = 0 ;
34619 int res1 = 0 ;
34620 int val2 ;
34621 int ecode2 = 0 ;
34622 int val3 ;
34623 int ecode3 = 0 ;
34624 int val4 ;
34625 int ecode4 = 0 ;
34626 PyObject * obj0 = 0 ;
34627 PyObject * obj1 = 0 ;
34628 PyObject * obj2 = 0 ;
34629 PyObject * obj3 = 0 ;
34630 char * kwnames[] = {
34631 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34632 };
34633
34634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34636 if (!SWIG_IsOK(res1)) {
34637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34638 }
34639 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34640 ecode2 = SWIG_AsVal_int(obj1, &val2);
34641 if (!SWIG_IsOK(ecode2)) {
34642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34643 }
34644 arg2 = static_cast< int >(val2);
34645 ecode3 = SWIG_AsVal_int(obj2, &val3);
34646 if (!SWIG_IsOK(ecode3)) {
34647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34648 }
34649 arg3 = static_cast< int >(val3);
34650 ecode4 = SWIG_AsVal_int(obj3, &val4);
34651 if (!SWIG_IsOK(ecode4)) {
34652 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34653 }
34654 arg4 = static_cast< wxDragResult >(val4);
34655 {
34656 PyThreadState* __tstate = wxPyBeginAllowThreads();
34657 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34658 wxPyEndAllowThreads(__tstate);
34659 if (PyErr_Occurred()) SWIG_fail;
34660 }
34661 resultobj = SWIG_From_int(static_cast< int >(result));
34662 return resultobj;
34663 fail:
34664 return NULL;
34665 }
34666
34667
34668 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34669 PyObject *resultobj = 0;
34670 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34671 int arg2 ;
34672 int arg3 ;
34673 wxDragResult arg4 ;
34674 wxDragResult result;
34675 void *argp1 = 0 ;
34676 int res1 = 0 ;
34677 int val2 ;
34678 int ecode2 = 0 ;
34679 int val3 ;
34680 int ecode3 = 0 ;
34681 int val4 ;
34682 int ecode4 = 0 ;
34683 PyObject * obj0 = 0 ;
34684 PyObject * obj1 = 0 ;
34685 PyObject * obj2 = 0 ;
34686 PyObject * obj3 = 0 ;
34687 char * kwnames[] = {
34688 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34689 };
34690
34691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34693 if (!SWIG_IsOK(res1)) {
34694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34695 }
34696 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34697 ecode2 = SWIG_AsVal_int(obj1, &val2);
34698 if (!SWIG_IsOK(ecode2)) {
34699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34700 }
34701 arg2 = static_cast< int >(val2);
34702 ecode3 = SWIG_AsVal_int(obj2, &val3);
34703 if (!SWIG_IsOK(ecode3)) {
34704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34705 }
34706 arg3 = static_cast< int >(val3);
34707 ecode4 = SWIG_AsVal_int(obj3, &val4);
34708 if (!SWIG_IsOK(ecode4)) {
34709 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34710 }
34711 arg4 = static_cast< wxDragResult >(val4);
34712 {
34713 PyThreadState* __tstate = wxPyBeginAllowThreads();
34714 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34715 wxPyEndAllowThreads(__tstate);
34716 if (PyErr_Occurred()) SWIG_fail;
34717 }
34718 resultobj = SWIG_From_int(static_cast< int >(result));
34719 return resultobj;
34720 fail:
34721 return NULL;
34722 }
34723
34724
34725 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34726 PyObject *resultobj = 0;
34727 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34728 void *argp1 = 0 ;
34729 int res1 = 0 ;
34730 PyObject *swig_obj[1] ;
34731
34732 if (!args) SWIG_fail;
34733 swig_obj[0] = args;
34734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34735 if (!SWIG_IsOK(res1)) {
34736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34737 }
34738 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34739 {
34740 PyThreadState* __tstate = wxPyBeginAllowThreads();
34741 (arg1)->OnLeave();
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 resultobj = SWIG_Py_Void();
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34753 PyObject *resultobj = 0;
34754 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34755 int arg2 ;
34756 int arg3 ;
34757 bool result;
34758 void *argp1 = 0 ;
34759 int res1 = 0 ;
34760 int val2 ;
34761 int ecode2 = 0 ;
34762 int val3 ;
34763 int ecode3 = 0 ;
34764 PyObject * obj0 = 0 ;
34765 PyObject * obj1 = 0 ;
34766 PyObject * obj2 = 0 ;
34767 char * kwnames[] = {
34768 (char *) "self",(char *) "x",(char *) "y", NULL
34769 };
34770
34771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34773 if (!SWIG_IsOK(res1)) {
34774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34775 }
34776 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34777 ecode2 = SWIG_AsVal_int(obj1, &val2);
34778 if (!SWIG_IsOK(ecode2)) {
34779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34780 }
34781 arg2 = static_cast< int >(val2);
34782 ecode3 = SWIG_AsVal_int(obj2, &val3);
34783 if (!SWIG_IsOK(ecode3)) {
34784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34785 }
34786 arg3 = static_cast< int >(val3);
34787 {
34788 PyThreadState* __tstate = wxPyBeginAllowThreads();
34789 result = (bool)(arg1)->OnDrop(arg2,arg3);
34790 wxPyEndAllowThreads(__tstate);
34791 if (PyErr_Occurred()) SWIG_fail;
34792 }
34793 {
34794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34795 }
34796 return resultobj;
34797 fail:
34798 return NULL;
34799 }
34800
34801
34802 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34803 PyObject *resultobj = 0;
34804 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34805 int arg2 ;
34806 int arg3 ;
34807 wxDragResult arg4 ;
34808 wxDragResult result;
34809 void *argp1 = 0 ;
34810 int res1 = 0 ;
34811 int val2 ;
34812 int ecode2 = 0 ;
34813 int val3 ;
34814 int ecode3 = 0 ;
34815 int val4 ;
34816 int ecode4 = 0 ;
34817 PyObject * obj0 = 0 ;
34818 PyObject * obj1 = 0 ;
34819 PyObject * obj2 = 0 ;
34820 PyObject * obj3 = 0 ;
34821 char * kwnames[] = {
34822 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34823 };
34824
34825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34827 if (!SWIG_IsOK(res1)) {
34828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34829 }
34830 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34831 ecode2 = SWIG_AsVal_int(obj1, &val2);
34832 if (!SWIG_IsOK(ecode2)) {
34833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34834 }
34835 arg2 = static_cast< int >(val2);
34836 ecode3 = SWIG_AsVal_int(obj2, &val3);
34837 if (!SWIG_IsOK(ecode3)) {
34838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34839 }
34840 arg3 = static_cast< int >(val3);
34841 ecode4 = SWIG_AsVal_int(obj3, &val4);
34842 if (!SWIG_IsOK(ecode4)) {
34843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34844 }
34845 arg4 = static_cast< wxDragResult >(val4);
34846 {
34847 PyThreadState* __tstate = wxPyBeginAllowThreads();
34848 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34849 wxPyEndAllowThreads(__tstate);
34850 if (PyErr_Occurred()) SWIG_fail;
34851 }
34852 resultobj = SWIG_From_int(static_cast< int >(result));
34853 return resultobj;
34854 fail:
34855 return NULL;
34856 }
34857
34858
34859 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34860 PyObject *obj;
34861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34862 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34863 return SWIG_Py_Void();
34864 }
34865
34866 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34867 return SWIG_Python_InitShadowInstance(args);
34868 }
34869
34870 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34871 PyObject *resultobj = 0;
34872 wxPyFileDropTarget *result = 0 ;
34873
34874 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34875 {
34876 PyThreadState* __tstate = wxPyBeginAllowThreads();
34877 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34878 wxPyEndAllowThreads(__tstate);
34879 if (PyErr_Occurred()) SWIG_fail;
34880 }
34881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34882 return resultobj;
34883 fail:
34884 return NULL;
34885 }
34886
34887
34888 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34889 PyObject *resultobj = 0;
34890 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34891 PyObject *arg2 = (PyObject *) 0 ;
34892 PyObject *arg3 = (PyObject *) 0 ;
34893 void *argp1 = 0 ;
34894 int res1 = 0 ;
34895 PyObject * obj0 = 0 ;
34896 PyObject * obj1 = 0 ;
34897 PyObject * obj2 = 0 ;
34898 char * kwnames[] = {
34899 (char *) "self",(char *) "self",(char *) "_class", NULL
34900 };
34901
34902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34904 if (!SWIG_IsOK(res1)) {
34905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34906 }
34907 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34908 arg2 = obj1;
34909 arg3 = obj2;
34910 {
34911 PyThreadState* __tstate = wxPyBeginAllowThreads();
34912 (arg1)->_setCallbackInfo(arg2,arg3);
34913 wxPyEndAllowThreads(__tstate);
34914 if (PyErr_Occurred()) SWIG_fail;
34915 }
34916 resultobj = SWIG_Py_Void();
34917 return resultobj;
34918 fail:
34919 return NULL;
34920 }
34921
34922
34923 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34924 PyObject *resultobj = 0;
34925 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34926 int arg2 ;
34927 int arg3 ;
34928 wxArrayString *arg4 = 0 ;
34929 bool result;
34930 void *argp1 = 0 ;
34931 int res1 = 0 ;
34932 int val2 ;
34933 int ecode2 = 0 ;
34934 int val3 ;
34935 int ecode3 = 0 ;
34936 bool temp4 = false ;
34937 PyObject * obj0 = 0 ;
34938 PyObject * obj1 = 0 ;
34939 PyObject * obj2 = 0 ;
34940 PyObject * obj3 = 0 ;
34941 char * kwnames[] = {
34942 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34943 };
34944
34945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34947 if (!SWIG_IsOK(res1)) {
34948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34949 }
34950 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34951 ecode2 = SWIG_AsVal_int(obj1, &val2);
34952 if (!SWIG_IsOK(ecode2)) {
34953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34954 }
34955 arg2 = static_cast< int >(val2);
34956 ecode3 = SWIG_AsVal_int(obj2, &val3);
34957 if (!SWIG_IsOK(ecode3)) {
34958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34959 }
34960 arg3 = static_cast< int >(val3);
34961 {
34962 if (! PySequence_Check(obj3)) {
34963 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34964 SWIG_fail;
34965 }
34966 arg4 = new wxArrayString;
34967 temp4 = true;
34968 int i, len=PySequence_Length(obj3);
34969 for (i=0; i<len; i++) {
34970 PyObject* item = PySequence_GetItem(obj3, i);
34971 wxString* s = wxString_in_helper(item);
34972 if (PyErr_Occurred()) SWIG_fail;
34973 arg4->Add(*s);
34974 delete s;
34975 Py_DECREF(item);
34976 }
34977 }
34978 {
34979 PyThreadState* __tstate = wxPyBeginAllowThreads();
34980 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34981 wxPyEndAllowThreads(__tstate);
34982 if (PyErr_Occurred()) SWIG_fail;
34983 }
34984 {
34985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34986 }
34987 {
34988 if (temp4) delete arg4;
34989 }
34990 return resultobj;
34991 fail:
34992 {
34993 if (temp4) delete arg4;
34994 }
34995 return NULL;
34996 }
34997
34998
34999 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35000 PyObject *resultobj = 0;
35001 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35002 int arg2 ;
35003 int arg3 ;
35004 wxDragResult arg4 ;
35005 wxDragResult result;
35006 void *argp1 = 0 ;
35007 int res1 = 0 ;
35008 int val2 ;
35009 int ecode2 = 0 ;
35010 int val3 ;
35011 int ecode3 = 0 ;
35012 int val4 ;
35013 int ecode4 = 0 ;
35014 PyObject * obj0 = 0 ;
35015 PyObject * obj1 = 0 ;
35016 PyObject * obj2 = 0 ;
35017 PyObject * obj3 = 0 ;
35018 char * kwnames[] = {
35019 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35020 };
35021
35022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35024 if (!SWIG_IsOK(res1)) {
35025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35026 }
35027 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35028 ecode2 = SWIG_AsVal_int(obj1, &val2);
35029 if (!SWIG_IsOK(ecode2)) {
35030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35031 }
35032 arg2 = static_cast< int >(val2);
35033 ecode3 = SWIG_AsVal_int(obj2, &val3);
35034 if (!SWIG_IsOK(ecode3)) {
35035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35036 }
35037 arg3 = static_cast< int >(val3);
35038 ecode4 = SWIG_AsVal_int(obj3, &val4);
35039 if (!SWIG_IsOK(ecode4)) {
35040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35041 }
35042 arg4 = static_cast< wxDragResult >(val4);
35043 {
35044 PyThreadState* __tstate = wxPyBeginAllowThreads();
35045 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35046 wxPyEndAllowThreads(__tstate);
35047 if (PyErr_Occurred()) SWIG_fail;
35048 }
35049 resultobj = SWIG_From_int(static_cast< int >(result));
35050 return resultobj;
35051 fail:
35052 return NULL;
35053 }
35054
35055
35056 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35057 PyObject *resultobj = 0;
35058 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35059 int arg2 ;
35060 int arg3 ;
35061 wxDragResult arg4 ;
35062 wxDragResult result;
35063 void *argp1 = 0 ;
35064 int res1 = 0 ;
35065 int val2 ;
35066 int ecode2 = 0 ;
35067 int val3 ;
35068 int ecode3 = 0 ;
35069 int val4 ;
35070 int ecode4 = 0 ;
35071 PyObject * obj0 = 0 ;
35072 PyObject * obj1 = 0 ;
35073 PyObject * obj2 = 0 ;
35074 PyObject * obj3 = 0 ;
35075 char * kwnames[] = {
35076 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35077 };
35078
35079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35081 if (!SWIG_IsOK(res1)) {
35082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35083 }
35084 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35085 ecode2 = SWIG_AsVal_int(obj1, &val2);
35086 if (!SWIG_IsOK(ecode2)) {
35087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35088 }
35089 arg2 = static_cast< int >(val2);
35090 ecode3 = SWIG_AsVal_int(obj2, &val3);
35091 if (!SWIG_IsOK(ecode3)) {
35092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35093 }
35094 arg3 = static_cast< int >(val3);
35095 ecode4 = SWIG_AsVal_int(obj3, &val4);
35096 if (!SWIG_IsOK(ecode4)) {
35097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35098 }
35099 arg4 = static_cast< wxDragResult >(val4);
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 resultobj = SWIG_From_int(static_cast< int >(result));
35107 return resultobj;
35108 fail:
35109 return NULL;
35110 }
35111
35112
35113 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35114 PyObject *resultobj = 0;
35115 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35116 void *argp1 = 0 ;
35117 int res1 = 0 ;
35118 PyObject *swig_obj[1] ;
35119
35120 if (!args) SWIG_fail;
35121 swig_obj[0] = args;
35122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35123 if (!SWIG_IsOK(res1)) {
35124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35125 }
35126 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35127 {
35128 PyThreadState* __tstate = wxPyBeginAllowThreads();
35129 (arg1)->OnLeave();
35130 wxPyEndAllowThreads(__tstate);
35131 if (PyErr_Occurred()) SWIG_fail;
35132 }
35133 resultobj = SWIG_Py_Void();
35134 return resultobj;
35135 fail:
35136 return NULL;
35137 }
35138
35139
35140 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35141 PyObject *resultobj = 0;
35142 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35143 int arg2 ;
35144 int arg3 ;
35145 bool result;
35146 void *argp1 = 0 ;
35147 int res1 = 0 ;
35148 int val2 ;
35149 int ecode2 = 0 ;
35150 int val3 ;
35151 int ecode3 = 0 ;
35152 PyObject * obj0 = 0 ;
35153 PyObject * obj1 = 0 ;
35154 PyObject * obj2 = 0 ;
35155 char * kwnames[] = {
35156 (char *) "self",(char *) "x",(char *) "y", NULL
35157 };
35158
35159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35161 if (!SWIG_IsOK(res1)) {
35162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35163 }
35164 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35165 ecode2 = SWIG_AsVal_int(obj1, &val2);
35166 if (!SWIG_IsOK(ecode2)) {
35167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35168 }
35169 arg2 = static_cast< int >(val2);
35170 ecode3 = SWIG_AsVal_int(obj2, &val3);
35171 if (!SWIG_IsOK(ecode3)) {
35172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35173 }
35174 arg3 = static_cast< int >(val3);
35175 {
35176 PyThreadState* __tstate = wxPyBeginAllowThreads();
35177 result = (bool)(arg1)->OnDrop(arg2,arg3);
35178 wxPyEndAllowThreads(__tstate);
35179 if (PyErr_Occurred()) SWIG_fail;
35180 }
35181 {
35182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35183 }
35184 return resultobj;
35185 fail:
35186 return NULL;
35187 }
35188
35189
35190 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35191 PyObject *resultobj = 0;
35192 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35193 int arg2 ;
35194 int arg3 ;
35195 wxDragResult arg4 ;
35196 wxDragResult result;
35197 void *argp1 = 0 ;
35198 int res1 = 0 ;
35199 int val2 ;
35200 int ecode2 = 0 ;
35201 int val3 ;
35202 int ecode3 = 0 ;
35203 int val4 ;
35204 int ecode4 = 0 ;
35205 PyObject * obj0 = 0 ;
35206 PyObject * obj1 = 0 ;
35207 PyObject * obj2 = 0 ;
35208 PyObject * obj3 = 0 ;
35209 char * kwnames[] = {
35210 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35211 };
35212
35213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35215 if (!SWIG_IsOK(res1)) {
35216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35217 }
35218 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35219 ecode2 = SWIG_AsVal_int(obj1, &val2);
35220 if (!SWIG_IsOK(ecode2)) {
35221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35222 }
35223 arg2 = static_cast< int >(val2);
35224 ecode3 = SWIG_AsVal_int(obj2, &val3);
35225 if (!SWIG_IsOK(ecode3)) {
35226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35227 }
35228 arg3 = static_cast< int >(val3);
35229 ecode4 = SWIG_AsVal_int(obj3, &val4);
35230 if (!SWIG_IsOK(ecode4)) {
35231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35232 }
35233 arg4 = static_cast< wxDragResult >(val4);
35234 {
35235 PyThreadState* __tstate = wxPyBeginAllowThreads();
35236 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35237 wxPyEndAllowThreads(__tstate);
35238 if (PyErr_Occurred()) SWIG_fail;
35239 }
35240 resultobj = SWIG_From_int(static_cast< int >(result));
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35248 PyObject *obj;
35249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35250 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35251 return SWIG_Py_Void();
35252 }
35253
35254 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35255 return SWIG_Python_InitShadowInstance(args);
35256 }
35257
35258 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35259 PyObject *resultobj = 0;
35260 wxClipboard *result = 0 ;
35261
35262 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 result = (wxClipboard *)new wxClipboard();
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35277 PyObject *resultobj = 0;
35278 wxClipboard *arg1 = (wxClipboard *) 0 ;
35279 void *argp1 = 0 ;
35280 int res1 = 0 ;
35281 PyObject *swig_obj[1] ;
35282
35283 if (!args) SWIG_fail;
35284 swig_obj[0] = args;
35285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35286 if (!SWIG_IsOK(res1)) {
35287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35288 }
35289 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35290 {
35291 PyThreadState* __tstate = wxPyBeginAllowThreads();
35292 delete arg1;
35293
35294 wxPyEndAllowThreads(__tstate);
35295 if (PyErr_Occurred()) SWIG_fail;
35296 }
35297 resultobj = SWIG_Py_Void();
35298 return resultobj;
35299 fail:
35300 return NULL;
35301 }
35302
35303
35304 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35305 PyObject *resultobj = 0;
35306 wxClipboard *arg1 = (wxClipboard *) 0 ;
35307 bool result;
35308 void *argp1 = 0 ;
35309 int res1 = 0 ;
35310 PyObject *swig_obj[1] ;
35311
35312 if (!args) SWIG_fail;
35313 swig_obj[0] = args;
35314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35315 if (!SWIG_IsOK(res1)) {
35316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35317 }
35318 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35319 {
35320 PyThreadState* __tstate = wxPyBeginAllowThreads();
35321 result = (bool)(arg1)->Open();
35322 wxPyEndAllowThreads(__tstate);
35323 if (PyErr_Occurred()) SWIG_fail;
35324 }
35325 {
35326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35327 }
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35335 PyObject *resultobj = 0;
35336 wxClipboard *arg1 = (wxClipboard *) 0 ;
35337 void *argp1 = 0 ;
35338 int res1 = 0 ;
35339 PyObject *swig_obj[1] ;
35340
35341 if (!args) SWIG_fail;
35342 swig_obj[0] = args;
35343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35344 if (!SWIG_IsOK(res1)) {
35345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35346 }
35347 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35348 {
35349 PyThreadState* __tstate = wxPyBeginAllowThreads();
35350 (arg1)->Close();
35351 wxPyEndAllowThreads(__tstate);
35352 if (PyErr_Occurred()) SWIG_fail;
35353 }
35354 resultobj = SWIG_Py_Void();
35355 return resultobj;
35356 fail:
35357 return NULL;
35358 }
35359
35360
35361 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35362 PyObject *resultobj = 0;
35363 wxClipboard *arg1 = (wxClipboard *) 0 ;
35364 bool result;
35365 void *argp1 = 0 ;
35366 int res1 = 0 ;
35367 PyObject *swig_obj[1] ;
35368
35369 if (!args) SWIG_fail;
35370 swig_obj[0] = args;
35371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35372 if (!SWIG_IsOK(res1)) {
35373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35374 }
35375 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35376 {
35377 PyThreadState* __tstate = wxPyBeginAllowThreads();
35378 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35379 wxPyEndAllowThreads(__tstate);
35380 if (PyErr_Occurred()) SWIG_fail;
35381 }
35382 {
35383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35384 }
35385 return resultobj;
35386 fail:
35387 return NULL;
35388 }
35389
35390
35391 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35392 PyObject *resultobj = 0;
35393 wxClipboard *arg1 = (wxClipboard *) 0 ;
35394 wxDataObject *arg2 = (wxDataObject *) 0 ;
35395 bool result;
35396 void *argp1 = 0 ;
35397 int res1 = 0 ;
35398 int res2 = 0 ;
35399 PyObject * obj0 = 0 ;
35400 PyObject * obj1 = 0 ;
35401 char * kwnames[] = {
35402 (char *) "self",(char *) "data", NULL
35403 };
35404
35405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35407 if (!SWIG_IsOK(res1)) {
35408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35409 }
35410 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35411 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35412 if (!SWIG_IsOK(res2)) {
35413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35414 }
35415 {
35416 PyThreadState* __tstate = wxPyBeginAllowThreads();
35417 result = (bool)(arg1)->AddData(arg2);
35418 wxPyEndAllowThreads(__tstate);
35419 if (PyErr_Occurred()) SWIG_fail;
35420 }
35421 {
35422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35423 }
35424 return resultobj;
35425 fail:
35426 return NULL;
35427 }
35428
35429
35430 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35431 PyObject *resultobj = 0;
35432 wxClipboard *arg1 = (wxClipboard *) 0 ;
35433 wxDataObject *arg2 = (wxDataObject *) 0 ;
35434 bool result;
35435 void *argp1 = 0 ;
35436 int res1 = 0 ;
35437 int res2 = 0 ;
35438 PyObject * obj0 = 0 ;
35439 PyObject * obj1 = 0 ;
35440 char * kwnames[] = {
35441 (char *) "self",(char *) "data", NULL
35442 };
35443
35444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35446 if (!SWIG_IsOK(res1)) {
35447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35448 }
35449 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35450 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35451 if (!SWIG_IsOK(res2)) {
35452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35453 }
35454 {
35455 PyThreadState* __tstate = wxPyBeginAllowThreads();
35456 result = (bool)(arg1)->SetData(arg2);
35457 wxPyEndAllowThreads(__tstate);
35458 if (PyErr_Occurred()) SWIG_fail;
35459 }
35460 {
35461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35462 }
35463 return resultobj;
35464 fail:
35465 return NULL;
35466 }
35467
35468
35469 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35470 PyObject *resultobj = 0;
35471 wxClipboard *arg1 = (wxClipboard *) 0 ;
35472 wxDataFormat *arg2 = 0 ;
35473 bool result;
35474 void *argp1 = 0 ;
35475 int res1 = 0 ;
35476 void *argp2 = 0 ;
35477 int res2 = 0 ;
35478 PyObject * obj0 = 0 ;
35479 PyObject * obj1 = 0 ;
35480 char * kwnames[] = {
35481 (char *) "self",(char *) "format", NULL
35482 };
35483
35484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35486 if (!SWIG_IsOK(res1)) {
35487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35488 }
35489 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35490 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35491 if (!SWIG_IsOK(res2)) {
35492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35493 }
35494 if (!argp2) {
35495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35496 }
35497 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35498 {
35499 PyThreadState* __tstate = wxPyBeginAllowThreads();
35500 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 {
35505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35506 }
35507 return resultobj;
35508 fail:
35509 return NULL;
35510 }
35511
35512
35513 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35514 PyObject *resultobj = 0;
35515 wxClipboard *arg1 = (wxClipboard *) 0 ;
35516 wxDataObject *arg2 = 0 ;
35517 bool result;
35518 void *argp1 = 0 ;
35519 int res1 = 0 ;
35520 void *argp2 = 0 ;
35521 int res2 = 0 ;
35522 PyObject * obj0 = 0 ;
35523 PyObject * obj1 = 0 ;
35524 char * kwnames[] = {
35525 (char *) "self",(char *) "data", NULL
35526 };
35527
35528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35530 if (!SWIG_IsOK(res1)) {
35531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35532 }
35533 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35534 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35535 if (!SWIG_IsOK(res2)) {
35536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35537 }
35538 if (!argp2) {
35539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35540 }
35541 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35542 {
35543 PyThreadState* __tstate = wxPyBeginAllowThreads();
35544 result = (bool)(arg1)->GetData(*arg2);
35545 wxPyEndAllowThreads(__tstate);
35546 if (PyErr_Occurred()) SWIG_fail;
35547 }
35548 {
35549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35550 }
35551 return resultobj;
35552 fail:
35553 return NULL;
35554 }
35555
35556
35557 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35558 PyObject *resultobj = 0;
35559 wxClipboard *arg1 = (wxClipboard *) 0 ;
35560 void *argp1 = 0 ;
35561 int res1 = 0 ;
35562 PyObject *swig_obj[1] ;
35563
35564 if (!args) SWIG_fail;
35565 swig_obj[0] = args;
35566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35567 if (!SWIG_IsOK(res1)) {
35568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35569 }
35570 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35571 {
35572 PyThreadState* __tstate = wxPyBeginAllowThreads();
35573 (arg1)->Clear();
35574 wxPyEndAllowThreads(__tstate);
35575 if (PyErr_Occurred()) SWIG_fail;
35576 }
35577 resultobj = SWIG_Py_Void();
35578 return resultobj;
35579 fail:
35580 return NULL;
35581 }
35582
35583
35584 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35585 PyObject *resultobj = 0;
35586 wxClipboard *arg1 = (wxClipboard *) 0 ;
35587 bool result;
35588 void *argp1 = 0 ;
35589 int res1 = 0 ;
35590 PyObject *swig_obj[1] ;
35591
35592 if (!args) SWIG_fail;
35593 swig_obj[0] = args;
35594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35595 if (!SWIG_IsOK(res1)) {
35596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35597 }
35598 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 result = (bool)(arg1)->Flush();
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 {
35606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35607 }
35608 return resultobj;
35609 fail:
35610 return NULL;
35611 }
35612
35613
35614 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35615 PyObject *resultobj = 0;
35616 wxClipboard *arg1 = (wxClipboard *) 0 ;
35617 bool arg2 = (bool) true ;
35618 void *argp1 = 0 ;
35619 int res1 = 0 ;
35620 bool val2 ;
35621 int ecode2 = 0 ;
35622 PyObject * obj0 = 0 ;
35623 PyObject * obj1 = 0 ;
35624 char * kwnames[] = {
35625 (char *) "self",(char *) "primary", NULL
35626 };
35627
35628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35630 if (!SWIG_IsOK(res1)) {
35631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35632 }
35633 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35634 if (obj1) {
35635 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35636 if (!SWIG_IsOK(ecode2)) {
35637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35638 }
35639 arg2 = static_cast< bool >(val2);
35640 }
35641 {
35642 PyThreadState* __tstate = wxPyBeginAllowThreads();
35643 (arg1)->UsePrimarySelection(arg2);
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 resultobj = SWIG_Py_Void();
35648 return resultobj;
35649 fail:
35650 return NULL;
35651 }
35652
35653
35654 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35655 PyObject *resultobj = 0;
35656 wxClipboard *result = 0 ;
35657
35658 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35659 {
35660 PyThreadState* __tstate = wxPyBeginAllowThreads();
35661 result = (wxClipboard *)wxClipboard::Get();
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35666 return resultobj;
35667 fail:
35668 return NULL;
35669 }
35670
35671
35672 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35673 PyObject *obj;
35674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35675 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35676 return SWIG_Py_Void();
35677 }
35678
35679 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35680 return SWIG_Python_InitShadowInstance(args);
35681 }
35682
35683 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35684 PyObject *resultobj = 0;
35685 wxClipboard *arg1 = (wxClipboard *) NULL ;
35686 wxClipboardLocker *result = 0 ;
35687 void *argp1 = 0 ;
35688 int res1 = 0 ;
35689 PyObject * obj0 = 0 ;
35690 char * kwnames[] = {
35691 (char *) "clipboard", NULL
35692 };
35693
35694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35695 if (obj0) {
35696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35697 if (!SWIG_IsOK(res1)) {
35698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35699 }
35700 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35701 }
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35709 return resultobj;
35710 fail:
35711 return NULL;
35712 }
35713
35714
35715 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35716 PyObject *resultobj = 0;
35717 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35718 void *argp1 = 0 ;
35719 int res1 = 0 ;
35720 PyObject *swig_obj[1] ;
35721
35722 if (!args) SWIG_fail;
35723 swig_obj[0] = args;
35724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35725 if (!SWIG_IsOK(res1)) {
35726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35727 }
35728 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 delete arg1;
35732
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 resultobj = SWIG_Py_Void();
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35744 PyObject *resultobj = 0;
35745 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35746 bool result;
35747 void *argp1 = 0 ;
35748 int res1 = 0 ;
35749 PyObject *swig_obj[1] ;
35750
35751 if (!args) SWIG_fail;
35752 swig_obj[0] = args;
35753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35754 if (!SWIG_IsOK(res1)) {
35755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35756 }
35757 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35758 {
35759 PyThreadState* __tstate = wxPyBeginAllowThreads();
35760 result = (bool)wxClipboardLocker___nonzero__(arg1);
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 {
35765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35774 PyObject *obj;
35775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35776 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35777 return SWIG_Py_Void();
35778 }
35779
35780 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35781 return SWIG_Python_InitShadowInstance(args);
35782 }
35783
35784 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35785 PyObject *resultobj = 0;
35786 int arg1 = (int) 0 ;
35787 int arg2 = (int) 0 ;
35788 int arg3 = (int) 0 ;
35789 int arg4 = (int) 0 ;
35790 wxVideoMode *result = 0 ;
35791 int val1 ;
35792 int ecode1 = 0 ;
35793 int val2 ;
35794 int ecode2 = 0 ;
35795 int val3 ;
35796 int ecode3 = 0 ;
35797 int val4 ;
35798 int ecode4 = 0 ;
35799 PyObject * obj0 = 0 ;
35800 PyObject * obj1 = 0 ;
35801 PyObject * obj2 = 0 ;
35802 PyObject * obj3 = 0 ;
35803 char * kwnames[] = {
35804 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35805 };
35806
35807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35808 if (obj0) {
35809 ecode1 = SWIG_AsVal_int(obj0, &val1);
35810 if (!SWIG_IsOK(ecode1)) {
35811 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35812 }
35813 arg1 = static_cast< int >(val1);
35814 }
35815 if (obj1) {
35816 ecode2 = SWIG_AsVal_int(obj1, &val2);
35817 if (!SWIG_IsOK(ecode2)) {
35818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35819 }
35820 arg2 = static_cast< int >(val2);
35821 }
35822 if (obj2) {
35823 ecode3 = SWIG_AsVal_int(obj2, &val3);
35824 if (!SWIG_IsOK(ecode3)) {
35825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35826 }
35827 arg3 = static_cast< int >(val3);
35828 }
35829 if (obj3) {
35830 ecode4 = SWIG_AsVal_int(obj3, &val4);
35831 if (!SWIG_IsOK(ecode4)) {
35832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35833 }
35834 arg4 = static_cast< int >(val4);
35835 }
35836 {
35837 PyThreadState* __tstate = wxPyBeginAllowThreads();
35838 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35839 wxPyEndAllowThreads(__tstate);
35840 if (PyErr_Occurred()) SWIG_fail;
35841 }
35842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35843 return resultobj;
35844 fail:
35845 return NULL;
35846 }
35847
35848
35849 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35850 PyObject *resultobj = 0;
35851 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35852 void *argp1 = 0 ;
35853 int res1 = 0 ;
35854 PyObject *swig_obj[1] ;
35855
35856 if (!args) SWIG_fail;
35857 swig_obj[0] = args;
35858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35859 if (!SWIG_IsOK(res1)) {
35860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35861 }
35862 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35863 {
35864 PyThreadState* __tstate = wxPyBeginAllowThreads();
35865 delete arg1;
35866
35867 wxPyEndAllowThreads(__tstate);
35868 if (PyErr_Occurred()) SWIG_fail;
35869 }
35870 resultobj = SWIG_Py_Void();
35871 return resultobj;
35872 fail:
35873 return NULL;
35874 }
35875
35876
35877 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35878 PyObject *resultobj = 0;
35879 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35880 wxVideoMode *arg2 = 0 ;
35881 bool result;
35882 void *argp1 = 0 ;
35883 int res1 = 0 ;
35884 void *argp2 = 0 ;
35885 int res2 = 0 ;
35886 PyObject * obj0 = 0 ;
35887 PyObject * obj1 = 0 ;
35888 char * kwnames[] = {
35889 (char *) "self",(char *) "other", NULL
35890 };
35891
35892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35894 if (!SWIG_IsOK(res1)) {
35895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35896 }
35897 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35899 if (!SWIG_IsOK(res2)) {
35900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35901 }
35902 if (!argp2) {
35903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35904 }
35905 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35906 {
35907 PyThreadState* __tstate = wxPyBeginAllowThreads();
35908 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35909 wxPyEndAllowThreads(__tstate);
35910 if (PyErr_Occurred()) SWIG_fail;
35911 }
35912 {
35913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35914 }
35915 return resultobj;
35916 fail:
35917 return NULL;
35918 }
35919
35920
35921 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35922 PyObject *resultobj = 0;
35923 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35924 int result;
35925 void *argp1 = 0 ;
35926 int res1 = 0 ;
35927 PyObject *swig_obj[1] ;
35928
35929 if (!args) SWIG_fail;
35930 swig_obj[0] = args;
35931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35932 if (!SWIG_IsOK(res1)) {
35933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35934 }
35935 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35936 {
35937 PyThreadState* __tstate = wxPyBeginAllowThreads();
35938 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35939 wxPyEndAllowThreads(__tstate);
35940 if (PyErr_Occurred()) SWIG_fail;
35941 }
35942 resultobj = SWIG_From_int(static_cast< int >(result));
35943 return resultobj;
35944 fail:
35945 return NULL;
35946 }
35947
35948
35949 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35950 PyObject *resultobj = 0;
35951 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35952 int result;
35953 void *argp1 = 0 ;
35954 int res1 = 0 ;
35955 PyObject *swig_obj[1] ;
35956
35957 if (!args) SWIG_fail;
35958 swig_obj[0] = args;
35959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35960 if (!SWIG_IsOK(res1)) {
35961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35962 }
35963 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35964 {
35965 PyThreadState* __tstate = wxPyBeginAllowThreads();
35966 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35967 wxPyEndAllowThreads(__tstate);
35968 if (PyErr_Occurred()) SWIG_fail;
35969 }
35970 resultobj = SWIG_From_int(static_cast< int >(result));
35971 return resultobj;
35972 fail:
35973 return NULL;
35974 }
35975
35976
35977 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35978 PyObject *resultobj = 0;
35979 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35980 int result;
35981 void *argp1 = 0 ;
35982 int res1 = 0 ;
35983 PyObject *swig_obj[1] ;
35984
35985 if (!args) SWIG_fail;
35986 swig_obj[0] = args;
35987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35988 if (!SWIG_IsOK(res1)) {
35989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35990 }
35991 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35992 {
35993 PyThreadState* __tstate = wxPyBeginAllowThreads();
35994 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 resultobj = SWIG_From_int(static_cast< int >(result));
35999 return resultobj;
36000 fail:
36001 return NULL;
36002 }
36003
36004
36005 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36006 PyObject *resultobj = 0;
36007 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36008 bool result;
36009 void *argp1 = 0 ;
36010 int res1 = 0 ;
36011 PyObject *swig_obj[1] ;
36012
36013 if (!args) SWIG_fail;
36014 swig_obj[0] = args;
36015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36016 if (!SWIG_IsOK(res1)) {
36017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36018 }
36019 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 {
36027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36028 }
36029 return resultobj;
36030 fail:
36031 return NULL;
36032 }
36033
36034
36035 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36036 PyObject *resultobj = 0;
36037 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36038 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36039 bool result;
36040 void *argp1 = 0 ;
36041 int res1 = 0 ;
36042 void *argp2 = 0 ;
36043 int res2 = 0 ;
36044 PyObject * obj0 = 0 ;
36045 PyObject * obj1 = 0 ;
36046 char * kwnames[] = {
36047 (char *) "self",(char *) "other", NULL
36048 };
36049
36050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36052 if (!SWIG_IsOK(res1)) {
36053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36054 }
36055 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36056 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36057 if (!SWIG_IsOK(res2)) {
36058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36059 }
36060 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36061 {
36062 PyThreadState* __tstate = wxPyBeginAllowThreads();
36063 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36064 wxPyEndAllowThreads(__tstate);
36065 if (PyErr_Occurred()) SWIG_fail;
36066 }
36067 {
36068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36069 }
36070 return resultobj;
36071 fail:
36072 return NULL;
36073 }
36074
36075
36076 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36077 PyObject *resultobj = 0;
36078 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36079 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36080 bool result;
36081 void *argp1 = 0 ;
36082 int res1 = 0 ;
36083 void *argp2 = 0 ;
36084 int res2 = 0 ;
36085 PyObject * obj0 = 0 ;
36086 PyObject * obj1 = 0 ;
36087 char * kwnames[] = {
36088 (char *) "self",(char *) "other", NULL
36089 };
36090
36091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36093 if (!SWIG_IsOK(res1)) {
36094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36095 }
36096 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36097 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36098 if (!SWIG_IsOK(res2)) {
36099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36100 }
36101 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36102 {
36103 PyThreadState* __tstate = wxPyBeginAllowThreads();
36104 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36105 wxPyEndAllowThreads(__tstate);
36106 if (PyErr_Occurred()) SWIG_fail;
36107 }
36108 {
36109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36110 }
36111 return resultobj;
36112 fail:
36113 return NULL;
36114 }
36115
36116
36117 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36118 PyObject *resultobj = 0;
36119 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36120 int arg2 ;
36121 void *argp1 = 0 ;
36122 int res1 = 0 ;
36123 int val2 ;
36124 int ecode2 = 0 ;
36125 PyObject *swig_obj[2] ;
36126
36127 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36129 if (!SWIG_IsOK(res1)) {
36130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36131 }
36132 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36133 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36134 if (!SWIG_IsOK(ecode2)) {
36135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36136 }
36137 arg2 = static_cast< int >(val2);
36138 if (arg1) (arg1)->w = arg2;
36139
36140 resultobj = SWIG_Py_Void();
36141 return resultobj;
36142 fail:
36143 return NULL;
36144 }
36145
36146
36147 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36148 PyObject *resultobj = 0;
36149 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36150 int result;
36151 void *argp1 = 0 ;
36152 int res1 = 0 ;
36153 PyObject *swig_obj[1] ;
36154
36155 if (!args) SWIG_fail;
36156 swig_obj[0] = args;
36157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36158 if (!SWIG_IsOK(res1)) {
36159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36160 }
36161 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36162 result = (int) ((arg1)->w);
36163 resultobj = SWIG_From_int(static_cast< int >(result));
36164 return resultobj;
36165 fail:
36166 return NULL;
36167 }
36168
36169
36170 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36171 PyObject *resultobj = 0;
36172 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36173 int arg2 ;
36174 void *argp1 = 0 ;
36175 int res1 = 0 ;
36176 int val2 ;
36177 int ecode2 = 0 ;
36178 PyObject *swig_obj[2] ;
36179
36180 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36182 if (!SWIG_IsOK(res1)) {
36183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36184 }
36185 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36186 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36187 if (!SWIG_IsOK(ecode2)) {
36188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36189 }
36190 arg2 = static_cast< int >(val2);
36191 if (arg1) (arg1)->h = arg2;
36192
36193 resultobj = SWIG_Py_Void();
36194 return resultobj;
36195 fail:
36196 return NULL;
36197 }
36198
36199
36200 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36201 PyObject *resultobj = 0;
36202 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36203 int result;
36204 void *argp1 = 0 ;
36205 int res1 = 0 ;
36206 PyObject *swig_obj[1] ;
36207
36208 if (!args) SWIG_fail;
36209 swig_obj[0] = args;
36210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36211 if (!SWIG_IsOK(res1)) {
36212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36213 }
36214 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36215 result = (int) ((arg1)->h);
36216 resultobj = SWIG_From_int(static_cast< int >(result));
36217 return resultobj;
36218 fail:
36219 return NULL;
36220 }
36221
36222
36223 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36224 PyObject *resultobj = 0;
36225 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36226 int arg2 ;
36227 void *argp1 = 0 ;
36228 int res1 = 0 ;
36229 int val2 ;
36230 int ecode2 = 0 ;
36231 PyObject *swig_obj[2] ;
36232
36233 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36235 if (!SWIG_IsOK(res1)) {
36236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36237 }
36238 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36239 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36240 if (!SWIG_IsOK(ecode2)) {
36241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36242 }
36243 arg2 = static_cast< int >(val2);
36244 if (arg1) (arg1)->bpp = arg2;
36245
36246 resultobj = SWIG_Py_Void();
36247 return resultobj;
36248 fail:
36249 return NULL;
36250 }
36251
36252
36253 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36254 PyObject *resultobj = 0;
36255 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36256 int result;
36257 void *argp1 = 0 ;
36258 int res1 = 0 ;
36259 PyObject *swig_obj[1] ;
36260
36261 if (!args) SWIG_fail;
36262 swig_obj[0] = args;
36263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36264 if (!SWIG_IsOK(res1)) {
36265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36266 }
36267 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36268 result = (int) ((arg1)->bpp);
36269 resultobj = SWIG_From_int(static_cast< int >(result));
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36277 PyObject *resultobj = 0;
36278 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36279 int arg2 ;
36280 void *argp1 = 0 ;
36281 int res1 = 0 ;
36282 int val2 ;
36283 int ecode2 = 0 ;
36284 PyObject *swig_obj[2] ;
36285
36286 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36288 if (!SWIG_IsOK(res1)) {
36289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36290 }
36291 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36292 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36293 if (!SWIG_IsOK(ecode2)) {
36294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36295 }
36296 arg2 = static_cast< int >(val2);
36297 if (arg1) (arg1)->refresh = arg2;
36298
36299 resultobj = SWIG_Py_Void();
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36307 PyObject *resultobj = 0;
36308 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36309 int result;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 PyObject *swig_obj[1] ;
36313
36314 if (!args) SWIG_fail;
36315 swig_obj[0] = args;
36316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36317 if (!SWIG_IsOK(res1)) {
36318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36319 }
36320 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36321 result = (int) ((arg1)->refresh);
36322 resultobj = SWIG_From_int(static_cast< int >(result));
36323 return resultobj;
36324 fail:
36325 return NULL;
36326 }
36327
36328
36329 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36330 PyObject *obj;
36331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36332 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36333 return SWIG_Py_Void();
36334 }
36335
36336 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36337 return SWIG_Python_InitShadowInstance(args);
36338 }
36339
36340 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36341 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36342 return 1;
36343 }
36344
36345
36346 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36347 PyObject *pyobj = 0;
36348
36349 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36350 return pyobj;
36351 }
36352
36353
36354 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36355 PyObject *resultobj = 0;
36356 unsigned int arg1 = (unsigned int) 0 ;
36357 wxDisplay *result = 0 ;
36358 unsigned int val1 ;
36359 int ecode1 = 0 ;
36360 PyObject * obj0 = 0 ;
36361 char * kwnames[] = {
36362 (char *) "index", NULL
36363 };
36364
36365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36366 if (obj0) {
36367 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36368 if (!SWIG_IsOK(ecode1)) {
36369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36370 }
36371 arg1 = static_cast< unsigned int >(val1);
36372 }
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = (wxDisplay *)new wxDisplay(arg1);
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36380 return resultobj;
36381 fail:
36382 return NULL;
36383 }
36384
36385
36386 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36387 PyObject *resultobj = 0;
36388 wxDisplay *arg1 = (wxDisplay *) 0 ;
36389 void *argp1 = 0 ;
36390 int res1 = 0 ;
36391 PyObject *swig_obj[1] ;
36392
36393 if (!args) SWIG_fail;
36394 swig_obj[0] = args;
36395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36396 if (!SWIG_IsOK(res1)) {
36397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36398 }
36399 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36400 {
36401 PyThreadState* __tstate = wxPyBeginAllowThreads();
36402 delete arg1;
36403
36404 wxPyEndAllowThreads(__tstate);
36405 if (PyErr_Occurred()) SWIG_fail;
36406 }
36407 resultobj = SWIG_Py_Void();
36408 return resultobj;
36409 fail:
36410 return NULL;
36411 }
36412
36413
36414 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36415 PyObject *resultobj = 0;
36416 unsigned int result;
36417
36418 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = (unsigned int)wxDisplay::GetCount();
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36433 PyObject *resultobj = 0;
36434 wxPoint *arg1 = 0 ;
36435 int result;
36436 wxPoint temp1 ;
36437 PyObject * obj0 = 0 ;
36438 char * kwnames[] = {
36439 (char *) "pt", NULL
36440 };
36441
36442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36443 {
36444 arg1 = &temp1;
36445 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36446 }
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36450 wxPyEndAllowThreads(__tstate);
36451 if (PyErr_Occurred()) SWIG_fail;
36452 }
36453 resultobj = SWIG_From_int(static_cast< int >(result));
36454 return resultobj;
36455 fail:
36456 return NULL;
36457 }
36458
36459
36460 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36461 PyObject *resultobj = 0;
36462 wxWindow *arg1 = (wxWindow *) 0 ;
36463 int result;
36464 void *argp1 = 0 ;
36465 int res1 = 0 ;
36466 PyObject * obj0 = 0 ;
36467 char * kwnames[] = {
36468 (char *) "window", NULL
36469 };
36470
36471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36473 if (!SWIG_IsOK(res1)) {
36474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow const *""'");
36475 }
36476 arg1 = reinterpret_cast< wxWindow * >(argp1);
36477 {
36478 PyThreadState* __tstate = wxPyBeginAllowThreads();
36479 result = (int)wxDisplay::GetFromWindow((wxWindow const *)arg1);
36480 wxPyEndAllowThreads(__tstate);
36481 if (PyErr_Occurred()) SWIG_fail;
36482 }
36483 resultobj = SWIG_From_int(static_cast< int >(result));
36484 return resultobj;
36485 fail:
36486 return NULL;
36487 }
36488
36489
36490 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36491 PyObject *resultobj = 0;
36492 wxDisplay *arg1 = (wxDisplay *) 0 ;
36493 bool result;
36494 void *argp1 = 0 ;
36495 int res1 = 0 ;
36496 PyObject *swig_obj[1] ;
36497
36498 if (!args) SWIG_fail;
36499 swig_obj[0] = args;
36500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36501 if (!SWIG_IsOK(res1)) {
36502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36503 }
36504 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 result = (bool)((wxDisplay const *)arg1)->IsOk();
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 {
36512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36513 }
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36521 PyObject *resultobj = 0;
36522 wxDisplay *arg1 = (wxDisplay *) 0 ;
36523 wxRect result;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 PyObject *swig_obj[1] ;
36527
36528 if (!args) SWIG_fail;
36529 swig_obj[0] = args;
36530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36531 if (!SWIG_IsOK(res1)) {
36532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36533 }
36534 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 result = ((wxDisplay const *)arg1)->GetGeometry();
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36549 PyObject *resultobj = 0;
36550 wxDisplay *arg1 = (wxDisplay *) 0 ;
36551 wxRect result;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 PyObject *swig_obj[1] ;
36555
36556 if (!args) SWIG_fail;
36557 swig_obj[0] = args;
36558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36561 }
36562 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36563 {
36564 PyThreadState* __tstate = wxPyBeginAllowThreads();
36565 result = ((wxDisplay const *)arg1)->GetClientArea();
36566 wxPyEndAllowThreads(__tstate);
36567 if (PyErr_Occurred()) SWIG_fail;
36568 }
36569 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36570 return resultobj;
36571 fail:
36572 return NULL;
36573 }
36574
36575
36576 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36577 PyObject *resultobj = 0;
36578 wxDisplay *arg1 = (wxDisplay *) 0 ;
36579 wxString result;
36580 void *argp1 = 0 ;
36581 int res1 = 0 ;
36582 PyObject *swig_obj[1] ;
36583
36584 if (!args) SWIG_fail;
36585 swig_obj[0] = args;
36586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36587 if (!SWIG_IsOK(res1)) {
36588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36589 }
36590 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36591 {
36592 PyThreadState* __tstate = wxPyBeginAllowThreads();
36593 result = ((wxDisplay const *)arg1)->GetName();
36594 wxPyEndAllowThreads(__tstate);
36595 if (PyErr_Occurred()) SWIG_fail;
36596 }
36597 {
36598 #if wxUSE_UNICODE
36599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36600 #else
36601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36602 #endif
36603 }
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36611 PyObject *resultobj = 0;
36612 wxDisplay *arg1 = (wxDisplay *) 0 ;
36613 bool result;
36614 void *argp1 = 0 ;
36615 int res1 = 0 ;
36616 PyObject *swig_obj[1] ;
36617
36618 if (!args) SWIG_fail;
36619 swig_obj[0] = args;
36620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36621 if (!SWIG_IsOK(res1)) {
36622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36623 }
36624 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36625 {
36626 PyThreadState* __tstate = wxPyBeginAllowThreads();
36627 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36628 wxPyEndAllowThreads(__tstate);
36629 if (PyErr_Occurred()) SWIG_fail;
36630 }
36631 {
36632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36633 }
36634 return resultobj;
36635 fail:
36636 return NULL;
36637 }
36638
36639
36640 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36641 PyObject *resultobj = 0;
36642 wxDisplay *arg1 = (wxDisplay *) 0 ;
36643 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36644 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36645 PyObject *result = 0 ;
36646 void *argp1 = 0 ;
36647 int res1 = 0 ;
36648 void *argp2 = 0 ;
36649 int res2 = 0 ;
36650 PyObject * obj0 = 0 ;
36651 PyObject * obj1 = 0 ;
36652 char * kwnames[] = {
36653 (char *) "self",(char *) "mode", NULL
36654 };
36655
36656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36658 if (!SWIG_IsOK(res1)) {
36659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36660 }
36661 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36662 if (obj1) {
36663 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36664 if (!SWIG_IsOK(res2)) {
36665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36666 }
36667 if (!argp2) {
36668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36669 }
36670 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36671 }
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36675 wxPyEndAllowThreads(__tstate);
36676 if (PyErr_Occurred()) SWIG_fail;
36677 }
36678 resultobj = result;
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36686 PyObject *resultobj = 0;
36687 wxDisplay *arg1 = (wxDisplay *) 0 ;
36688 wxVideoMode result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 PyObject *swig_obj[1] ;
36692
36693 if (!args) SWIG_fail;
36694 swig_obj[0] = args;
36695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36696 if (!SWIG_IsOK(res1)) {
36697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36698 }
36699 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36707 return resultobj;
36708 fail:
36709 return NULL;
36710 }
36711
36712
36713 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36714 PyObject *resultobj = 0;
36715 wxDisplay *arg1 = (wxDisplay *) 0 ;
36716 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36717 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36718 bool result;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 void *argp2 = 0 ;
36722 int res2 = 0 ;
36723 PyObject * obj0 = 0 ;
36724 PyObject * obj1 = 0 ;
36725 char * kwnames[] = {
36726 (char *) "self",(char *) "mode", NULL
36727 };
36728
36729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36731 if (!SWIG_IsOK(res1)) {
36732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36733 }
36734 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36735 if (obj1) {
36736 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36737 if (!SWIG_IsOK(res2)) {
36738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36739 }
36740 if (!argp2) {
36741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36742 }
36743 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36744 }
36745 {
36746 PyThreadState* __tstate = wxPyBeginAllowThreads();
36747 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36748 wxPyEndAllowThreads(__tstate);
36749 if (PyErr_Occurred()) SWIG_fail;
36750 }
36751 {
36752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36753 }
36754 return resultobj;
36755 fail:
36756 return NULL;
36757 }
36758
36759
36760 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36761 PyObject *resultobj = 0;
36762 wxDisplay *arg1 = (wxDisplay *) 0 ;
36763 void *argp1 = 0 ;
36764 int res1 = 0 ;
36765 PyObject *swig_obj[1] ;
36766
36767 if (!args) SWIG_fail;
36768 swig_obj[0] = args;
36769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36770 if (!SWIG_IsOK(res1)) {
36771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36772 }
36773 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36774 {
36775 PyThreadState* __tstate = wxPyBeginAllowThreads();
36776 wxDisplay_ResetMode(arg1);
36777 wxPyEndAllowThreads(__tstate);
36778 if (PyErr_Occurred()) SWIG_fail;
36779 }
36780 resultobj = SWIG_Py_Void();
36781 return resultobj;
36782 fail:
36783 return NULL;
36784 }
36785
36786
36787 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36788 PyObject *obj;
36789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36790 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36791 return SWIG_Py_Void();
36792 }
36793
36794 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36795 return SWIG_Python_InitShadowInstance(args);
36796 }
36797
36798 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36799 PyObject *resultobj = 0;
36800 wxStandardPaths *result = 0 ;
36801
36802 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36803 {
36804 PyThreadState* __tstate = wxPyBeginAllowThreads();
36805 result = (wxStandardPaths *)wxStandardPaths_Get();
36806 wxPyEndAllowThreads(__tstate);
36807 if (PyErr_Occurred()) SWIG_fail;
36808 }
36809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36810 return resultobj;
36811 fail:
36812 return NULL;
36813 }
36814
36815
36816 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36817 PyObject *resultobj = 0;
36818 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36819 wxString result;
36820 void *argp1 = 0 ;
36821 int res1 = 0 ;
36822 PyObject *swig_obj[1] ;
36823
36824 if (!args) SWIG_fail;
36825 swig_obj[0] = args;
36826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36827 if (!SWIG_IsOK(res1)) {
36828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36829 }
36830 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36831 {
36832 PyThreadState* __tstate = wxPyBeginAllowThreads();
36833 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36834 wxPyEndAllowThreads(__tstate);
36835 if (PyErr_Occurred()) SWIG_fail;
36836 }
36837 {
36838 #if wxUSE_UNICODE
36839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36840 #else
36841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36842 #endif
36843 }
36844 return resultobj;
36845 fail:
36846 return NULL;
36847 }
36848
36849
36850 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36851 PyObject *resultobj = 0;
36852 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36853 wxString result;
36854 void *argp1 = 0 ;
36855 int res1 = 0 ;
36856 PyObject *swig_obj[1] ;
36857
36858 if (!args) SWIG_fail;
36859 swig_obj[0] = args;
36860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36861 if (!SWIG_IsOK(res1)) {
36862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36863 }
36864 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 {
36872 #if wxUSE_UNICODE
36873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36874 #else
36875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36876 #endif
36877 }
36878 return resultobj;
36879 fail:
36880 return NULL;
36881 }
36882
36883
36884 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36885 PyObject *resultobj = 0;
36886 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36887 wxString result;
36888 void *argp1 = 0 ;
36889 int res1 = 0 ;
36890 PyObject *swig_obj[1] ;
36891
36892 if (!args) SWIG_fail;
36893 swig_obj[0] = args;
36894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36895 if (!SWIG_IsOK(res1)) {
36896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36897 }
36898 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36899 {
36900 PyThreadState* __tstate = wxPyBeginAllowThreads();
36901 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36902 wxPyEndAllowThreads(__tstate);
36903 if (PyErr_Occurred()) SWIG_fail;
36904 }
36905 {
36906 #if wxUSE_UNICODE
36907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36908 #else
36909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36910 #endif
36911 }
36912 return resultobj;
36913 fail:
36914 return NULL;
36915 }
36916
36917
36918 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36919 PyObject *resultobj = 0;
36920 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36921 wxString result;
36922 void *argp1 = 0 ;
36923 int res1 = 0 ;
36924 PyObject *swig_obj[1] ;
36925
36926 if (!args) SWIG_fail;
36927 swig_obj[0] = args;
36928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36929 if (!SWIG_IsOK(res1)) {
36930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36931 }
36932 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36933 {
36934 PyThreadState* __tstate = wxPyBeginAllowThreads();
36935 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36936 wxPyEndAllowThreads(__tstate);
36937 if (PyErr_Occurred()) SWIG_fail;
36938 }
36939 {
36940 #if wxUSE_UNICODE
36941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36942 #else
36943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36944 #endif
36945 }
36946 return resultobj;
36947 fail:
36948 return NULL;
36949 }
36950
36951
36952 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36953 PyObject *resultobj = 0;
36954 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36955 wxString result;
36956 void *argp1 = 0 ;
36957 int res1 = 0 ;
36958 PyObject *swig_obj[1] ;
36959
36960 if (!args) SWIG_fail;
36961 swig_obj[0] = args;
36962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36963 if (!SWIG_IsOK(res1)) {
36964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36965 }
36966 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36970 wxPyEndAllowThreads(__tstate);
36971 if (PyErr_Occurred()) SWIG_fail;
36972 }
36973 {
36974 #if wxUSE_UNICODE
36975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36976 #else
36977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36978 #endif
36979 }
36980 return resultobj;
36981 fail:
36982 return NULL;
36983 }
36984
36985
36986 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36987 PyObject *resultobj = 0;
36988 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36989 wxString result;
36990 void *argp1 = 0 ;
36991 int res1 = 0 ;
36992 PyObject *swig_obj[1] ;
36993
36994 if (!args) SWIG_fail;
36995 swig_obj[0] = args;
36996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36997 if (!SWIG_IsOK(res1)) {
36998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36999 }
37000 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37001 {
37002 PyThreadState* __tstate = wxPyBeginAllowThreads();
37003 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37004 wxPyEndAllowThreads(__tstate);
37005 if (PyErr_Occurred()) SWIG_fail;
37006 }
37007 {
37008 #if wxUSE_UNICODE
37009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37010 #else
37011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37012 #endif
37013 }
37014 return resultobj;
37015 fail:
37016 return NULL;
37017 }
37018
37019
37020 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37021 PyObject *resultobj = 0;
37022 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37023 wxString result;
37024 void *argp1 = 0 ;
37025 int res1 = 0 ;
37026 PyObject *swig_obj[1] ;
37027
37028 if (!args) SWIG_fail;
37029 swig_obj[0] = args;
37030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37031 if (!SWIG_IsOK(res1)) {
37032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37033 }
37034 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37038 wxPyEndAllowThreads(__tstate);
37039 if (PyErr_Occurred()) SWIG_fail;
37040 }
37041 {
37042 #if wxUSE_UNICODE
37043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37044 #else
37045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37046 #endif
37047 }
37048 return resultobj;
37049 fail:
37050 return NULL;
37051 }
37052
37053
37054 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37055 PyObject *resultobj = 0;
37056 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37057 wxString result;
37058 void *argp1 = 0 ;
37059 int res1 = 0 ;
37060 PyObject *swig_obj[1] ;
37061
37062 if (!args) SWIG_fail;
37063 swig_obj[0] = args;
37064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37065 if (!SWIG_IsOK(res1)) {
37066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37067 }
37068 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37069 {
37070 PyThreadState* __tstate = wxPyBeginAllowThreads();
37071 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37072 wxPyEndAllowThreads(__tstate);
37073 if (PyErr_Occurred()) SWIG_fail;
37074 }
37075 {
37076 #if wxUSE_UNICODE
37077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37078 #else
37079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37080 #endif
37081 }
37082 return resultobj;
37083 fail:
37084 return NULL;
37085 }
37086
37087
37088 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37089 PyObject *resultobj = 0;
37090 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37091 wxString result;
37092 void *argp1 = 0 ;
37093 int res1 = 0 ;
37094 PyObject *swig_obj[1] ;
37095
37096 if (!args) SWIG_fail;
37097 swig_obj[0] = args;
37098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37099 if (!SWIG_IsOK(res1)) {
37100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37101 }
37102 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37103 {
37104 PyThreadState* __tstate = wxPyBeginAllowThreads();
37105 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37106 wxPyEndAllowThreads(__tstate);
37107 if (PyErr_Occurred()) SWIG_fail;
37108 }
37109 {
37110 #if wxUSE_UNICODE
37111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37112 #else
37113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37114 #endif
37115 }
37116 return resultobj;
37117 fail:
37118 return NULL;
37119 }
37120
37121
37122 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37123 PyObject *resultobj = 0;
37124 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37125 wxString *arg2 = 0 ;
37126 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37127 wxString result;
37128 void *argp1 = 0 ;
37129 int res1 = 0 ;
37130 bool temp2 = false ;
37131 int val3 ;
37132 int ecode3 = 0 ;
37133 PyObject * obj0 = 0 ;
37134 PyObject * obj1 = 0 ;
37135 PyObject * obj2 = 0 ;
37136 char * kwnames[] = {
37137 (char *) "self",(char *) "lang",(char *) "category", NULL
37138 };
37139
37140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37142 if (!SWIG_IsOK(res1)) {
37143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37144 }
37145 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37146 {
37147 arg2 = wxString_in_helper(obj1);
37148 if (arg2 == NULL) SWIG_fail;
37149 temp2 = true;
37150 }
37151 if (obj2) {
37152 ecode3 = SWIG_AsVal_int(obj2, &val3);
37153 if (!SWIG_IsOK(ecode3)) {
37154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37155 }
37156 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37157 }
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 {
37165 #if wxUSE_UNICODE
37166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37167 #else
37168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37169 #endif
37170 }
37171 {
37172 if (temp2)
37173 delete arg2;
37174 }
37175 return resultobj;
37176 fail:
37177 {
37178 if (temp2)
37179 delete arg2;
37180 }
37181 return NULL;
37182 }
37183
37184
37185 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37186 PyObject *resultobj = 0;
37187 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37188 wxString result;
37189 void *argp1 = 0 ;
37190 int res1 = 0 ;
37191 PyObject *swig_obj[1] ;
37192
37193 if (!args) SWIG_fail;
37194 swig_obj[0] = args;
37195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37196 if (!SWIG_IsOK(res1)) {
37197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37198 }
37199 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37200 {
37201 PyThreadState* __tstate = wxPyBeginAllowThreads();
37202 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37203 wxPyEndAllowThreads(__tstate);
37204 if (PyErr_Occurred()) SWIG_fail;
37205 }
37206 {
37207 #if wxUSE_UNICODE
37208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37209 #else
37210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37211 #endif
37212 }
37213 return resultobj;
37214 fail:
37215 return NULL;
37216 }
37217
37218
37219 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37220 PyObject *resultobj = 0;
37221 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37222 wxString result;
37223 void *argp1 = 0 ;
37224 int res1 = 0 ;
37225 PyObject *swig_obj[1] ;
37226
37227 if (!args) SWIG_fail;
37228 swig_obj[0] = args;
37229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37230 if (!SWIG_IsOK(res1)) {
37231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37232 }
37233 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 {
37241 #if wxUSE_UNICODE
37242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37243 #else
37244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37245 #endif
37246 }
37247 return resultobj;
37248 fail:
37249 return NULL;
37250 }
37251
37252
37253 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37254 PyObject *resultobj = 0;
37255 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37256 wxString *arg2 = 0 ;
37257 void *argp1 = 0 ;
37258 int res1 = 0 ;
37259 bool temp2 = false ;
37260 PyObject * obj0 = 0 ;
37261 PyObject * obj1 = 0 ;
37262 char * kwnames[] = {
37263 (char *) "self",(char *) "prefix", NULL
37264 };
37265
37266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37268 if (!SWIG_IsOK(res1)) {
37269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37270 }
37271 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37272 {
37273 arg2 = wxString_in_helper(obj1);
37274 if (arg2 == NULL) SWIG_fail;
37275 temp2 = true;
37276 }
37277 {
37278 PyThreadState* __tstate = wxPyBeginAllowThreads();
37279 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37280 wxPyEndAllowThreads(__tstate);
37281 if (PyErr_Occurred()) SWIG_fail;
37282 }
37283 resultobj = SWIG_Py_Void();
37284 {
37285 if (temp2)
37286 delete arg2;
37287 }
37288 return resultobj;
37289 fail:
37290 {
37291 if (temp2)
37292 delete arg2;
37293 }
37294 return NULL;
37295 }
37296
37297
37298 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37299 PyObject *resultobj = 0;
37300 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37301 wxString result;
37302 void *argp1 = 0 ;
37303 int res1 = 0 ;
37304 PyObject *swig_obj[1] ;
37305
37306 if (!args) SWIG_fail;
37307 swig_obj[0] = args;
37308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37309 if (!SWIG_IsOK(res1)) {
37310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37311 }
37312 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37313 {
37314 PyThreadState* __tstate = wxPyBeginAllowThreads();
37315 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37316 wxPyEndAllowThreads(__tstate);
37317 if (PyErr_Occurred()) SWIG_fail;
37318 }
37319 {
37320 #if wxUSE_UNICODE
37321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37322 #else
37323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37324 #endif
37325 }
37326 return resultobj;
37327 fail:
37328 return NULL;
37329 }
37330
37331
37332 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37333 PyObject *obj;
37334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37335 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37336 return SWIG_Py_Void();
37337 }
37338
37339 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37340 PyObject *resultobj = 0;
37341 wxEventType arg1 ;
37342 wxPowerEvent *result = 0 ;
37343 int val1 ;
37344 int ecode1 = 0 ;
37345 PyObject * obj0 = 0 ;
37346 char * kwnames[] = {
37347 (char *) "evtType", NULL
37348 };
37349
37350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37351 ecode1 = SWIG_AsVal_int(obj0, &val1);
37352 if (!SWIG_IsOK(ecode1)) {
37353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37354 }
37355 arg1 = static_cast< wxEventType >(val1);
37356 {
37357 PyThreadState* __tstate = wxPyBeginAllowThreads();
37358 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37363 return resultobj;
37364 fail:
37365 return NULL;
37366 }
37367
37368
37369 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37370 PyObject *resultobj = 0;
37371 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37372 void *argp1 = 0 ;
37373 int res1 = 0 ;
37374 PyObject *swig_obj[1] ;
37375
37376 if (!args) SWIG_fail;
37377 swig_obj[0] = args;
37378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37379 if (!SWIG_IsOK(res1)) {
37380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37381 }
37382 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37383 {
37384 PyThreadState* __tstate = wxPyBeginAllowThreads();
37385 (arg1)->Veto();
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 resultobj = SWIG_Py_Void();
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37397 PyObject *resultobj = 0;
37398 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37399 bool result;
37400 void *argp1 = 0 ;
37401 int res1 = 0 ;
37402 PyObject *swig_obj[1] ;
37403
37404 if (!args) SWIG_fail;
37405 swig_obj[0] = args;
37406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37407 if (!SWIG_IsOK(res1)) {
37408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37409 }
37410 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 {
37418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37419 }
37420 return resultobj;
37421 fail:
37422 return NULL;
37423 }
37424
37425
37426 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37427 PyObject *obj;
37428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37429 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37430 return SWIG_Py_Void();
37431 }
37432
37433 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37434 return SWIG_Python_InitShadowInstance(args);
37435 }
37436
37437 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37438 PyObject *resultobj = 0;
37439 wxPowerType result;
37440
37441 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37442 {
37443 PyThreadState* __tstate = wxPyBeginAllowThreads();
37444 result = (wxPowerType)wxGetPowerType();
37445 wxPyEndAllowThreads(__tstate);
37446 if (PyErr_Occurred()) SWIG_fail;
37447 }
37448 resultobj = SWIG_From_int(static_cast< int >(result));
37449 return resultobj;
37450 fail:
37451 return NULL;
37452 }
37453
37454
37455 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37456 PyObject *resultobj = 0;
37457 wxBatteryState result;
37458
37459 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37460 {
37461 PyThreadState* __tstate = wxPyBeginAllowThreads();
37462 result = (wxBatteryState)wxGetBatteryState();
37463 wxPyEndAllowThreads(__tstate);
37464 if (PyErr_Occurred()) SWIG_fail;
37465 }
37466 resultobj = SWIG_From_int(static_cast< int >(result));
37467 return resultobj;
37468 fail:
37469 return NULL;
37470 }
37471
37472
37473 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37474 PyObject *resultobj = 0;
37475 wxAboutDialogInfo *result = 0 ;
37476
37477 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37478 {
37479 PyThreadState* __tstate = wxPyBeginAllowThreads();
37480 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37481 wxPyEndAllowThreads(__tstate);
37482 if (PyErr_Occurred()) SWIG_fail;
37483 }
37484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37485 return resultobj;
37486 fail:
37487 return NULL;
37488 }
37489
37490
37491 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37492 PyObject *resultobj = 0;
37493 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37494 void *argp1 = 0 ;
37495 int res1 = 0 ;
37496 PyObject *swig_obj[1] ;
37497
37498 if (!args) SWIG_fail;
37499 swig_obj[0] = args;
37500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37501 if (!SWIG_IsOK(res1)) {
37502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37503 }
37504 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37505 {
37506 PyThreadState* __tstate = wxPyBeginAllowThreads();
37507 delete arg1;
37508
37509 wxPyEndAllowThreads(__tstate);
37510 if (PyErr_Occurred()) SWIG_fail;
37511 }
37512 resultobj = SWIG_Py_Void();
37513 return resultobj;
37514 fail:
37515 return NULL;
37516 }
37517
37518
37519 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37520 PyObject *resultobj = 0;
37521 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37522 wxString *arg2 = 0 ;
37523 void *argp1 = 0 ;
37524 int res1 = 0 ;
37525 bool temp2 = false ;
37526 PyObject * obj0 = 0 ;
37527 PyObject * obj1 = 0 ;
37528 char * kwnames[] = {
37529 (char *) "self",(char *) "name", NULL
37530 };
37531
37532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37534 if (!SWIG_IsOK(res1)) {
37535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37536 }
37537 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37538 {
37539 arg2 = wxString_in_helper(obj1);
37540 if (arg2 == NULL) SWIG_fail;
37541 temp2 = true;
37542 }
37543 {
37544 PyThreadState* __tstate = wxPyBeginAllowThreads();
37545 (arg1)->SetName((wxString const &)*arg2);
37546 wxPyEndAllowThreads(__tstate);
37547 if (PyErr_Occurred()) SWIG_fail;
37548 }
37549 resultobj = SWIG_Py_Void();
37550 {
37551 if (temp2)
37552 delete arg2;
37553 }
37554 return resultobj;
37555 fail:
37556 {
37557 if (temp2)
37558 delete arg2;
37559 }
37560 return NULL;
37561 }
37562
37563
37564 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37565 PyObject *resultobj = 0;
37566 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37567 wxString result;
37568 void *argp1 = 0 ;
37569 int res1 = 0 ;
37570 PyObject *swig_obj[1] ;
37571
37572 if (!args) SWIG_fail;
37573 swig_obj[0] = args;
37574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37575 if (!SWIG_IsOK(res1)) {
37576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37577 }
37578 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 {
37586 #if wxUSE_UNICODE
37587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37588 #else
37589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37590 #endif
37591 }
37592 return resultobj;
37593 fail:
37594 return NULL;
37595 }
37596
37597
37598 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37599 PyObject *resultobj = 0;
37600 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37601 wxString *arg2 = 0 ;
37602 void *argp1 = 0 ;
37603 int res1 = 0 ;
37604 bool temp2 = false ;
37605 PyObject * obj0 = 0 ;
37606 PyObject * obj1 = 0 ;
37607 char * kwnames[] = {
37608 (char *) "self",(char *) "version", NULL
37609 };
37610
37611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37613 if (!SWIG_IsOK(res1)) {
37614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37615 }
37616 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37617 {
37618 arg2 = wxString_in_helper(obj1);
37619 if (arg2 == NULL) SWIG_fail;
37620 temp2 = true;
37621 }
37622 {
37623 PyThreadState* __tstate = wxPyBeginAllowThreads();
37624 (arg1)->SetVersion((wxString const &)*arg2);
37625 wxPyEndAllowThreads(__tstate);
37626 if (PyErr_Occurred()) SWIG_fail;
37627 }
37628 resultobj = SWIG_Py_Void();
37629 {
37630 if (temp2)
37631 delete arg2;
37632 }
37633 return resultobj;
37634 fail:
37635 {
37636 if (temp2)
37637 delete arg2;
37638 }
37639 return NULL;
37640 }
37641
37642
37643 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37644 PyObject *resultobj = 0;
37645 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37646 bool result;
37647 void *argp1 = 0 ;
37648 int res1 = 0 ;
37649 PyObject *swig_obj[1] ;
37650
37651 if (!args) SWIG_fail;
37652 swig_obj[0] = args;
37653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37654 if (!SWIG_IsOK(res1)) {
37655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37656 }
37657 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37658 {
37659 PyThreadState* __tstate = wxPyBeginAllowThreads();
37660 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37661 wxPyEndAllowThreads(__tstate);
37662 if (PyErr_Occurred()) SWIG_fail;
37663 }
37664 {
37665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37666 }
37667 return resultobj;
37668 fail:
37669 return NULL;
37670 }
37671
37672
37673 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37674 PyObject *resultobj = 0;
37675 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37676 wxString result;
37677 void *argp1 = 0 ;
37678 int res1 = 0 ;
37679 PyObject *swig_obj[1] ;
37680
37681 if (!args) SWIG_fail;
37682 swig_obj[0] = args;
37683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37684 if (!SWIG_IsOK(res1)) {
37685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37686 }
37687 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37688 {
37689 PyThreadState* __tstate = wxPyBeginAllowThreads();
37690 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37691 wxPyEndAllowThreads(__tstate);
37692 if (PyErr_Occurred()) SWIG_fail;
37693 }
37694 {
37695 #if wxUSE_UNICODE
37696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37697 #else
37698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37699 #endif
37700 }
37701 return resultobj;
37702 fail:
37703 return NULL;
37704 }
37705
37706
37707 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37708 PyObject *resultobj = 0;
37709 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37710 wxString *arg2 = 0 ;
37711 void *argp1 = 0 ;
37712 int res1 = 0 ;
37713 bool temp2 = false ;
37714 PyObject * obj0 = 0 ;
37715 PyObject * obj1 = 0 ;
37716 char * kwnames[] = {
37717 (char *) "self",(char *) "desc", NULL
37718 };
37719
37720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37722 if (!SWIG_IsOK(res1)) {
37723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37724 }
37725 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37726 {
37727 arg2 = wxString_in_helper(obj1);
37728 if (arg2 == NULL) SWIG_fail;
37729 temp2 = true;
37730 }
37731 {
37732 PyThreadState* __tstate = wxPyBeginAllowThreads();
37733 (arg1)->SetDescription((wxString const &)*arg2);
37734 wxPyEndAllowThreads(__tstate);
37735 if (PyErr_Occurred()) SWIG_fail;
37736 }
37737 resultobj = SWIG_Py_Void();
37738 {
37739 if (temp2)
37740 delete arg2;
37741 }
37742 return resultobj;
37743 fail:
37744 {
37745 if (temp2)
37746 delete arg2;
37747 }
37748 return NULL;
37749 }
37750
37751
37752 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37753 PyObject *resultobj = 0;
37754 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37755 bool result;
37756 void *argp1 = 0 ;
37757 int res1 = 0 ;
37758 PyObject *swig_obj[1] ;
37759
37760 if (!args) SWIG_fail;
37761 swig_obj[0] = args;
37762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37763 if (!SWIG_IsOK(res1)) {
37764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37765 }
37766 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37767 {
37768 PyThreadState* __tstate = wxPyBeginAllowThreads();
37769 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 {
37774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37775 }
37776 return resultobj;
37777 fail:
37778 return NULL;
37779 }
37780
37781
37782 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37783 PyObject *resultobj = 0;
37784 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37785 wxString result;
37786 void *argp1 = 0 ;
37787 int res1 = 0 ;
37788 PyObject *swig_obj[1] ;
37789
37790 if (!args) SWIG_fail;
37791 swig_obj[0] = args;
37792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37793 if (!SWIG_IsOK(res1)) {
37794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37795 }
37796 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37797 {
37798 PyThreadState* __tstate = wxPyBeginAllowThreads();
37799 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37800 wxPyEndAllowThreads(__tstate);
37801 if (PyErr_Occurred()) SWIG_fail;
37802 }
37803 {
37804 #if wxUSE_UNICODE
37805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37806 #else
37807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37808 #endif
37809 }
37810 return resultobj;
37811 fail:
37812 return NULL;
37813 }
37814
37815
37816 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37817 PyObject *resultobj = 0;
37818 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37819 wxString *arg2 = 0 ;
37820 void *argp1 = 0 ;
37821 int res1 = 0 ;
37822 bool temp2 = false ;
37823 PyObject * obj0 = 0 ;
37824 PyObject * obj1 = 0 ;
37825 char * kwnames[] = {
37826 (char *) "self",(char *) "copyright", NULL
37827 };
37828
37829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37831 if (!SWIG_IsOK(res1)) {
37832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37833 }
37834 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37835 {
37836 arg2 = wxString_in_helper(obj1);
37837 if (arg2 == NULL) SWIG_fail;
37838 temp2 = true;
37839 }
37840 {
37841 PyThreadState* __tstate = wxPyBeginAllowThreads();
37842 (arg1)->SetCopyright((wxString const &)*arg2);
37843 wxPyEndAllowThreads(__tstate);
37844 if (PyErr_Occurred()) SWIG_fail;
37845 }
37846 resultobj = SWIG_Py_Void();
37847 {
37848 if (temp2)
37849 delete arg2;
37850 }
37851 return resultobj;
37852 fail:
37853 {
37854 if (temp2)
37855 delete arg2;
37856 }
37857 return NULL;
37858 }
37859
37860
37861 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37862 PyObject *resultobj = 0;
37863 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37864 bool result;
37865 void *argp1 = 0 ;
37866 int res1 = 0 ;
37867 PyObject *swig_obj[1] ;
37868
37869 if (!args) SWIG_fail;
37870 swig_obj[0] = args;
37871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37872 if (!SWIG_IsOK(res1)) {
37873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37874 }
37875 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37876 {
37877 PyThreadState* __tstate = wxPyBeginAllowThreads();
37878 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37879 wxPyEndAllowThreads(__tstate);
37880 if (PyErr_Occurred()) SWIG_fail;
37881 }
37882 {
37883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37884 }
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37892 PyObject *resultobj = 0;
37893 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37894 wxString result;
37895 void *argp1 = 0 ;
37896 int res1 = 0 ;
37897 PyObject *swig_obj[1] ;
37898
37899 if (!args) SWIG_fail;
37900 swig_obj[0] = args;
37901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37902 if (!SWIG_IsOK(res1)) {
37903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37904 }
37905 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37909 wxPyEndAllowThreads(__tstate);
37910 if (PyErr_Occurred()) SWIG_fail;
37911 }
37912 {
37913 #if wxUSE_UNICODE
37914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37915 #else
37916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37917 #endif
37918 }
37919 return resultobj;
37920 fail:
37921 return NULL;
37922 }
37923
37924
37925 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37926 PyObject *resultobj = 0;
37927 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37928 wxString *arg2 = 0 ;
37929 void *argp1 = 0 ;
37930 int res1 = 0 ;
37931 bool temp2 = false ;
37932 PyObject * obj0 = 0 ;
37933 PyObject * obj1 = 0 ;
37934 char * kwnames[] = {
37935 (char *) "self",(char *) "licence", NULL
37936 };
37937
37938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37940 if (!SWIG_IsOK(res1)) {
37941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37942 }
37943 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37944 {
37945 arg2 = wxString_in_helper(obj1);
37946 if (arg2 == NULL) SWIG_fail;
37947 temp2 = true;
37948 }
37949 {
37950 PyThreadState* __tstate = wxPyBeginAllowThreads();
37951 (arg1)->SetLicence((wxString const &)*arg2);
37952 wxPyEndAllowThreads(__tstate);
37953 if (PyErr_Occurred()) SWIG_fail;
37954 }
37955 resultobj = SWIG_Py_Void();
37956 {
37957 if (temp2)
37958 delete arg2;
37959 }
37960 return resultobj;
37961 fail:
37962 {
37963 if (temp2)
37964 delete arg2;
37965 }
37966 return NULL;
37967 }
37968
37969
37970 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37971 PyObject *resultobj = 0;
37972 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37973 wxString *arg2 = 0 ;
37974 void *argp1 = 0 ;
37975 int res1 = 0 ;
37976 bool temp2 = false ;
37977 PyObject * obj0 = 0 ;
37978 PyObject * obj1 = 0 ;
37979 char * kwnames[] = {
37980 (char *) "self",(char *) "licence", NULL
37981 };
37982
37983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
37984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37985 if (!SWIG_IsOK(res1)) {
37986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37987 }
37988 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37989 {
37990 arg2 = wxString_in_helper(obj1);
37991 if (arg2 == NULL) SWIG_fail;
37992 temp2 = true;
37993 }
37994 {
37995 PyThreadState* __tstate = wxPyBeginAllowThreads();
37996 (arg1)->SetLicense((wxString const &)*arg2);
37997 wxPyEndAllowThreads(__tstate);
37998 if (PyErr_Occurred()) SWIG_fail;
37999 }
38000 resultobj = SWIG_Py_Void();
38001 {
38002 if (temp2)
38003 delete arg2;
38004 }
38005 return resultobj;
38006 fail:
38007 {
38008 if (temp2)
38009 delete arg2;
38010 }
38011 return NULL;
38012 }
38013
38014
38015 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38016 PyObject *resultobj = 0;
38017 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38018 bool result;
38019 void *argp1 = 0 ;
38020 int res1 = 0 ;
38021 PyObject *swig_obj[1] ;
38022
38023 if (!args) SWIG_fail;
38024 swig_obj[0] = args;
38025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38026 if (!SWIG_IsOK(res1)) {
38027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38028 }
38029 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38033 wxPyEndAllowThreads(__tstate);
38034 if (PyErr_Occurred()) SWIG_fail;
38035 }
38036 {
38037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38038 }
38039 return resultobj;
38040 fail:
38041 return NULL;
38042 }
38043
38044
38045 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38046 PyObject *resultobj = 0;
38047 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38048 wxString result;
38049 void *argp1 = 0 ;
38050 int res1 = 0 ;
38051 PyObject *swig_obj[1] ;
38052
38053 if (!args) SWIG_fail;
38054 swig_obj[0] = args;
38055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38056 if (!SWIG_IsOK(res1)) {
38057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38058 }
38059 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38060 {
38061 PyThreadState* __tstate = wxPyBeginAllowThreads();
38062 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38063 wxPyEndAllowThreads(__tstate);
38064 if (PyErr_Occurred()) SWIG_fail;
38065 }
38066 {
38067 #if wxUSE_UNICODE
38068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38069 #else
38070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38071 #endif
38072 }
38073 return resultobj;
38074 fail:
38075 return NULL;
38076 }
38077
38078
38079 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38080 PyObject *resultobj = 0;
38081 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38082 wxIcon *arg2 = 0 ;
38083 void *argp1 = 0 ;
38084 int res1 = 0 ;
38085 void *argp2 = 0 ;
38086 int res2 = 0 ;
38087 PyObject * obj0 = 0 ;
38088 PyObject * obj1 = 0 ;
38089 char * kwnames[] = {
38090 (char *) "self",(char *) "icon", NULL
38091 };
38092
38093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38095 if (!SWIG_IsOK(res1)) {
38096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38097 }
38098 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38099 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38100 if (!SWIG_IsOK(res2)) {
38101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38102 }
38103 if (!argp2) {
38104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38105 }
38106 arg2 = reinterpret_cast< wxIcon * >(argp2);
38107 {
38108 PyThreadState* __tstate = wxPyBeginAllowThreads();
38109 (arg1)->SetIcon((wxIcon const &)*arg2);
38110 wxPyEndAllowThreads(__tstate);
38111 if (PyErr_Occurred()) SWIG_fail;
38112 }
38113 resultobj = SWIG_Py_Void();
38114 return resultobj;
38115 fail:
38116 return NULL;
38117 }
38118
38119
38120 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38121 PyObject *resultobj = 0;
38122 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38123 bool result;
38124 void *argp1 = 0 ;
38125 int res1 = 0 ;
38126 PyObject *swig_obj[1] ;
38127
38128 if (!args) SWIG_fail;
38129 swig_obj[0] = args;
38130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38131 if (!SWIG_IsOK(res1)) {
38132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38133 }
38134 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38135 {
38136 PyThreadState* __tstate = wxPyBeginAllowThreads();
38137 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38138 wxPyEndAllowThreads(__tstate);
38139 if (PyErr_Occurred()) SWIG_fail;
38140 }
38141 {
38142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38143 }
38144 return resultobj;
38145 fail:
38146 return NULL;
38147 }
38148
38149
38150 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38151 PyObject *resultobj = 0;
38152 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38153 wxIcon result;
38154 void *argp1 = 0 ;
38155 int res1 = 0 ;
38156 PyObject *swig_obj[1] ;
38157
38158 if (!args) SWIG_fail;
38159 swig_obj[0] = args;
38160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38163 }
38164 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38172 return resultobj;
38173 fail:
38174 return NULL;
38175 }
38176
38177
38178 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38179 PyObject *resultobj = 0;
38180 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38181 wxString *arg2 = 0 ;
38182 wxString const &arg3_defvalue = wxEmptyString ;
38183 wxString *arg3 = (wxString *) &arg3_defvalue ;
38184 void *argp1 = 0 ;
38185 int res1 = 0 ;
38186 bool temp2 = false ;
38187 bool temp3 = false ;
38188 PyObject * obj0 = 0 ;
38189 PyObject * obj1 = 0 ;
38190 PyObject * obj2 = 0 ;
38191 char * kwnames[] = {
38192 (char *) "self",(char *) "url",(char *) "desc", NULL
38193 };
38194
38195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38197 if (!SWIG_IsOK(res1)) {
38198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38199 }
38200 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38201 {
38202 arg2 = wxString_in_helper(obj1);
38203 if (arg2 == NULL) SWIG_fail;
38204 temp2 = true;
38205 }
38206 if (obj2) {
38207 {
38208 arg3 = wxString_in_helper(obj2);
38209 if (arg3 == NULL) SWIG_fail;
38210 temp3 = true;
38211 }
38212 }
38213 {
38214 PyThreadState* __tstate = wxPyBeginAllowThreads();
38215 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38216 wxPyEndAllowThreads(__tstate);
38217 if (PyErr_Occurred()) SWIG_fail;
38218 }
38219 resultobj = SWIG_Py_Void();
38220 {
38221 if (temp2)
38222 delete arg2;
38223 }
38224 {
38225 if (temp3)
38226 delete arg3;
38227 }
38228 return resultobj;
38229 fail:
38230 {
38231 if (temp2)
38232 delete arg2;
38233 }
38234 {
38235 if (temp3)
38236 delete arg3;
38237 }
38238 return NULL;
38239 }
38240
38241
38242 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38243 PyObject *resultobj = 0;
38244 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38245 wxString result;
38246 void *argp1 = 0 ;
38247 int res1 = 0 ;
38248 PyObject *swig_obj[1] ;
38249
38250 if (!args) SWIG_fail;
38251 swig_obj[0] = args;
38252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38253 if (!SWIG_IsOK(res1)) {
38254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38255 }
38256 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38257 {
38258 PyThreadState* __tstate = wxPyBeginAllowThreads();
38259 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38260 wxPyEndAllowThreads(__tstate);
38261 if (PyErr_Occurred()) SWIG_fail;
38262 }
38263 {
38264 #if wxUSE_UNICODE
38265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38266 #else
38267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38268 #endif
38269 }
38270 return resultobj;
38271 fail:
38272 return NULL;
38273 }
38274
38275
38276 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38277 PyObject *resultobj = 0;
38278 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38279 wxString result;
38280 void *argp1 = 0 ;
38281 int res1 = 0 ;
38282 PyObject *swig_obj[1] ;
38283
38284 if (!args) SWIG_fail;
38285 swig_obj[0] = args;
38286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38287 if (!SWIG_IsOK(res1)) {
38288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38289 }
38290 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38291 {
38292 PyThreadState* __tstate = wxPyBeginAllowThreads();
38293 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38294 wxPyEndAllowThreads(__tstate);
38295 if (PyErr_Occurred()) SWIG_fail;
38296 }
38297 {
38298 #if wxUSE_UNICODE
38299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38300 #else
38301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38302 #endif
38303 }
38304 return resultobj;
38305 fail:
38306 return NULL;
38307 }
38308
38309
38310 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38311 PyObject *resultobj = 0;
38312 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38313 bool result;
38314 void *argp1 = 0 ;
38315 int res1 = 0 ;
38316 PyObject *swig_obj[1] ;
38317
38318 if (!args) SWIG_fail;
38319 swig_obj[0] = args;
38320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38321 if (!SWIG_IsOK(res1)) {
38322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38323 }
38324 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38328 wxPyEndAllowThreads(__tstate);
38329 if (PyErr_Occurred()) SWIG_fail;
38330 }
38331 {
38332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38333 }
38334 return resultobj;
38335 fail:
38336 return NULL;
38337 }
38338
38339
38340 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38341 PyObject *resultobj = 0;
38342 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38343 wxArrayString *arg2 = 0 ;
38344 void *argp1 = 0 ;
38345 int res1 = 0 ;
38346 bool temp2 = false ;
38347 PyObject * obj0 = 0 ;
38348 PyObject * obj1 = 0 ;
38349 char * kwnames[] = {
38350 (char *) "self",(char *) "developers", NULL
38351 };
38352
38353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38355 if (!SWIG_IsOK(res1)) {
38356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38357 }
38358 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38359 {
38360 if (! PySequence_Check(obj1)) {
38361 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38362 SWIG_fail;
38363 }
38364 arg2 = new wxArrayString;
38365 temp2 = true;
38366 int i, len=PySequence_Length(obj1);
38367 for (i=0; i<len; i++) {
38368 PyObject* item = PySequence_GetItem(obj1, i);
38369 wxString* s = wxString_in_helper(item);
38370 if (PyErr_Occurred()) SWIG_fail;
38371 arg2->Add(*s);
38372 delete s;
38373 Py_DECREF(item);
38374 }
38375 }
38376 {
38377 PyThreadState* __tstate = wxPyBeginAllowThreads();
38378 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38379 wxPyEndAllowThreads(__tstate);
38380 if (PyErr_Occurred()) SWIG_fail;
38381 }
38382 resultobj = SWIG_Py_Void();
38383 {
38384 if (temp2) delete arg2;
38385 }
38386 return resultobj;
38387 fail:
38388 {
38389 if (temp2) delete arg2;
38390 }
38391 return NULL;
38392 }
38393
38394
38395 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj = 0;
38397 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38398 wxString *arg2 = 0 ;
38399 void *argp1 = 0 ;
38400 int res1 = 0 ;
38401 bool temp2 = false ;
38402 PyObject * obj0 = 0 ;
38403 PyObject * obj1 = 0 ;
38404 char * kwnames[] = {
38405 (char *) "self",(char *) "developer", NULL
38406 };
38407
38408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38410 if (!SWIG_IsOK(res1)) {
38411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38412 }
38413 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38414 {
38415 arg2 = wxString_in_helper(obj1);
38416 if (arg2 == NULL) SWIG_fail;
38417 temp2 = true;
38418 }
38419 {
38420 PyThreadState* __tstate = wxPyBeginAllowThreads();
38421 (arg1)->AddDeveloper((wxString const &)*arg2);
38422 wxPyEndAllowThreads(__tstate);
38423 if (PyErr_Occurred()) SWIG_fail;
38424 }
38425 resultobj = SWIG_Py_Void();
38426 {
38427 if (temp2)
38428 delete arg2;
38429 }
38430 return resultobj;
38431 fail:
38432 {
38433 if (temp2)
38434 delete arg2;
38435 }
38436 return NULL;
38437 }
38438
38439
38440 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38441 PyObject *resultobj = 0;
38442 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38443 bool result;
38444 void *argp1 = 0 ;
38445 int res1 = 0 ;
38446 PyObject *swig_obj[1] ;
38447
38448 if (!args) SWIG_fail;
38449 swig_obj[0] = args;
38450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38451 if (!SWIG_IsOK(res1)) {
38452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38453 }
38454 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38455 {
38456 PyThreadState* __tstate = wxPyBeginAllowThreads();
38457 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38458 wxPyEndAllowThreads(__tstate);
38459 if (PyErr_Occurred()) SWIG_fail;
38460 }
38461 {
38462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38463 }
38464 return resultobj;
38465 fail:
38466 return NULL;
38467 }
38468
38469
38470 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38471 PyObject *resultobj = 0;
38472 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38473 wxArrayString *result = 0 ;
38474 void *argp1 = 0 ;
38475 int res1 = 0 ;
38476 PyObject *swig_obj[1] ;
38477
38478 if (!args) SWIG_fail;
38479 swig_obj[0] = args;
38480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38481 if (!SWIG_IsOK(res1)) {
38482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38483 }
38484 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38485 {
38486 PyThreadState* __tstate = wxPyBeginAllowThreads();
38487 {
38488 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38489 result = (wxArrayString *) &_result_ref;
38490 }
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 {
38495 resultobj = wxArrayString2PyList_helper(*result);
38496 }
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj = 0;
38505 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38506 wxArrayString *arg2 = 0 ;
38507 void *argp1 = 0 ;
38508 int res1 = 0 ;
38509 bool temp2 = false ;
38510 PyObject * obj0 = 0 ;
38511 PyObject * obj1 = 0 ;
38512 char * kwnames[] = {
38513 (char *) "self",(char *) "docwriters", NULL
38514 };
38515
38516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38518 if (!SWIG_IsOK(res1)) {
38519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38520 }
38521 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38522 {
38523 if (! PySequence_Check(obj1)) {
38524 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38525 SWIG_fail;
38526 }
38527 arg2 = new wxArrayString;
38528 temp2 = true;
38529 int i, len=PySequence_Length(obj1);
38530 for (i=0; i<len; i++) {
38531 PyObject* item = PySequence_GetItem(obj1, i);
38532 wxString* s = wxString_in_helper(item);
38533 if (PyErr_Occurred()) SWIG_fail;
38534 arg2->Add(*s);
38535 delete s;
38536 Py_DECREF(item);
38537 }
38538 }
38539 {
38540 PyThreadState* __tstate = wxPyBeginAllowThreads();
38541 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38542 wxPyEndAllowThreads(__tstate);
38543 if (PyErr_Occurred()) SWIG_fail;
38544 }
38545 resultobj = SWIG_Py_Void();
38546 {
38547 if (temp2) delete arg2;
38548 }
38549 return resultobj;
38550 fail:
38551 {
38552 if (temp2) delete arg2;
38553 }
38554 return NULL;
38555 }
38556
38557
38558 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38559 PyObject *resultobj = 0;
38560 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38561 wxString *arg2 = 0 ;
38562 void *argp1 = 0 ;
38563 int res1 = 0 ;
38564 bool temp2 = false ;
38565 PyObject * obj0 = 0 ;
38566 PyObject * obj1 = 0 ;
38567 char * kwnames[] = {
38568 (char *) "self",(char *) "docwriter", NULL
38569 };
38570
38571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38573 if (!SWIG_IsOK(res1)) {
38574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38575 }
38576 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38577 {
38578 arg2 = wxString_in_helper(obj1);
38579 if (arg2 == NULL) SWIG_fail;
38580 temp2 = true;
38581 }
38582 {
38583 PyThreadState* __tstate = wxPyBeginAllowThreads();
38584 (arg1)->AddDocWriter((wxString const &)*arg2);
38585 wxPyEndAllowThreads(__tstate);
38586 if (PyErr_Occurred()) SWIG_fail;
38587 }
38588 resultobj = SWIG_Py_Void();
38589 {
38590 if (temp2)
38591 delete arg2;
38592 }
38593 return resultobj;
38594 fail:
38595 {
38596 if (temp2)
38597 delete arg2;
38598 }
38599 return NULL;
38600 }
38601
38602
38603 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38604 PyObject *resultobj = 0;
38605 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38606 bool result;
38607 void *argp1 = 0 ;
38608 int res1 = 0 ;
38609 PyObject *swig_obj[1] ;
38610
38611 if (!args) SWIG_fail;
38612 swig_obj[0] = args;
38613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38616 }
38617 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38621 wxPyEndAllowThreads(__tstate);
38622 if (PyErr_Occurred()) SWIG_fail;
38623 }
38624 {
38625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38626 }
38627 return resultobj;
38628 fail:
38629 return NULL;
38630 }
38631
38632
38633 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38634 PyObject *resultobj = 0;
38635 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38636 wxArrayString *result = 0 ;
38637 void *argp1 = 0 ;
38638 int res1 = 0 ;
38639 PyObject *swig_obj[1] ;
38640
38641 if (!args) SWIG_fail;
38642 swig_obj[0] = args;
38643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38644 if (!SWIG_IsOK(res1)) {
38645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38646 }
38647 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38648 {
38649 PyThreadState* __tstate = wxPyBeginAllowThreads();
38650 {
38651 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38652 result = (wxArrayString *) &_result_ref;
38653 }
38654 wxPyEndAllowThreads(__tstate);
38655 if (PyErr_Occurred()) SWIG_fail;
38656 }
38657 {
38658 resultobj = wxArrayString2PyList_helper(*result);
38659 }
38660 return resultobj;
38661 fail:
38662 return NULL;
38663 }
38664
38665
38666 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38667 PyObject *resultobj = 0;
38668 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38669 wxArrayString *arg2 = 0 ;
38670 void *argp1 = 0 ;
38671 int res1 = 0 ;
38672 bool temp2 = false ;
38673 PyObject * obj0 = 0 ;
38674 PyObject * obj1 = 0 ;
38675 char * kwnames[] = {
38676 (char *) "self",(char *) "artists", NULL
38677 };
38678
38679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38681 if (!SWIG_IsOK(res1)) {
38682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38683 }
38684 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38685 {
38686 if (! PySequence_Check(obj1)) {
38687 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38688 SWIG_fail;
38689 }
38690 arg2 = new wxArrayString;
38691 temp2 = true;
38692 int i, len=PySequence_Length(obj1);
38693 for (i=0; i<len; i++) {
38694 PyObject* item = PySequence_GetItem(obj1, i);
38695 wxString* s = wxString_in_helper(item);
38696 if (PyErr_Occurred()) SWIG_fail;
38697 arg2->Add(*s);
38698 delete s;
38699 Py_DECREF(item);
38700 }
38701 }
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 (arg1)->SetArtists((wxArrayString const &)*arg2);
38705 wxPyEndAllowThreads(__tstate);
38706 if (PyErr_Occurred()) SWIG_fail;
38707 }
38708 resultobj = SWIG_Py_Void();
38709 {
38710 if (temp2) delete arg2;
38711 }
38712 return resultobj;
38713 fail:
38714 {
38715 if (temp2) delete arg2;
38716 }
38717 return NULL;
38718 }
38719
38720
38721 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38722 PyObject *resultobj = 0;
38723 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38724 wxString *arg2 = 0 ;
38725 void *argp1 = 0 ;
38726 int res1 = 0 ;
38727 bool temp2 = false ;
38728 PyObject * obj0 = 0 ;
38729 PyObject * obj1 = 0 ;
38730 char * kwnames[] = {
38731 (char *) "self",(char *) "artist", NULL
38732 };
38733
38734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38736 if (!SWIG_IsOK(res1)) {
38737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38738 }
38739 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38740 {
38741 arg2 = wxString_in_helper(obj1);
38742 if (arg2 == NULL) SWIG_fail;
38743 temp2 = true;
38744 }
38745 {
38746 PyThreadState* __tstate = wxPyBeginAllowThreads();
38747 (arg1)->AddArtist((wxString const &)*arg2);
38748 wxPyEndAllowThreads(__tstate);
38749 if (PyErr_Occurred()) SWIG_fail;
38750 }
38751 resultobj = SWIG_Py_Void();
38752 {
38753 if (temp2)
38754 delete arg2;
38755 }
38756 return resultobj;
38757 fail:
38758 {
38759 if (temp2)
38760 delete arg2;
38761 }
38762 return NULL;
38763 }
38764
38765
38766 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38767 PyObject *resultobj = 0;
38768 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38769 bool result;
38770 void *argp1 = 0 ;
38771 int res1 = 0 ;
38772 PyObject *swig_obj[1] ;
38773
38774 if (!args) SWIG_fail;
38775 swig_obj[0] = args;
38776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38777 if (!SWIG_IsOK(res1)) {
38778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38779 }
38780 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38781 {
38782 PyThreadState* __tstate = wxPyBeginAllowThreads();
38783 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38784 wxPyEndAllowThreads(__tstate);
38785 if (PyErr_Occurred()) SWIG_fail;
38786 }
38787 {
38788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38789 }
38790 return resultobj;
38791 fail:
38792 return NULL;
38793 }
38794
38795
38796 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38797 PyObject *resultobj = 0;
38798 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38799 wxArrayString *result = 0 ;
38800 void *argp1 = 0 ;
38801 int res1 = 0 ;
38802 PyObject *swig_obj[1] ;
38803
38804 if (!args) SWIG_fail;
38805 swig_obj[0] = args;
38806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38807 if (!SWIG_IsOK(res1)) {
38808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38809 }
38810 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 {
38814 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38815 result = (wxArrayString *) &_result_ref;
38816 }
38817 wxPyEndAllowThreads(__tstate);
38818 if (PyErr_Occurred()) SWIG_fail;
38819 }
38820 {
38821 resultobj = wxArrayString2PyList_helper(*result);
38822 }
38823 return resultobj;
38824 fail:
38825 return NULL;
38826 }
38827
38828
38829 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38830 PyObject *resultobj = 0;
38831 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38832 wxArrayString *arg2 = 0 ;
38833 void *argp1 = 0 ;
38834 int res1 = 0 ;
38835 bool temp2 = false ;
38836 PyObject * obj0 = 0 ;
38837 PyObject * obj1 = 0 ;
38838 char * kwnames[] = {
38839 (char *) "self",(char *) "translators", NULL
38840 };
38841
38842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38844 if (!SWIG_IsOK(res1)) {
38845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38846 }
38847 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38848 {
38849 if (! PySequence_Check(obj1)) {
38850 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38851 SWIG_fail;
38852 }
38853 arg2 = new wxArrayString;
38854 temp2 = true;
38855 int i, len=PySequence_Length(obj1);
38856 for (i=0; i<len; i++) {
38857 PyObject* item = PySequence_GetItem(obj1, i);
38858 wxString* s = wxString_in_helper(item);
38859 if (PyErr_Occurred()) SWIG_fail;
38860 arg2->Add(*s);
38861 delete s;
38862 Py_DECREF(item);
38863 }
38864 }
38865 {
38866 PyThreadState* __tstate = wxPyBeginAllowThreads();
38867 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38868 wxPyEndAllowThreads(__tstate);
38869 if (PyErr_Occurred()) SWIG_fail;
38870 }
38871 resultobj = SWIG_Py_Void();
38872 {
38873 if (temp2) delete arg2;
38874 }
38875 return resultobj;
38876 fail:
38877 {
38878 if (temp2) delete arg2;
38879 }
38880 return NULL;
38881 }
38882
38883
38884 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38885 PyObject *resultobj = 0;
38886 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38887 wxString *arg2 = 0 ;
38888 void *argp1 = 0 ;
38889 int res1 = 0 ;
38890 bool temp2 = false ;
38891 PyObject * obj0 = 0 ;
38892 PyObject * obj1 = 0 ;
38893 char * kwnames[] = {
38894 (char *) "self",(char *) "translator", NULL
38895 };
38896
38897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38899 if (!SWIG_IsOK(res1)) {
38900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38901 }
38902 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38903 {
38904 arg2 = wxString_in_helper(obj1);
38905 if (arg2 == NULL) SWIG_fail;
38906 temp2 = true;
38907 }
38908 {
38909 PyThreadState* __tstate = wxPyBeginAllowThreads();
38910 (arg1)->AddTranslator((wxString const &)*arg2);
38911 wxPyEndAllowThreads(__tstate);
38912 if (PyErr_Occurred()) SWIG_fail;
38913 }
38914 resultobj = SWIG_Py_Void();
38915 {
38916 if (temp2)
38917 delete arg2;
38918 }
38919 return resultobj;
38920 fail:
38921 {
38922 if (temp2)
38923 delete arg2;
38924 }
38925 return NULL;
38926 }
38927
38928
38929 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38930 PyObject *resultobj = 0;
38931 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38932 bool result;
38933 void *argp1 = 0 ;
38934 int res1 = 0 ;
38935 PyObject *swig_obj[1] ;
38936
38937 if (!args) SWIG_fail;
38938 swig_obj[0] = args;
38939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38940 if (!SWIG_IsOK(res1)) {
38941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38942 }
38943 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38944 {
38945 PyThreadState* __tstate = wxPyBeginAllowThreads();
38946 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38947 wxPyEndAllowThreads(__tstate);
38948 if (PyErr_Occurred()) SWIG_fail;
38949 }
38950 {
38951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38952 }
38953 return resultobj;
38954 fail:
38955 return NULL;
38956 }
38957
38958
38959 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38960 PyObject *resultobj = 0;
38961 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38962 wxArrayString *result = 0 ;
38963 void *argp1 = 0 ;
38964 int res1 = 0 ;
38965 PyObject *swig_obj[1] ;
38966
38967 if (!args) SWIG_fail;
38968 swig_obj[0] = args;
38969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38970 if (!SWIG_IsOK(res1)) {
38971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38972 }
38973 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38974 {
38975 PyThreadState* __tstate = wxPyBeginAllowThreads();
38976 {
38977 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
38978 result = (wxArrayString *) &_result_ref;
38979 }
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = wxArrayString2PyList_helper(*result);
38985 }
38986 return resultobj;
38987 fail:
38988 return NULL;
38989 }
38990
38991
38992 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38993 PyObject *resultobj = 0;
38994 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38995 bool result;
38996 void *argp1 = 0 ;
38997 int res1 = 0 ;
38998 PyObject *swig_obj[1] ;
38999
39000 if (!args) SWIG_fail;
39001 swig_obj[0] = args;
39002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39003 if (!SWIG_IsOK(res1)) {
39004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39005 }
39006 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39007 {
39008 PyThreadState* __tstate = wxPyBeginAllowThreads();
39009 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39010 wxPyEndAllowThreads(__tstate);
39011 if (PyErr_Occurred()) SWIG_fail;
39012 }
39013 {
39014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39015 }
39016 return resultobj;
39017 fail:
39018 return NULL;
39019 }
39020
39021
39022 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39023 PyObject *resultobj = 0;
39024 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39025 wxString result;
39026 void *argp1 = 0 ;
39027 int res1 = 0 ;
39028 PyObject *swig_obj[1] ;
39029
39030 if (!args) SWIG_fail;
39031 swig_obj[0] = args;
39032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39033 if (!SWIG_IsOK(res1)) {
39034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39035 }
39036 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39037 {
39038 PyThreadState* __tstate = wxPyBeginAllowThreads();
39039 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39040 wxPyEndAllowThreads(__tstate);
39041 if (PyErr_Occurred()) SWIG_fail;
39042 }
39043 {
39044 #if wxUSE_UNICODE
39045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39046 #else
39047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39048 #endif
39049 }
39050 return resultobj;
39051 fail:
39052 return NULL;
39053 }
39054
39055
39056 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39057 PyObject *obj;
39058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39059 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39060 return SWIG_Py_Void();
39061 }
39062
39063 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39064 return SWIG_Python_InitShadowInstance(args);
39065 }
39066
39067 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39068 PyObject *resultobj = 0;
39069 wxAboutDialogInfo *arg1 = 0 ;
39070 void *argp1 = 0 ;
39071 int res1 = 0 ;
39072 PyObject * obj0 = 0 ;
39073 char * kwnames[] = {
39074 (char *) "info", NULL
39075 };
39076
39077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39078 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39079 if (!SWIG_IsOK(res1)) {
39080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39081 }
39082 if (!argp1) {
39083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39084 }
39085 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39086 {
39087 PyThreadState* __tstate = wxPyBeginAllowThreads();
39088 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39089 wxPyEndAllowThreads(__tstate);
39090 if (PyErr_Occurred()) SWIG_fail;
39091 }
39092 resultobj = SWIG_Py_Void();
39093 return resultobj;
39094 fail:
39095 return NULL;
39096 }
39097
39098
39099 static PyMethodDef SwigMethods[] = {
39100 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39101 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39102 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39103 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39104 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39105 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39106 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39107 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39108 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39109 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39110 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39111 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39112 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39113 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39114 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39115 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39116 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39117 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39118 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39119 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39120 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39121 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39122 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39123 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39124 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39125 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39126 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39127 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39128 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39129 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39130 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39131 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39132 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39133 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39134 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39135 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39136 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39137 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39138 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39139 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39140 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39141 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39142 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39143 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39144 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39145 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39146 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39147 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39148 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39149 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39151 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39152 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39153 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39154 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39155 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39156 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39157 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39158 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39159 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39160 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39161 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39162 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39163 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39164 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39165 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39166 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39167 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39168 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39169 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39170 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39171 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39172 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39173 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39174 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39175 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39176 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39178 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39179 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39180 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39181 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39182 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39183 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39184 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39185 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39186 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39187 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39188 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39189 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39190 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39196 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39197 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39198 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39199 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39200 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39201 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39202 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39203 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39204 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39205 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39206 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39207 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39208 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39209 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39210 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39212 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39214 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39215 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39216 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39217 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39218 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39219 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39220 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39221 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39222 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39223 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39224 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39225 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39226 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39227 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39228 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39229 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39235 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39236 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39238 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39239 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39241 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39242 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39243 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39244 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39245 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39246 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39247 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39249 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39250 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39251 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39252 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39253 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39255 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39256 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39257 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39258 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39259 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39260 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39261 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39263 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39264 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39267 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39268 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39269 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39271 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39272 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39273 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39274 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39276 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39277 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39278 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39279 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39280 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39281 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39282 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39283 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39284 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39285 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39286 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39288 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39289 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39291 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39292 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39293 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39294 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39295 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39296 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39297 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39298 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39299 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39300 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39301 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39302 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39305 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39306 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39307 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39308 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39309 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39310 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39312 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39313 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39314 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39316 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39318 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39319 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39320 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39324 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39326 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39327 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39328 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39329 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39330 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39331 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39332 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39333 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39334 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39335 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39336 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39337 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39338 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39339 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39340 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39341 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39342 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39344 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39345 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39346 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39347 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39348 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39349 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39350 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39351 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39352 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39353 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39354 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39355 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39356 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39357 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39359 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39361 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39363 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39365 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39366 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39367 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39368 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39369 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39370 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39371 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39372 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39373 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39374 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39375 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39376 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39377 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39378 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39379 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39381 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39382 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39383 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39384 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39385 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39387 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39388 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39389 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39390 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39391 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39392 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39393 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39395 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39396 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39397 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39398 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39399 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39400 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39401 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39402 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39403 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39404 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39405 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39411 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39415 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39418 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39419 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39420 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39421 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39422 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39423 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39424 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39426 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39427 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39428 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39429 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39430 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39431 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39432 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39433 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39434 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39436 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39437 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39438 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39439 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39440 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39441 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39442 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39443 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39444 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39445 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39446 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39447 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39449 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39450 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39451 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39452 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39453 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39454 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39455 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39456 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39457 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39458 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39459 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39460 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39461 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39462 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39463 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39464 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39465 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39466 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39467 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39468 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39469 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39470 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39471 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39472 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39473 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39474 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39475 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39476 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39477 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39478 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39479 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39480 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39481 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39482 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39483 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39484 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39485 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39486 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39487 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39488 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39489 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39490 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39491 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39492 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39493 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39494 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39495 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39496 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39497 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39498 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39499 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39500 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39501 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39502 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39503 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39504 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39506 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39507 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39508 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39509 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39510 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39511 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39512 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39515 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39516 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39517 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39518 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39519 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39520 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39522 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39523 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39526 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39527 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39528 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39529 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39530 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39531 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39532 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39533 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39534 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39537 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39538 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39539 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39540 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39541 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39542 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39543 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39544 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39545 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39546 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39547 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39548 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39549 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39550 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39551 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39552 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39553 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39554 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39555 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39556 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39557 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39558 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39559 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39560 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39561 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39562 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39563 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39564 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39565 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39566 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39567 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39568 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39570 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39572 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39575 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39576 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39577 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39578 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39579 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39580 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39581 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39582 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39583 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39584 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39585 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39586 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39589 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39590 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39591 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39594 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39595 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39596 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39597 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39598 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39599 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39600 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39601 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39603 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39604 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39606 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39625 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39627 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39628 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39629 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39631 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39632 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39633 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39634 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39636 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39638 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39639 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39641 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39642 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39643 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39644 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39645 { (char *)"FileConfig_GetGlobalFileName", (PyCFunction) _wrap_FileConfig_GetGlobalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"FileConfig_GetLocalFileName", (PyCFunction) _wrap_FileConfig_GetLocalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39648 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39649 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39651 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39652 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39653 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39654 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39657 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39668 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39672 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39673 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39674 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39675 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39681 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39682 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39687 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39688 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39710 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39711 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39712 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39713 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39714 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39726 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39727 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39753 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39754 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39755 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39756 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39769 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39770 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39771 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39772 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39773 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39774 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39776 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39778 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39780 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39782 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39784 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39786 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39788 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39792 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39793 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39797 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39808 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39809 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39810 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39814 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39815 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39816 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39817 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39818 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39819 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39821 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39822 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39824 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39826 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39828 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39830 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39832 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39837 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39838 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39839 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39840 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39841 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39844 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39848 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39856 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39857 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39858 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39859 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39860 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39861 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39864 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39865 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39866 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39868 { (char *)"DataFormat__GetId", (PyCFunction)_wrap_DataFormat__GetId, METH_O, NULL},
39869 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39871 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39872 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39873 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39881 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39883 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39885 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39886 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39888 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39889 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39892 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39893 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39894 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39896 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39897 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39898 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39900 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39901 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39903 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39904 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39907 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39908 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39910 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39912 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39913 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39915 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39916 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39917 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39918 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39919 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39921 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39922 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39923 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39925 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39926 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39927 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39928 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39930 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39932 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39933 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39934 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39935 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39936 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39940 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39942 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39946 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39947 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39948 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39949 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39950 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39951 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
39955 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
39957 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
39959 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
39960 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
39961 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
39962 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
39964 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39965 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
39967 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
39970 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
39971 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
39972 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39975 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39976 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
39977 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39978 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39979 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
39980 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
39981 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
39982 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
39983 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
39984 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
39985 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
39986 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
39991 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
39992 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
39994 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
39995 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
39996 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
39998 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
39999 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40000 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40001 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40003 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40004 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40005 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40006 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40007 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40008 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40009 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40010 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40011 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40012 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40013 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40014 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40015 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40016 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40017 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40018 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40019 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40020 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40022 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40023 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40024 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40026 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40027 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40028 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40029 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40030 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40032 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40034 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40035 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40036 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40037 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40038 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40039 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40040 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40041 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40042 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40043 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40044 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40045 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40046 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40048 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40049 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40051 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40052 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40053 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40054 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40055 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40056 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40057 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40058 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40059 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40060 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40061 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40062 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40063 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40065 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40066 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40068 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40069 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40070 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40071 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40072 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40073 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40074 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40075 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40076 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40077 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40078 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40079 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40081 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40082 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40083 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40084 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40085 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40086 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40087 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40088 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40090 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40091 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40092 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40093 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40094 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40095 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40096 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40097 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40098 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40099 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40100 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40101 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40102 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40103 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { NULL, NULL, 0, NULL }
40105 };
40106
40107
40108 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40109
40110 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40111 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40112 }
40113 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40114 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40115 }
40116 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40117 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40118 }
40119 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40120 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40121 }
40122 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40123 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40124 }
40125 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40126 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40127 }
40128 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40129 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40130 }
40131 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40132 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40133 }
40134 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40135 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40136 }
40137 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40138 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40139 }
40140 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40141 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40142 }
40143 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40144 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40145 }
40146 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40147 return (void *)((wxEvent *) ((wxPyEvent *) x));
40148 }
40149 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40150 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40151 }
40152 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40153 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40154 }
40155 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40156 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40157 }
40158 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40159 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40160 }
40161 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40162 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40163 }
40164 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40165 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40166 }
40167 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40168 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40169 }
40170 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40171 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40172 }
40173 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40174 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40175 }
40176 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40177 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40178 }
40179 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40180 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40181 }
40182 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40183 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40184 }
40185 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40186 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40187 }
40188 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40189 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40190 }
40191 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40192 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40193 }
40194 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40195 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40196 }
40197 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40198 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40199 }
40200 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40201 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40202 }
40203 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40204 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40205 }
40206 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40207 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40208 }
40209 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40210 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40211 }
40212 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40213 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40214 }
40215 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40216 return (void *)((wxEvent *) ((wxShowEvent *) x));
40217 }
40218 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40219 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40220 }
40221 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40222 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40223 }
40224 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40225 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40226 }
40227 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40228 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40229 }
40230 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40231 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40232 }
40233 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40234 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40235 }
40236 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40237 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40238 }
40239 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40240 return (void *)((wxConfigBase *) ((wxConfig *) x));
40241 }
40242 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40243 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40244 }
40245 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40246 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40247 }
40248 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40249 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40250 }
40251 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40252 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40253 }
40254 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40255 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40256 }
40257 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40258 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40259 }
40260 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40261 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40262 }
40263 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40264 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40265 }
40266 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40267 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40268 }
40269 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40270 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40271 }
40272 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40273 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40274 }
40275 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40276 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40277 }
40278 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40279 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40280 }
40281 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40282 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40283 }
40284 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40285 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40286 }
40287 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40288 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40289 }
40290 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40291 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40292 }
40293 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40294 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40295 }
40296 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40297 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40298 }
40299 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40300 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40301 }
40302 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40303 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40304 }
40305 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40306 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40307 }
40308 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40309 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40310 }
40311 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40312 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40313 }
40314 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40315 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40316 }
40317 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40318 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40319 }
40320 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40321 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40322 }
40323 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40324 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40325 }
40326 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40327 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40328 }
40329 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
40330 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
40331 }
40332 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40333 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40334 }
40335 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40336 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40337 }
40338 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40339 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40340 }
40341 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40342 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40343 }
40344 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
40345 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
40346 }
40347 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40348 return (void *)((wxObject *) ((wxSizerItem *) x));
40349 }
40350 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40351 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40352 }
40353 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40354 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40355 }
40356 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40357 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40358 }
40359 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40360 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40361 }
40362 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40363 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40364 }
40365 static void *_p_wxSizerTo_p_wxObject(void *x) {
40366 return (void *)((wxObject *) ((wxSizer *) x));
40367 }
40368 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40369 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40370 }
40371 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40372 return (void *)((wxObject *) ((wxFileHistory *) x));
40373 }
40374 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40375 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40376 }
40377 static void *_p_wxEventTo_p_wxObject(void *x) {
40378 return (void *)((wxObject *) ((wxEvent *) x));
40379 }
40380 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40381 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40382 }
40383 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40384 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40385 }
40386 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40387 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40388 }
40389 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40390 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40391 }
40392 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40393 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40394 }
40395 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40396 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40397 }
40398 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40399 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40400 }
40401 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40402 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40403 }
40404 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40405 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40406 }
40407 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40408 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40409 }
40410 static void *_p_wxControlTo_p_wxObject(void *x) {
40411 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40412 }
40413 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40414 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40415 }
40416 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40417 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40418 }
40419 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40420 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40421 }
40422 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40423 return (void *)((wxObject *) ((wxFSFile *) x));
40424 }
40425 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40426 return (void *)((wxObject *) ((wxClipboard *) x));
40427 }
40428 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40429 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40430 }
40431 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40432 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40433 }
40434 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40435 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40436 }
40437 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40438 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40439 }
40440 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40441 return (void *)((wxObject *) ((wxToolTip *) x));
40442 }
40443 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40444 return (void *)((wxObject *) ((wxMenuItem *) x));
40445 }
40446 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40447 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40448 }
40449 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40450 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40451 }
40452 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40454 }
40455 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40456 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40457 }
40458 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40459 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40460 }
40461 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40462 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40463 }
40464 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40465 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40466 }
40467 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40468 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40469 }
40470 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40471 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40472 }
40473 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40474 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40475 }
40476 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40477 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40478 }
40479 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40480 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40481 }
40482 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40483 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40484 }
40485 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40486 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40487 }
40488 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40489 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40490 }
40491 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40492 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40493 }
40494 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40495 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40496 }
40497 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40498 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40499 }
40500 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40501 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40502 }
40503 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40504 return (void *)((wxObject *) ((wxImageHandler *) x));
40505 }
40506 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40507 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40508 }
40509 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40510 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40511 }
40512 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40513 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40514 }
40515 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40516 return (void *)((wxObject *) ((wxEvtHandler *) x));
40517 }
40518 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40519 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40520 }
40521 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40522 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40523 }
40524 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40525 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40526 }
40527 static void *_p_wxImageTo_p_wxObject(void *x) {
40528 return (void *)((wxObject *) ((wxImage *) x));
40529 }
40530 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40531 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40532 }
40533 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40534 return (void *)((wxObject *) ((wxSystemOptions *) x));
40535 }
40536 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40537 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40538 }
40539 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40540 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40541 }
40542 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40543 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40544 }
40545 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40546 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40547 }
40548 static void *_p_wxWindowTo_p_wxObject(void *x) {
40549 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40550 }
40551 static void *_p_wxMenuTo_p_wxObject(void *x) {
40552 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40553 }
40554 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40555 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40556 }
40557 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40558 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40559 }
40560 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40561 return (void *)((wxObject *) ((wxFileSystem *) x));
40562 }
40563 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40564 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40565 }
40566 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40567 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40568 }
40569 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40570 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40571 }
40572 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40573 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40574 }
40575 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40576 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40577 }
40578 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40579 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40580 }
40581 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40582 return (void *)((wxObject *) ((wxBusyInfo *) x));
40583 }
40584 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40585 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40586 }
40587 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40588 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40589 }
40590 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40591 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40592 }
40593 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40594 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40595 }
40596 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40597 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40598 }
40599 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40600 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40601 }
40602 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40603 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40604 }
40605 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40606 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40607 }
40608 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40609 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40610 }
40611 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40612 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40613 }
40614 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40615 return (void *)((wxLog *) ((wxLogBuffer *) x));
40616 }
40617 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40618 return (void *)((wxLog *) ((wxLogStderr *) x));
40619 }
40620 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40621 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40622 }
40623 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40624 return (void *)((wxLog *) ((wxLogWindow *) x));
40625 }
40626 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40627 return (void *)((wxLog *) ((wxLogChain *) x));
40628 }
40629 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40630 return (void *)((wxLog *) ((wxLogGui *) x));
40631 }
40632 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40633 return (void *)((wxLog *) ((wxPyLog *) x));
40634 }
40635 static void *_p_wxControlTo_p_wxWindow(void *x) {
40636 return (void *)((wxWindow *) ((wxControl *) x));
40637 }
40638 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40639 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40640 }
40641 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40642 return (void *)((wxWindow *) ((wxMenuBar *) x));
40643 }
40644 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40645 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40646 }
40647 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40648 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40649 }
40650 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40651 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};
40652 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40653 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40654 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40655 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40656 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40657 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40658 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40659 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40660 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40661 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40662 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40663 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40664 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40665 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40666 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40667 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40668 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40669 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40670 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40671 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40672 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40673 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40674 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40675 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40676 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40677 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40678 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40679 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40680 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40681 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40682 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40683 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40684 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40685 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40686 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40687 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40688 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40689 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40690 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40691 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40692 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40693 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40694 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40695 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40696 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40697 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40698 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40699 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40700 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40701 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40702 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40703 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40704 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40705 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40706 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40707 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40708 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40709 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40710 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40711 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40712 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40713 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40714 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40715 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40716 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40717 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40718 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40719 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40720 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40721 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40722 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40724 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40725 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40726 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40727 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40728 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40729 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
40730 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40736 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40737 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40738 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40739 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40740 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40741 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40742 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40743 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40744 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40745 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40746 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40747 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40748 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40749 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40750 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40751 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40752 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40753 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40754 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40755 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40773 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40774 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40775 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40776 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40777 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40778 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40779 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40780 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40781 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40782 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40783 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40784 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40785 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40786 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40812 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40813 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40814 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40815 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40816 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40818 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40819 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40820 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40821 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40822 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40823 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40824 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40825
40826 static swig_type_info *swig_type_initial[] = {
40827 &_swigt__p_char,
40828 &_swigt__p_form_ops_t,
40829 &_swigt__p_int,
40830 &_swigt__p_unsigned_char,
40831 &_swigt__p_unsigned_int,
40832 &_swigt__p_unsigned_long,
40833 &_swigt__p_void,
40834 &_swigt__p_wxANIHandler,
40835 &_swigt__p_wxAboutDialogInfo,
40836 &_swigt__p_wxAcceleratorTable,
40837 &_swigt__p_wxActivateEvent,
40838 &_swigt__p_wxArrayString,
40839 &_swigt__p_wxBMPHandler,
40840 &_swigt__p_wxBitmap,
40841 &_swigt__p_wxBitmapDataObject,
40842 &_swigt__p_wxBoxSizer,
40843 &_swigt__p_wxBusyCursor,
40844 &_swigt__p_wxBusyInfo,
40845 &_swigt__p_wxCURHandler,
40846 &_swigt__p_wxCaret,
40847 &_swigt__p_wxChar,
40848 &_swigt__p_wxChildFocusEvent,
40849 &_swigt__p_wxClipboard,
40850 &_swigt__p_wxClipboardLocker,
40851 &_swigt__p_wxClipboardTextEvent,
40852 &_swigt__p_wxCloseEvent,
40853 &_swigt__p_wxColour,
40854 &_swigt__p_wxCommandEvent,
40855 &_swigt__p_wxConfig,
40856 &_swigt__p_wxConfigBase,
40857 &_swigt__p_wxConfigPathChanger,
40858 &_swigt__p_wxContextMenuEvent,
40859 &_swigt__p_wxControl,
40860 &_swigt__p_wxControlWithItems,
40861 &_swigt__p_wxCursor,
40862 &_swigt__p_wxCustomDataObject,
40863 &_swigt__p_wxDC,
40864 &_swigt__p_wxDataFormat,
40865 &_swigt__p_wxDataObject,
40866 &_swigt__p_wxDataObjectComposite,
40867 &_swigt__p_wxDataObjectSimple,
40868 &_swigt__p_wxDateEvent,
40869 &_swigt__p_wxDateSpan,
40870 &_swigt__p_wxDateTime,
40871 &_swigt__p_wxDateTime__TimeZone,
40872 &_swigt__p_wxDisplay,
40873 &_swigt__p_wxDisplayChangedEvent,
40874 &_swigt__p_wxDropFilesEvent,
40875 &_swigt__p_wxDuplexMode,
40876 &_swigt__p_wxEraseEvent,
40877 &_swigt__p_wxEvent,
40878 &_swigt__p_wxEventBlocker,
40879 &_swigt__p_wxEvtHandler,
40880 &_swigt__p_wxFSFile,
40881 &_swigt__p_wxFileConfig,
40882 &_swigt__p_wxFileDataObject,
40883 &_swigt__p_wxFileHistory,
40884 &_swigt__p_wxFileSystem,
40885 &_swigt__p_wxFileType,
40886 &_swigt__p_wxFileTypeInfo,
40887 &_swigt__p_wxFlexGridSizer,
40888 &_swigt__p_wxFocusEvent,
40889 &_swigt__p_wxFont,
40890 &_swigt__p_wxFrame,
40891 &_swigt__p_wxGBSizerItem,
40892 &_swigt__p_wxGIFHandler,
40893 &_swigt__p_wxGridBagSizer,
40894 &_swigt__p_wxGridSizer,
40895 &_swigt__p_wxICOHandler,
40896 &_swigt__p_wxIcon,
40897 &_swigt__p_wxIconizeEvent,
40898 &_swigt__p_wxIdleEvent,
40899 &_swigt__p_wxImage,
40900 &_swigt__p_wxImageHandler,
40901 &_swigt__p_wxIndividualLayoutConstraint,
40902 &_swigt__p_wxInitDialogEvent,
40903 &_swigt__p_wxJPEGHandler,
40904 &_swigt__p_wxJoystick,
40905 &_swigt__p_wxJoystickEvent,
40906 &_swigt__p_wxKeyEvent,
40907 &_swigt__p_wxKillError,
40908 &_swigt__p_wxLayoutConstraints,
40909 &_swigt__p_wxLog,
40910 &_swigt__p_wxLogBuffer,
40911 &_swigt__p_wxLogChain,
40912 &_swigt__p_wxLogGui,
40913 &_swigt__p_wxLogNull,
40914 &_swigt__p_wxLogStderr,
40915 &_swigt__p_wxLogTextCtrl,
40916 &_swigt__p_wxLogWindow,
40917 &_swigt__p_wxMaximizeEvent,
40918 &_swigt__p_wxMenu,
40919 &_swigt__p_wxMenuBar,
40920 &_swigt__p_wxMenuEvent,
40921 &_swigt__p_wxMenuItem,
40922 &_swigt__p_wxMetafileDataObject,
40923 &_swigt__p_wxMimeTypesManager,
40924 &_swigt__p_wxMouseCaptureChangedEvent,
40925 &_swigt__p_wxMouseCaptureLostEvent,
40926 &_swigt__p_wxMouseEvent,
40927 &_swigt__p_wxMouseState,
40928 &_swigt__p_wxMoveEvent,
40929 &_swigt__p_wxMutexGuiLocker,
40930 &_swigt__p_wxNavigationKeyEvent,
40931 &_swigt__p_wxNcPaintEvent,
40932 &_swigt__p_wxNotifyEvent,
40933 &_swigt__p_wxObject,
40934 &_swigt__p_wxOutputStream,
40935 &_swigt__p_wxPCXHandler,
40936 &_swigt__p_wxPNGHandler,
40937 &_swigt__p_wxPNMHandler,
40938 &_swigt__p_wxPaintEvent,
40939 &_swigt__p_wxPaletteChangedEvent,
40940 &_swigt__p_wxPaperSize,
40941 &_swigt__p_wxPlatformInfo,
40942 &_swigt__p_wxPoint,
40943 &_swigt__p_wxPowerEvent,
40944 &_swigt__p_wxProcessEvent,
40945 &_swigt__p_wxPyApp,
40946 &_swigt__p_wxPyArtProvider,
40947 &_swigt__p_wxPyBitmapDataObject,
40948 &_swigt__p_wxPyCommandEvent,
40949 &_swigt__p_wxPyDataObjectSimple,
40950 &_swigt__p_wxPyDropSource,
40951 &_swigt__p_wxPyDropTarget,
40952 &_swigt__p_wxPyEvent,
40953 &_swigt__p_wxPyFileDropTarget,
40954 &_swigt__p_wxPyImageHandler,
40955 &_swigt__p_wxPyLog,
40956 &_swigt__p_wxPyProcess,
40957 &_swigt__p_wxPySizer,
40958 &_swigt__p_wxPyTextDataObject,
40959 &_swigt__p_wxPyTextDropTarget,
40960 &_swigt__p_wxPyTimer,
40961 &_swigt__p_wxPyTipProvider,
40962 &_swigt__p_wxPyValidator,
40963 &_swigt__p_wxQueryNewPaletteEvent,
40964 &_swigt__p_wxRect,
40965 &_swigt__p_wxScrollEvent,
40966 &_swigt__p_wxScrollWinEvent,
40967 &_swigt__p_wxSetCursorEvent,
40968 &_swigt__p_wxShowEvent,
40969 &_swigt__p_wxSingleInstanceChecker,
40970 &_swigt__p_wxSize,
40971 &_swigt__p_wxSizeEvent,
40972 &_swigt__p_wxSizer,
40973 &_swigt__p_wxSizerItem,
40974 &_swigt__p_wxSound,
40975 &_swigt__p_wxStandardPaths,
40976 &_swigt__p_wxStaticBoxSizer,
40977 &_swigt__p_wxStdDialogButtonSizer,
40978 &_swigt__p_wxStopWatch,
40979 &_swigt__p_wxString,
40980 &_swigt__p_wxSysColourChangedEvent,
40981 &_swigt__p_wxSystemOptions,
40982 &_swigt__p_wxSystemSettings,
40983 &_swigt__p_wxTGAHandler,
40984 &_swigt__p_wxTIFFHandler,
40985 &_swigt__p_wxTextCtrl,
40986 &_swigt__p_wxTextDataObject,
40987 &_swigt__p_wxTimeSpan,
40988 &_swigt__p_wxTimer,
40989 &_swigt__p_wxTimerEvent,
40990 &_swigt__p_wxTimerRunner,
40991 &_swigt__p_wxTipProvider,
40992 &_swigt__p_wxToolTip,
40993 &_swigt__p_wxURLDataObject,
40994 &_swigt__p_wxUpdateUIEvent,
40995 &_swigt__p_wxValidator,
40996 &_swigt__p_wxVideoMode,
40997 &_swigt__p_wxWindow,
40998 &_swigt__p_wxWindowCreateEvent,
40999 &_swigt__p_wxWindowDestroyEvent,
41000 &_swigt__p_wxWindowDisabler,
41001 &_swigt__p_wxXPMHandler,
41002 };
41003
41004 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41005 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41006 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41007 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41008 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41009 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41010 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41011 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41012 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41013 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41014 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}};
41015 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41016 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41017 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41018 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41019 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41020 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41021 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41022 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41023 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}};
41024 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41025 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41026 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41027 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41028 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41029 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}};
41030 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41031 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}};
41032 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41033 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41034 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41035 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41036 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41037 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41038 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41039 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41040 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41041 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41042 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41043 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41044 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41045 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41046 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41047 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41048 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41052 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41053 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41054 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41055 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41061 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41073 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41075 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}};
41076 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
41083 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_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41095 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}};
41096 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_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_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_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_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41150 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}};
41151 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41168 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}};
41169 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41173 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}};
41174 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41177 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}};
41178 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41179
41180 static swig_cast_info *swig_cast_initial[] = {
41181 _swigc__p_char,
41182 _swigc__p_form_ops_t,
41183 _swigc__p_int,
41184 _swigc__p_unsigned_char,
41185 _swigc__p_unsigned_int,
41186 _swigc__p_unsigned_long,
41187 _swigc__p_void,
41188 _swigc__p_wxANIHandler,
41189 _swigc__p_wxAboutDialogInfo,
41190 _swigc__p_wxAcceleratorTable,
41191 _swigc__p_wxActivateEvent,
41192 _swigc__p_wxArrayString,
41193 _swigc__p_wxBMPHandler,
41194 _swigc__p_wxBitmap,
41195 _swigc__p_wxBitmapDataObject,
41196 _swigc__p_wxBoxSizer,
41197 _swigc__p_wxBusyCursor,
41198 _swigc__p_wxBusyInfo,
41199 _swigc__p_wxCURHandler,
41200 _swigc__p_wxCaret,
41201 _swigc__p_wxChar,
41202 _swigc__p_wxChildFocusEvent,
41203 _swigc__p_wxClipboard,
41204 _swigc__p_wxClipboardLocker,
41205 _swigc__p_wxClipboardTextEvent,
41206 _swigc__p_wxCloseEvent,
41207 _swigc__p_wxColour,
41208 _swigc__p_wxCommandEvent,
41209 _swigc__p_wxConfig,
41210 _swigc__p_wxConfigBase,
41211 _swigc__p_wxConfigPathChanger,
41212 _swigc__p_wxContextMenuEvent,
41213 _swigc__p_wxControl,
41214 _swigc__p_wxControlWithItems,
41215 _swigc__p_wxCursor,
41216 _swigc__p_wxCustomDataObject,
41217 _swigc__p_wxDC,
41218 _swigc__p_wxDataFormat,
41219 _swigc__p_wxDataObject,
41220 _swigc__p_wxDataObjectComposite,
41221 _swigc__p_wxDataObjectSimple,
41222 _swigc__p_wxDateEvent,
41223 _swigc__p_wxDateSpan,
41224 _swigc__p_wxDateTime,
41225 _swigc__p_wxDateTime__TimeZone,
41226 _swigc__p_wxDisplay,
41227 _swigc__p_wxDisplayChangedEvent,
41228 _swigc__p_wxDropFilesEvent,
41229 _swigc__p_wxDuplexMode,
41230 _swigc__p_wxEraseEvent,
41231 _swigc__p_wxEvent,
41232 _swigc__p_wxEventBlocker,
41233 _swigc__p_wxEvtHandler,
41234 _swigc__p_wxFSFile,
41235 _swigc__p_wxFileConfig,
41236 _swigc__p_wxFileDataObject,
41237 _swigc__p_wxFileHistory,
41238 _swigc__p_wxFileSystem,
41239 _swigc__p_wxFileType,
41240 _swigc__p_wxFileTypeInfo,
41241 _swigc__p_wxFlexGridSizer,
41242 _swigc__p_wxFocusEvent,
41243 _swigc__p_wxFont,
41244 _swigc__p_wxFrame,
41245 _swigc__p_wxGBSizerItem,
41246 _swigc__p_wxGIFHandler,
41247 _swigc__p_wxGridBagSizer,
41248 _swigc__p_wxGridSizer,
41249 _swigc__p_wxICOHandler,
41250 _swigc__p_wxIcon,
41251 _swigc__p_wxIconizeEvent,
41252 _swigc__p_wxIdleEvent,
41253 _swigc__p_wxImage,
41254 _swigc__p_wxImageHandler,
41255 _swigc__p_wxIndividualLayoutConstraint,
41256 _swigc__p_wxInitDialogEvent,
41257 _swigc__p_wxJPEGHandler,
41258 _swigc__p_wxJoystick,
41259 _swigc__p_wxJoystickEvent,
41260 _swigc__p_wxKeyEvent,
41261 _swigc__p_wxKillError,
41262 _swigc__p_wxLayoutConstraints,
41263 _swigc__p_wxLog,
41264 _swigc__p_wxLogBuffer,
41265 _swigc__p_wxLogChain,
41266 _swigc__p_wxLogGui,
41267 _swigc__p_wxLogNull,
41268 _swigc__p_wxLogStderr,
41269 _swigc__p_wxLogTextCtrl,
41270 _swigc__p_wxLogWindow,
41271 _swigc__p_wxMaximizeEvent,
41272 _swigc__p_wxMenu,
41273 _swigc__p_wxMenuBar,
41274 _swigc__p_wxMenuEvent,
41275 _swigc__p_wxMenuItem,
41276 _swigc__p_wxMetafileDataObject,
41277 _swigc__p_wxMimeTypesManager,
41278 _swigc__p_wxMouseCaptureChangedEvent,
41279 _swigc__p_wxMouseCaptureLostEvent,
41280 _swigc__p_wxMouseEvent,
41281 _swigc__p_wxMouseState,
41282 _swigc__p_wxMoveEvent,
41283 _swigc__p_wxMutexGuiLocker,
41284 _swigc__p_wxNavigationKeyEvent,
41285 _swigc__p_wxNcPaintEvent,
41286 _swigc__p_wxNotifyEvent,
41287 _swigc__p_wxObject,
41288 _swigc__p_wxOutputStream,
41289 _swigc__p_wxPCXHandler,
41290 _swigc__p_wxPNGHandler,
41291 _swigc__p_wxPNMHandler,
41292 _swigc__p_wxPaintEvent,
41293 _swigc__p_wxPaletteChangedEvent,
41294 _swigc__p_wxPaperSize,
41295 _swigc__p_wxPlatformInfo,
41296 _swigc__p_wxPoint,
41297 _swigc__p_wxPowerEvent,
41298 _swigc__p_wxProcessEvent,
41299 _swigc__p_wxPyApp,
41300 _swigc__p_wxPyArtProvider,
41301 _swigc__p_wxPyBitmapDataObject,
41302 _swigc__p_wxPyCommandEvent,
41303 _swigc__p_wxPyDataObjectSimple,
41304 _swigc__p_wxPyDropSource,
41305 _swigc__p_wxPyDropTarget,
41306 _swigc__p_wxPyEvent,
41307 _swigc__p_wxPyFileDropTarget,
41308 _swigc__p_wxPyImageHandler,
41309 _swigc__p_wxPyLog,
41310 _swigc__p_wxPyProcess,
41311 _swigc__p_wxPySizer,
41312 _swigc__p_wxPyTextDataObject,
41313 _swigc__p_wxPyTextDropTarget,
41314 _swigc__p_wxPyTimer,
41315 _swigc__p_wxPyTipProvider,
41316 _swigc__p_wxPyValidator,
41317 _swigc__p_wxQueryNewPaletteEvent,
41318 _swigc__p_wxRect,
41319 _swigc__p_wxScrollEvent,
41320 _swigc__p_wxScrollWinEvent,
41321 _swigc__p_wxSetCursorEvent,
41322 _swigc__p_wxShowEvent,
41323 _swigc__p_wxSingleInstanceChecker,
41324 _swigc__p_wxSize,
41325 _swigc__p_wxSizeEvent,
41326 _swigc__p_wxSizer,
41327 _swigc__p_wxSizerItem,
41328 _swigc__p_wxSound,
41329 _swigc__p_wxStandardPaths,
41330 _swigc__p_wxStaticBoxSizer,
41331 _swigc__p_wxStdDialogButtonSizer,
41332 _swigc__p_wxStopWatch,
41333 _swigc__p_wxString,
41334 _swigc__p_wxSysColourChangedEvent,
41335 _swigc__p_wxSystemOptions,
41336 _swigc__p_wxSystemSettings,
41337 _swigc__p_wxTGAHandler,
41338 _swigc__p_wxTIFFHandler,
41339 _swigc__p_wxTextCtrl,
41340 _swigc__p_wxTextDataObject,
41341 _swigc__p_wxTimeSpan,
41342 _swigc__p_wxTimer,
41343 _swigc__p_wxTimerEvent,
41344 _swigc__p_wxTimerRunner,
41345 _swigc__p_wxTipProvider,
41346 _swigc__p_wxToolTip,
41347 _swigc__p_wxURLDataObject,
41348 _swigc__p_wxUpdateUIEvent,
41349 _swigc__p_wxValidator,
41350 _swigc__p_wxVideoMode,
41351 _swigc__p_wxWindow,
41352 _swigc__p_wxWindowCreateEvent,
41353 _swigc__p_wxWindowDestroyEvent,
41354 _swigc__p_wxWindowDisabler,
41355 _swigc__p_wxXPMHandler,
41356 };
41357
41358
41359 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41360
41361 static swig_const_info swig_const_table[] = {
41362 {0, 0, 0, 0.0, 0, 0}};
41363
41364 #ifdef __cplusplus
41365 }
41366 #endif
41367 /* -----------------------------------------------------------------------------
41368 * Type initialization:
41369 * This problem is tough by the requirement that no dynamic
41370 * memory is used. Also, since swig_type_info structures store pointers to
41371 * swig_cast_info structures and swig_cast_info structures store pointers back
41372 * to swig_type_info structures, we need some lookup code at initialization.
41373 * The idea is that swig generates all the structures that are needed.
41374 * The runtime then collects these partially filled structures.
41375 * The SWIG_InitializeModule function takes these initial arrays out of
41376 * swig_module, and does all the lookup, filling in the swig_module.types
41377 * array with the correct data and linking the correct swig_cast_info
41378 * structures together.
41379 *
41380 * The generated swig_type_info structures are assigned staticly to an initial
41381 * array. We just loop though that array, and handle each type individually.
41382 * First we lookup if this type has been already loaded, and if so, use the
41383 * loaded structure instead of the generated one. Then we have to fill in the
41384 * cast linked list. The cast data is initially stored in something like a
41385 * two-dimensional array. Each row corresponds to a type (there are the same
41386 * number of rows as there are in the swig_type_initial array). Each entry in
41387 * a column is one of the swig_cast_info structures for that type.
41388 * The cast_initial array is actually an array of arrays, because each row has
41389 * a variable number of columns. So to actually build the cast linked list,
41390 * we find the array of casts associated with the type, and loop through it
41391 * adding the casts to the list. The one last trick we need to do is making
41392 * sure the type pointer in the swig_cast_info struct is correct.
41393 *
41394 * First off, we lookup the cast->type name to see if it is already loaded.
41395 * There are three cases to handle:
41396 * 1) If the cast->type has already been loaded AND the type we are adding
41397 * casting info to has not been loaded (it is in this module), THEN we
41398 * replace the cast->type pointer with the type pointer that has already
41399 * been loaded.
41400 * 2) If BOTH types (the one we are adding casting info to, and the
41401 * cast->type) are loaded, THEN the cast info has already been loaded by
41402 * the previous module so we just ignore it.
41403 * 3) Finally, if cast->type has not already been loaded, then we add that
41404 * swig_cast_info to the linked list (because the cast->type) pointer will
41405 * be correct.
41406 * ----------------------------------------------------------------------------- */
41407
41408 #ifdef __cplusplus
41409 extern "C" {
41410 #if 0
41411 } /* c-mode */
41412 #endif
41413 #endif
41414
41415 #if 0
41416 #define SWIGRUNTIME_DEBUG
41417 #endif
41418
41419 SWIGRUNTIME void
41420 SWIG_InitializeModule(void *clientdata) {
41421 size_t i;
41422 swig_module_info *module_head;
41423 static int init_run = 0;
41424
41425 clientdata = clientdata;
41426
41427 if (init_run) return;
41428 init_run = 1;
41429
41430 /* Initialize the swig_module */
41431 swig_module.type_initial = swig_type_initial;
41432 swig_module.cast_initial = swig_cast_initial;
41433
41434 /* Try and load any already created modules */
41435 module_head = SWIG_GetModule(clientdata);
41436 if (module_head) {
41437 swig_module.next = module_head->next;
41438 module_head->next = &swig_module;
41439 } else {
41440 /* This is the first module loaded */
41441 swig_module.next = &swig_module;
41442 SWIG_SetModule(clientdata, &swig_module);
41443 }
41444
41445 /* Now work on filling in swig_module.types */
41446 #ifdef SWIGRUNTIME_DEBUG
41447 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41448 #endif
41449 for (i = 0; i < swig_module.size; ++i) {
41450 swig_type_info *type = 0;
41451 swig_type_info *ret;
41452 swig_cast_info *cast;
41453
41454 #ifdef SWIGRUNTIME_DEBUG
41455 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41456 #endif
41457
41458 /* if there is another module already loaded */
41459 if (swig_module.next != &swig_module) {
41460 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41461 }
41462 if (type) {
41463 /* Overwrite clientdata field */
41464 #ifdef SWIGRUNTIME_DEBUG
41465 printf("SWIG_InitializeModule: found type %s\n", type->name);
41466 #endif
41467 if (swig_module.type_initial[i]->clientdata) {
41468 type->clientdata = swig_module.type_initial[i]->clientdata;
41469 #ifdef SWIGRUNTIME_DEBUG
41470 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41471 #endif
41472 }
41473 } else {
41474 type = swig_module.type_initial[i];
41475 }
41476
41477 /* Insert casting types */
41478 cast = swig_module.cast_initial[i];
41479 while (cast->type) {
41480 /* Don't need to add information already in the list */
41481 ret = 0;
41482 #ifdef SWIGRUNTIME_DEBUG
41483 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41484 #endif
41485 if (swig_module.next != &swig_module) {
41486 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41487 #ifdef SWIGRUNTIME_DEBUG
41488 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41489 #endif
41490 }
41491 if (ret) {
41492 if (type == swig_module.type_initial[i]) {
41493 #ifdef SWIGRUNTIME_DEBUG
41494 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41495 #endif
41496 cast->type = ret;
41497 ret = 0;
41498 } else {
41499 /* Check for casting already in the list */
41500 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41501 #ifdef SWIGRUNTIME_DEBUG
41502 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41503 #endif
41504 if (!ocast) ret = 0;
41505 }
41506 }
41507
41508 if (!ret) {
41509 #ifdef SWIGRUNTIME_DEBUG
41510 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41511 #endif
41512 if (type->cast) {
41513 type->cast->prev = cast;
41514 cast->next = type->cast;
41515 }
41516 type->cast = cast;
41517 }
41518 cast++;
41519 }
41520 /* Set entry in modules->types array equal to the type */
41521 swig_module.types[i] = type;
41522 }
41523 swig_module.types[i] = 0;
41524
41525 #ifdef SWIGRUNTIME_DEBUG
41526 printf("**** SWIG_InitializeModule: Cast List ******\n");
41527 for (i = 0; i < swig_module.size; ++i) {
41528 int j = 0;
41529 swig_cast_info *cast = swig_module.cast_initial[i];
41530 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41531 while (cast->type) {
41532 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41533 cast++;
41534 ++j;
41535 }
41536 printf("---- Total casts: %d\n",j);
41537 }
41538 printf("**** SWIG_InitializeModule: Cast List ******\n");
41539 #endif
41540 }
41541
41542 /* This function will propagate the clientdata field of type to
41543 * any new swig_type_info structures that have been added into the list
41544 * of equivalent types. It is like calling
41545 * SWIG_TypeClientData(type, clientdata) a second time.
41546 */
41547 SWIGRUNTIME void
41548 SWIG_PropagateClientData(void) {
41549 size_t i;
41550 swig_cast_info *equiv;
41551 static int init_run = 0;
41552
41553 if (init_run) return;
41554 init_run = 1;
41555
41556 for (i = 0; i < swig_module.size; i++) {
41557 if (swig_module.types[i]->clientdata) {
41558 equiv = swig_module.types[i]->cast;
41559 while (equiv) {
41560 if (!equiv->converter) {
41561 if (equiv->type && !equiv->type->clientdata)
41562 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41563 }
41564 equiv = equiv->next;
41565 }
41566 }
41567 }
41568 }
41569
41570 #ifdef __cplusplus
41571 #if 0
41572 {
41573 /* c-mode */
41574 #endif
41575 }
41576 #endif
41577
41578
41579
41580 #ifdef __cplusplus
41581 extern "C" {
41582 #endif
41583
41584 /* Python-specific SWIG API */
41585 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41586 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41587 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41588
41589 /* -----------------------------------------------------------------------------
41590 * global variable support code.
41591 * ----------------------------------------------------------------------------- */
41592
41593 typedef struct swig_globalvar {
41594 char *name; /* Name of global variable */
41595 PyObject *(*get_attr)(void); /* Return the current value */
41596 int (*set_attr)(PyObject *); /* Set the value */
41597 struct swig_globalvar *next;
41598 } swig_globalvar;
41599
41600 typedef struct swig_varlinkobject {
41601 PyObject_HEAD
41602 swig_globalvar *vars;
41603 } swig_varlinkobject;
41604
41605 SWIGINTERN PyObject *
41606 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41607 return PyString_FromString("<Swig global variables>");
41608 }
41609
41610 SWIGINTERN PyObject *
41611 swig_varlink_str(swig_varlinkobject *v) {
41612 PyObject *str = PyString_FromString("(");
41613 swig_globalvar *var;
41614 for (var = v->vars; var; var=var->next) {
41615 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41616 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41617 }
41618 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41619 return str;
41620 }
41621
41622 SWIGINTERN int
41623 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41624 PyObject *str = swig_varlink_str(v);
41625 fprintf(fp,"Swig global variables ");
41626 fprintf(fp,"%s\n", PyString_AsString(str));
41627 Py_DECREF(str);
41628 return 0;
41629 }
41630
41631 SWIGINTERN void
41632 swig_varlink_dealloc(swig_varlinkobject *v) {
41633 swig_globalvar *var = v->vars;
41634 while (var) {
41635 swig_globalvar *n = var->next;
41636 free(var->name);
41637 free(var);
41638 var = n;
41639 }
41640 }
41641
41642 SWIGINTERN PyObject *
41643 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41644 PyObject *res = NULL;
41645 swig_globalvar *var = v->vars;
41646 while (var) {
41647 if (strcmp(var->name,n) == 0) {
41648 res = (*var->get_attr)();
41649 break;
41650 }
41651 var = var->next;
41652 }
41653 if (res == NULL && !PyErr_Occurred()) {
41654 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41655 }
41656 return res;
41657 }
41658
41659 SWIGINTERN int
41660 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41661 int res = 1;
41662 swig_globalvar *var = v->vars;
41663 while (var) {
41664 if (strcmp(var->name,n) == 0) {
41665 res = (*var->set_attr)(p);
41666 break;
41667 }
41668 var = var->next;
41669 }
41670 if (res == 1 && !PyErr_Occurred()) {
41671 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41672 }
41673 return res;
41674 }
41675
41676 SWIGINTERN PyTypeObject*
41677 swig_varlink_type(void) {
41678 static char varlink__doc__[] = "Swig var link object";
41679 static PyTypeObject varlink_type;
41680 static int type_init = 0;
41681 if (!type_init) {
41682 const PyTypeObject tmp
41683 = {
41684 PyObject_HEAD_INIT(NULL)
41685 0, /* Number of items in variable part (ob_size) */
41686 (char *)"swigvarlink", /* Type name (tp_name) */
41687 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41688 0, /* Itemsize (tp_itemsize) */
41689 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41690 (printfunc) swig_varlink_print, /* Print (tp_print) */
41691 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41692 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41693 0, /* tp_compare */
41694 (reprfunc) swig_varlink_repr, /* tp_repr */
41695 0, /* tp_as_number */
41696 0, /* tp_as_sequence */
41697 0, /* tp_as_mapping */
41698 0, /* tp_hash */
41699 0, /* tp_call */
41700 (reprfunc)swig_varlink_str, /* tp_str */
41701 0, /* tp_getattro */
41702 0, /* tp_setattro */
41703 0, /* tp_as_buffer */
41704 0, /* tp_flags */
41705 varlink__doc__, /* tp_doc */
41706 0, /* tp_traverse */
41707 0, /* tp_clear */
41708 0, /* tp_richcompare */
41709 0, /* tp_weaklistoffset */
41710 #if PY_VERSION_HEX >= 0x02020000
41711 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41712 #endif
41713 #if PY_VERSION_HEX >= 0x02030000
41714 0, /* tp_del */
41715 #endif
41716 #ifdef COUNT_ALLOCS
41717 0,0,0,0 /* tp_alloc -> tp_next */
41718 #endif
41719 };
41720 varlink_type = tmp;
41721 varlink_type.ob_type = &PyType_Type;
41722 type_init = 1;
41723 }
41724 return &varlink_type;
41725 }
41726
41727 /* Create a variable linking object for use later */
41728 SWIGINTERN PyObject *
41729 SWIG_Python_newvarlink(void) {
41730 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41731 if (result) {
41732 result->vars = 0;
41733 }
41734 return ((PyObject*) result);
41735 }
41736
41737 SWIGINTERN void
41738 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41739 swig_varlinkobject *v = (swig_varlinkobject *) p;
41740 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41741 if (gv) {
41742 size_t size = strlen(name)+1;
41743 gv->name = (char *)malloc(size);
41744 if (gv->name) {
41745 strncpy(gv->name,name,size);
41746 gv->get_attr = get_attr;
41747 gv->set_attr = set_attr;
41748 gv->next = v->vars;
41749 }
41750 }
41751 v->vars = gv;
41752 }
41753
41754 SWIGINTERN PyObject *
41755 SWIG_globals() {
41756 static PyObject *_SWIG_globals = 0;
41757 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41758 return _SWIG_globals;
41759 }
41760
41761 /* -----------------------------------------------------------------------------
41762 * constants/methods manipulation
41763 * ----------------------------------------------------------------------------- */
41764
41765 /* Install Constants */
41766 SWIGINTERN void
41767 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41768 PyObject *obj = 0;
41769 size_t i;
41770 for (i = 0; constants[i].type; ++i) {
41771 switch(constants[i].type) {
41772 case SWIG_PY_POINTER:
41773 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41774 break;
41775 case SWIG_PY_BINARY:
41776 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41777 break;
41778 default:
41779 obj = 0;
41780 break;
41781 }
41782 if (obj) {
41783 PyDict_SetItemString(d, constants[i].name, obj);
41784 Py_DECREF(obj);
41785 }
41786 }
41787 }
41788
41789 /* -----------------------------------------------------------------------------*/
41790 /* Fix SwigMethods to carry the callback ptrs when needed */
41791 /* -----------------------------------------------------------------------------*/
41792
41793 SWIGINTERN void
41794 SWIG_Python_FixMethods(PyMethodDef *methods,
41795 swig_const_info *const_table,
41796 swig_type_info **types,
41797 swig_type_info **types_initial) {
41798 size_t i;
41799 for (i = 0; methods[i].ml_name; ++i) {
41800 const char *c = methods[i].ml_doc;
41801 if (c && (c = strstr(c, "swig_ptr: "))) {
41802 int j;
41803 swig_const_info *ci = 0;
41804 const char *name = c + 10;
41805 for (j = 0; const_table[j].type; ++j) {
41806 if (strncmp(const_table[j].name, name,
41807 strlen(const_table[j].name)) == 0) {
41808 ci = &(const_table[j]);
41809 break;
41810 }
41811 }
41812 if (ci) {
41813 size_t shift = (ci->ptype) - types;
41814 swig_type_info *ty = types_initial[shift];
41815 size_t ldoc = (c - methods[i].ml_doc);
41816 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41817 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41818 if (ndoc) {
41819 char *buff = ndoc;
41820 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41821 if (ptr) {
41822 strncpy(buff, methods[i].ml_doc, ldoc);
41823 buff += ldoc;
41824 strncpy(buff, "swig_ptr: ", 10);
41825 buff += 10;
41826 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41827 methods[i].ml_doc = ndoc;
41828 }
41829 }
41830 }
41831 }
41832 }
41833 }
41834
41835 #ifdef __cplusplus
41836 }
41837 #endif
41838
41839 /* -----------------------------------------------------------------------------*
41840 * Partial Init method
41841 * -----------------------------------------------------------------------------*/
41842
41843 #ifdef __cplusplus
41844 extern "C"
41845 #endif
41846 SWIGEXPORT void SWIG_init(void) {
41847 PyObject *m, *d;
41848
41849 /* Fix SwigMethods to carry the callback ptrs when needed */
41850 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41851
41852 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41853 d = PyModule_GetDict(m);
41854
41855 SWIG_InitializeModule(0);
41856 SWIG_InstallConstants(d,swig_const_table);
41857
41858
41859 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41860 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41861 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41862 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41863 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41864 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41865 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41866 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41867 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41868 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41869 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41870 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41871 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41872 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41873 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41874 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41875 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41876 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41877 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41878 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41879 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41880 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41881 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41882 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41883 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41884 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41885 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41886 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41887 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41888 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41889 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41890 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41891 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41892 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41893 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41894 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41895 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41896 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41897 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41898 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41899 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41900 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41901 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41902 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41903 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41904 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41905 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41906 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41907 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41908 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41909 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41910 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41911 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41912 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41913 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41914 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41915 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41916 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41917 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41918 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41919 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41920 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41921 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41922 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41923 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41924 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41925 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41926 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41927 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41928 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41929 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41930 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41931 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41932 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41933 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41934 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41935 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41936 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41937 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41938 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41939 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41940 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41941 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41942 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41943 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41944 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41945 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41946 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41947 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41948 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41949 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41950 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41951 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41952 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41953 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41954 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41955 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41956 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41957 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41958 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41959 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41960 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41961 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
41962 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
41963 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
41964 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
41965 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
41966 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
41967 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
41968 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
41969 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
41970 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
41971 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
41972 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
41973 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
41974 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
41975 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
41976 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
41977 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
41978 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
41979 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
41980 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
41981 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
41982 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
41983 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
41984 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
41985 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
41986 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
41987 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
41988 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
41989 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
41990 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
41991 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
41992 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
41993 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
41994 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
41995 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
41996 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
41997 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
41998 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
41999 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42000 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42001 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42002 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42003 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42004 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42005 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42006 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42007
42008 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42009
42010 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42011 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42012 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42013 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42014 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42015 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42016 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42017 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42018 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42019 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42020 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42021 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42022 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42023 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42024 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42025 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42026 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42027 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42028 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42029 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42030 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42031 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42032 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42033 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42034 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42035 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42036 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42037 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42038 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42039 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42040 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42041 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42042 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42043 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42044 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42045 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42046 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42047 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42048 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42049 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42050 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42051 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42052 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42053 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42054 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42055 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42056 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42057 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42058 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42059 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42060 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42061 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42062 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42063
42064 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42065
42066 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42067 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42068 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42069 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42070 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42071 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42072 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42073 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42074 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42075 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42076 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42077 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42078 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42079 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42080 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42081 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42082 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42083 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42084 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42085 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42086 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42087 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42088 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42089 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42090 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42091 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42092 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42093 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42094 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42095 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42096 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42097 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42098 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42099 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42100 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42101 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42102 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42103 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42104 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42105 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42106 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42107 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42108 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42109 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42110 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42111 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42112 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42113 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42114 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42115 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42117 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42118 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42119 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42120 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42121 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42122 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42125 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42126 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42127 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42128 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42129 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42130 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42131 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42132 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42133 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42134 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42135 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42142
42143 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42144
42145 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42146 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42147 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42148 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42149 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42150 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42151 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42152 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42153 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42154 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42155 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42156 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42157 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42158 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42159 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42160 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42161 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42162 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42163 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42164 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42165 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42166 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42167 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42168 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42169 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42170 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42171 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42172 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42173 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42174 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42175 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42176 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42177 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42178 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42179 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42180 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42181 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42182 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42183 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42184 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42185 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42186 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42187 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42188 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42189 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42190 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42191 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42192 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42193 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42194 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42195 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42196 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42197 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42198 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42199 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42200 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42201 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42202 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42203 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42204 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42205 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42206 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42207 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42208 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42209 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42210 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42211 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42212 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42213 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42214 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42215 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42216 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42217 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42218 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42219 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42220 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42221 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42222 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42223 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42224 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42225 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42226 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42227 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42228 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42229 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42230 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42231 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42232 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42233 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42234 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42235 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42236 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42237 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42238 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42239 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42240 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42241 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42242 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42243 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42244 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42245 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42246 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42247 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42248 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42249 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42250 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42251 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42252 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42253 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42254 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42255 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42256 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42257 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42258 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42259 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42260 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42261 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42262 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42263 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42264 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42265 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42266 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42267 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42268 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42269 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42270 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42271 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42272 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42273 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42274 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42275 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42276 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42277 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42278 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42279 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42280 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42281 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42282 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42283 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42284 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42285 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42286 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42287 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42288 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42289 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42290 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42291 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42292 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42293 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42294 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42295 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42296 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42297 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42298 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42299 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42300 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42301 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42302 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42303 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42304 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42305 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42306 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42307 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42308 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42309 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42310 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42311 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42312 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42313 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42314 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42315 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42316 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42317 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42318 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42319 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42320 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42321 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42322 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42323 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42324 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42325 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42326 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42327 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42328 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42329 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42330 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42331 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42332 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42333 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42334 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42335 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42336 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42337 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42338 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42339 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42340 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42341 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42342 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42343 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42344 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42345 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42346 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42347 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42348
42349 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42350 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42351 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42352 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42353
42354 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42355 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42356 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42357 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42358 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42359 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42360 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42361 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42362 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42363 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42364 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42365 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42366 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42367 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42368 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42369 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42370 }
42371
wxWidgets (Impactor)