]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
deprecated wxString::GetWriteBuf() and friends in favour of wxStringBuffer
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_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_wxMetafile swig_types[95]
2562 #define SWIGTYPE_p_wxMetafileDataObject swig_types[96]
2563 #define SWIGTYPE_p_wxMimeTypesManager swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseState swig_types[101]
2568 #define SWIGTYPE_p_wxMoveEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[103]
2570 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNcPaintEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNotifyEvent swig_types[106]
2573 #define SWIGTYPE_p_wxObject swig_types[107]
2574 #define SWIGTYPE_p_wxOutputStream swig_types[108]
2575 #define SWIGTYPE_p_wxPCXHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNGHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNMHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPaintEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[113]
2580 #define SWIGTYPE_p_wxPaperSize swig_types[114]
2581 #define SWIGTYPE_p_wxPlatformInfo swig_types[115]
2582 #define SWIGTYPE_p_wxPoint swig_types[116]
2583 #define SWIGTYPE_p_wxPowerEvent swig_types[117]
2584 #define SWIGTYPE_p_wxProcessEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPyApp swig_types[119]
2586 #define SWIGTYPE_p_wxPyArtProvider swig_types[120]
2587 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[121]
2588 #define SWIGTYPE_p_wxPyCommandEvent swig_types[122]
2589 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropSource swig_types[124]
2591 #define SWIGTYPE_p_wxPyDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyEvent swig_types[126]
2593 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[127]
2594 #define SWIGTYPE_p_wxPyImageHandler swig_types[128]
2595 #define SWIGTYPE_p_wxPyLog swig_types[129]
2596 #define SWIGTYPE_p_wxPyProcess swig_types[130]
2597 #define SWIGTYPE_p_wxPySizer swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDataObject swig_types[132]
2599 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[133]
2600 #define SWIGTYPE_p_wxPyTimer swig_types[134]
2601 #define SWIGTYPE_p_wxPyTipProvider swig_types[135]
2602 #define SWIGTYPE_p_wxPyValidator swig_types[136]
2603 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[137]
2604 #define SWIGTYPE_p_wxRect swig_types[138]
2605 #define SWIGTYPE_p_wxScrollEvent swig_types[139]
2606 #define SWIGTYPE_p_wxScrollWinEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSetCursorEvent swig_types[141]
2608 #define SWIGTYPE_p_wxShowEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[143]
2610 #define SWIGTYPE_p_wxSize swig_types[144]
2611 #define SWIGTYPE_p_wxSizeEvent swig_types[145]
2612 #define SWIGTYPE_p_wxSizer swig_types[146]
2613 #define SWIGTYPE_p_wxSizerItem swig_types[147]
2614 #define SWIGTYPE_p_wxSound swig_types[148]
2615 #define SWIGTYPE_p_wxStandardPaths swig_types[149]
2616 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[151]
2618 #define SWIGTYPE_p_wxStopWatch swig_types[152]
2619 #define SWIGTYPE_p_wxString swig_types[153]
2620 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[154]
2621 #define SWIGTYPE_p_wxSystemOptions swig_types[155]
2622 #define SWIGTYPE_p_wxSystemSettings swig_types[156]
2623 #define SWIGTYPE_p_wxTGAHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTIFFHandler swig_types[158]
2625 #define SWIGTYPE_p_wxTextCtrl swig_types[159]
2626 #define SWIGTYPE_p_wxTextDataObject swig_types[160]
2627 #define SWIGTYPE_p_wxTimeSpan swig_types[161]
2628 #define SWIGTYPE_p_wxTimer swig_types[162]
2629 #define SWIGTYPE_p_wxTimerEvent swig_types[163]
2630 #define SWIGTYPE_p_wxTimerRunner swig_types[164]
2631 #define SWIGTYPE_p_wxTipProvider swig_types[165]
2632 #define SWIGTYPE_p_wxToolTip swig_types[166]
2633 #define SWIGTYPE_p_wxURLDataObject swig_types[167]
2634 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[168]
2635 #define SWIGTYPE_p_wxValidator swig_types[169]
2636 #define SWIGTYPE_p_wxVideoMode swig_types[170]
2637 #define SWIGTYPE_p_wxWindow swig_types[171]
2638 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[173]
2640 #define SWIGTYPE_p_wxWindowDisabler swig_types[174]
2641 #define SWIGTYPE_p_wxXPMHandler swig_types[175]
2642 static swig_type_info *swig_types[177];
2643 static swig_module_info swig_module = {swig_types, 176, 0, 0, 0, 0};
2644 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2645 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2646
2647 /* -------- TYPES TABLE (END) -------- */
2648
2649 #if (PY_VERSION_HEX <= 0x02000000)
2650 # if !defined(SWIG_PYTHON_CLASSIC)
2651 # error "This python version requires to use swig with the '-classic' option"
2652 # endif
2653 #endif
2654 #if (PY_VERSION_HEX <= 0x02020000)
2655 # error "This python version requires to use swig with the '-nomodern' option"
2656 #endif
2657 #if (PY_VERSION_HEX <= 0x02020000)
2658 # error "This python version requires to use swig with the '-nomodernargs' option"
2659 #endif
2660 #ifndef METH_O
2661 # error "This python version requires to use swig with the '-nofastunpack' option"
2662 #endif
2663
2664 /*-----------------------------------------------
2665 @(target):= _misc_.so
2666 ------------------------------------------------*/
2667 #define SWIG_init init_misc_
2668
2669 #define SWIG_name "_misc_"
2670
2671 #define SWIGVERSION 0x010329
2672
2673
2674 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2675 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2676
2677
2678 #include <stdexcept>
2679
2680
2681 namespace swig {
2682 class PyObject_ptr {
2683 protected:
2684 PyObject *_obj;
2685
2686 public:
2687 PyObject_ptr() :_obj(0)
2688 {
2689 }
2690
2691 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2692 {
2693 Py_XINCREF(_obj);
2694 }
2695
2696 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2697 {
2698 if (initial_ref) Py_XINCREF(_obj);
2699 }
2700
2701 PyObject_ptr & operator=(const PyObject_ptr& item)
2702 {
2703 Py_XINCREF(item._obj);
2704 Py_XDECREF(_obj);
2705 _obj = item._obj;
2706 return *this;
2707 }
2708
2709 ~PyObject_ptr()
2710 {
2711 Py_XDECREF(_obj);
2712 }
2713
2714 operator PyObject *() const
2715 {
2716 return _obj;
2717 }
2718
2719 PyObject *operator->() const
2720 {
2721 return _obj;
2722 }
2723 };
2724 }
2725
2726
2727 namespace swig {
2728 struct PyObject_var : PyObject_ptr {
2729 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2730
2731 PyObject_var & operator = (PyObject* obj)
2732 {
2733 Py_XDECREF(_obj);
2734 _obj = obj;
2735 return *this;
2736 }
2737 };
2738 }
2739
2740
2741 #include "wx/wxPython/wxPython.h"
2742 #include "wx/wxPython/pyclasses.h"
2743 #include "wx/wxPython/pyistream.h"
2744
2745 static const wxString wxPyEmptyString(wxEmptyString);
2746
2747
2748
2749 #define SWIG_From_long PyInt_FromLong
2750
2751
2752 SWIGINTERNINLINE PyObject *
2753 SWIG_From_int (int value)
2754 {
2755 return SWIG_From_long (value);
2756 }
2757
2758
2759 #include <limits.h>
2760 #ifndef LLONG_MIN
2761 # define LLONG_MIN LONG_LONG_MIN
2762 #endif
2763 #ifndef LLONG_MAX
2764 # define LLONG_MAX LONG_LONG_MAX
2765 #endif
2766 #ifndef ULLONG_MAX
2767 # define ULLONG_MAX ULONG_LONG_MAX
2768 #endif
2769
2770
2771 SWIGINTERN int
2772 SWIG_AsVal_long (PyObject* obj, long* val)
2773 {
2774 if (PyNumber_Check(obj)) {
2775 if (val) *val = PyInt_AsLong(obj);
2776 return SWIG_OK;
2777 }
2778 return SWIG_TypeError;
2779 }
2780
2781
2782 SWIGINTERN int
2783 SWIG_AsVal_int (PyObject * obj, int *val)
2784 {
2785 long v;
2786 int res = SWIG_AsVal_long (obj, &v);
2787 if (SWIG_IsOK(res)) {
2788 if ((v < INT_MIN || v > INT_MAX)) {
2789 return SWIG_OverflowError;
2790 } else {
2791 if (val) *val = static_cast< int >(v);
2792 }
2793 }
2794 return res;
2795 }
2796
2797 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2798
2799 #include <wx/stockitem.h>
2800
2801 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2802 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2803 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2804
2805 SWIGINTERN int
2806 SWIG_AsVal_bool (PyObject *obj, bool *val)
2807 {
2808 if (obj == Py_True) {
2809 if (val) *val = true;
2810 return SWIG_OK;
2811 } else if (obj == Py_False) {
2812 if (val) *val = false;
2813 return SWIG_OK;
2814 } else {
2815 long v = 0;
2816 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2817 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2818 return res;
2819 }
2820 }
2821
2822
2823 SWIGINTERN int
2824 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2825 {
2826 long v = 0;
2827 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2828 return SWIG_TypeError;
2829 }
2830 else if (val)
2831 *val = (unsigned long)v;
2832 return SWIG_OK;
2833 }
2834
2835
2836 SWIGINTERNINLINE PyObject*
2837 SWIG_From_unsigned_SS_long (unsigned long value)
2838 {
2839 return (value > LONG_MAX) ?
2840 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2841 }
2842
2843
2844 void* wxGetXDisplay()
2845 {
2846 #ifdef __WXGTK__
2847 return wxGetDisplay();
2848 #else
2849 return NULL;
2850 #endif
2851 }
2852
2853
2854 wxWindow* FindWindowAtPointer() {
2855 wxPoint unused;
2856 return wxFindWindowAtPointer(unused);
2857 }
2858
2859
2860 bool wxThread_IsMain() {
2861 #ifdef WXP_WITH_THREAD
2862 return wxThread::IsMain();
2863 #else
2864 return true;
2865 #endif
2866 }
2867
2868 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2869 delete self;
2870 }
2871
2872 #include <wx/snglinst.h>
2873
2874
2875 #ifdef __WXMSW__
2876 #include <wx/msw/private.h>
2877 #include <wx/dynload.h>
2878 #endif
2879
2880
2881
2882 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2883 #if 0
2884 , int method
2885 #endif
2886 )
2887 {
2888 #ifdef __WXMSW__
2889 #if 0
2890 switch (method)
2891 {
2892 case 1:
2893 // This one only partially works. Appears to be an undocumented
2894 // "standard" convention that not all widgets adhear to. For
2895 // example, for some widgets backgrounds or non-client areas may
2896 // not be painted.
2897 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2898 break;
2899
2900 case 2:
2901 #endif
2902 // This one works much better, nearly all widgets and their
2903 // children are captured correctly[**]. Prior to the big
2904 // background erase changes that Vadim did in 2004-2005 this
2905 // method failed badly on XP with Themes activated, most native
2906 // widgets draw only partially, if at all. Without themes it
2907 // worked just like on Win2k. After those changes this method
2908 // works very well.
2909 //
2910 // ** For example the radio buttons in a wxRadioBox are not its
2911 // children by default, but you can capture it via the panel
2912 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2913 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2914 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2915 PRF_ERASEBKGND | PRF_OWNED );
2916 return true;
2917 #if 0
2918 break;
2919
2920 case 3:
2921 // This one is only defined in the latest SDK and is only
2922 // available on XP. MSDN says it is similar to sending WM_PRINT
2923 // so I expect that it will work similar to the above. Since it
2924 // is avaialble only on XP, it can't be compiled like this and
2925 // will have to be loaded dynamically.
2926 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2927
2928 // fall through
2929
2930 case 4:
2931 // Use PrintWindow if available, or fallback to WM_PRINT
2932 // otherwise. Unfortunately using PrintWindow is even worse than
2933 // WM_PRINT. For most native widgets nothing is drawn to the dc
2934 // at all, with or without Themes.
2935 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2936 static bool s_triedToLoad = false;
2937 static PrintWindow_t pfnPrintWindow = NULL;
2938 if ( !s_triedToLoad )
2939 {
2940
2941 s_triedToLoad = true;
2942 wxDynamicLibrary dllUser32(_T("user32.dll"));
2943 if ( dllUser32.IsLoaded() )
2944 {
2945 wxLogNull nolog; // Don't report errors here
2946 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2947 }
2948 }
2949 if (pfnPrintWindow)
2950 {
2951 //printf("Using PrintWindow\n");
2952 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2953 }
2954 else
2955 {
2956 //printf("Using WM_PRINT\n");
2957 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2958 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2959 PRF_ERASEBKGND | PRF_OWNED );
2960 }
2961 }
2962 #endif // 0
2963 #else
2964 return false;
2965 #endif // __WXMSW__
2966 }
2967
2968
2969
2970 #include <wx/tipdlg.h>
2971
2972
2973 SWIGINTERNINLINE PyObject *
2974 SWIG_From_size_t (size_t value)
2975 {
2976 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2977 }
2978
2979
2980 class wxPyTipProvider : public wxTipProvider {
2981 public:
2982 wxPyTipProvider(size_t currentTip)
2983 : wxTipProvider(currentTip) {}
2984
2985 DEC_PYCALLBACK_STRING__pure(GetTip);
2986 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2987 PYPRIVATE;
2988 };
2989
2990 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2991 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2992
2993
2994 SWIGINTERNINLINE int
2995 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2996 {
2997 unsigned long v;
2998 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2999 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3000 return res;
3001 }
3002
3003
3004 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3005
3006 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3007
3008 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3009 : wxTimer(owner, id)
3010 {
3011 if (owner == NULL)
3012 SetOwner(this);
3013 }
3014
3015 wxPyTimer::~wxPyTimer()
3016 {
3017 // printf("-=* ~wxPyTimer\n");
3018 }
3019
3020
3021
3022 SWIGINTERN swig_type_info*
3023 SWIG_pchar_descriptor()
3024 {
3025 static int init = 0;
3026 static swig_type_info* info = 0;
3027 if (!init) {
3028 info = SWIG_TypeQuery("_p_char");
3029 init = 1;
3030 }
3031 return info;
3032 }
3033
3034
3035 SWIGINTERNINLINE PyObject *
3036 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3037 {
3038 if (carray) {
3039 if (size > INT_MAX) {
3040 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3041 return pchar_descriptor ?
3042 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3043 } else {
3044 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3045 }
3046 } else {
3047 return SWIG_Py_Void();
3048 }
3049 }
3050
3051
3052 SWIGINTERNINLINE PyObject *
3053 SWIG_FromCharPtr(const char *cptr)
3054 {
3055 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3056 }
3057
3058
3059 SWIGINTERN int
3060 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3061 {
3062 unsigned long v;
3063 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3064 if (SWIG_IsOK(res)) {
3065 if ((v > UINT_MAX)) {
3066 return SWIG_OverflowError;
3067 } else {
3068 if (val) *val = static_cast< unsigned int >(v);
3069 }
3070 }
3071 return res;
3072 }
3073
3074 SWIGINTERN wxString wxLog_TimeStamp(){
3075 wxString msg;
3076 wxLog::TimeStamp(&msg);
3077 return msg;
3078 }
3079 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3080 // Make some wrappers that double any % signs so they are 'escaped'
3081 void wxPyLogFatalError(const wxString& msg)
3082 {
3083 wxString m(msg);
3084 m.Replace(wxT("%"), wxT("%%"));
3085 wxLogFatalError(m);
3086 }
3087
3088 void wxPyLogError(const wxString& msg)
3089 {
3090 wxString m(msg);
3091 m.Replace(wxT("%"), wxT("%%"));
3092 wxLogError(m);
3093 }
3094
3095 void wxPyLogWarning(const wxString& msg)
3096 {
3097 wxString m(msg);
3098 m.Replace(wxT("%"), wxT("%%"));
3099 wxLogWarning(m);
3100 }
3101
3102 void wxPyLogMessage(const wxString& msg)
3103 {
3104 wxString m(msg);
3105 m.Replace(wxT("%"), wxT("%%"));
3106 wxLogMessage(m);
3107 }
3108
3109 void wxPyLogInfo(const wxString& msg)
3110 {
3111 wxString m(msg);
3112 m.Replace(wxT("%"), wxT("%%"));
3113 wxLogInfo(m);
3114 }
3115
3116 void wxPyLogDebug(const wxString& msg)
3117 {
3118 wxString m(msg);
3119 m.Replace(wxT("%"), wxT("%%"));
3120 wxLogDebug(m);
3121 }
3122
3123 void wxPyLogVerbose(const wxString& msg)
3124 {
3125 wxString m(msg);
3126 m.Replace(wxT("%"), wxT("%%"));
3127 wxLogVerbose(m);
3128 }
3129
3130 void wxPyLogStatus(const wxString& msg)
3131 {
3132 wxString m(msg);
3133 m.Replace(wxT("%"), wxT("%%"));
3134 wxLogStatus(m);
3135 }
3136
3137 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3138 {
3139 wxString m(msg);
3140 m.Replace(wxT("%"), wxT("%%"));
3141 wxLogStatus(pFrame, m);
3142 }
3143
3144 void wxPyLogSysError(const wxString& msg)
3145 {
3146 wxString m(msg);
3147 m.Replace(wxT("%"), wxT("%%"));
3148 wxLogSysError(m);
3149 }
3150
3151 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3152 {
3153 wxString m(msg);
3154 m.Replace(wxT("%"), wxT("%%"));
3155 wxLogGeneric(level, m);
3156 }
3157
3158 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3159 {
3160 wxString m(msg);
3161 m.Replace(wxT("%"), wxT("%%"));
3162 wxLogTrace(mask, m);
3163 }
3164
3165 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3166 {
3167 wxString m(msg);
3168 m.Replace(wxT("%"), wxT("%%"));
3169 wxLogTrace(mask, m);
3170 }
3171
3172
3173
3174 // A wxLog class that can be derived from in wxPython
3175 class wxPyLog : public wxLog {
3176 public:
3177 wxPyLog() : wxLog() {}
3178
3179 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3180 bool found;
3181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3182 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3183 PyObject* s = wx2PyString(szString);
3184 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3185 Py_DECREF(s);
3186 }
3187 wxPyEndBlockThreads(blocked);
3188 if (! found)
3189 wxLog::DoLog(level, szString, t);
3190 }
3191
3192 virtual void DoLogString(const wxChar *szString, time_t t) {
3193 bool found;
3194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3195 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3196 PyObject* s = wx2PyString(szString);
3197 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3198 Py_DECREF(s);
3199 }
3200 wxPyEndBlockThreads(blocked);
3201 if (! found)
3202 wxLog::DoLogString(szString, t);
3203 }
3204
3205 DEC_PYCALLBACK_VOID_(Flush);
3206 PYPRIVATE;
3207 };
3208 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3209
3210
3211
3212
3213 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3214
3215
3216 #include <wx/joystick.h>
3217
3218
3219 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3220 // A C++ stub class for wxJoystick for platforms that don't have it.
3221 class wxJoystick : public wxObject {
3222 public:
3223 wxJoystick(int joystick = wxJOYSTICK1) {
3224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3225 PyErr_SetString(PyExc_NotImplementedError,
3226 "wxJoystick is not available on this platform.");
3227 wxPyEndBlockThreads(blocked);
3228 }
3229 wxPoint GetPosition() { return wxPoint(-1,-1); }
3230 int GetZPosition() { return -1; }
3231 int GetButtonState() { return -1; }
3232 int GetPOVPosition() { return -1; }
3233 int GetPOVCTSPosition() { return -1; }
3234 int GetRudderPosition() { return -1; }
3235 int GetUPosition() { return -1; }
3236 int GetVPosition() { return -1; }
3237 int GetMovementThreshold() { return -1; }
3238 void SetMovementThreshold(int threshold) {}
3239
3240 bool IsOk(void) { return false; }
3241 int GetNumberJoysticks() { return -1; }
3242 int GetManufacturerId() { return -1; }
3243 int GetProductId() { return -1; }
3244 wxString GetProductName() { return wxEmptyString; }
3245 int GetXMin() { return -1; }
3246 int GetYMin() { return -1; }
3247 int GetZMin() { return -1; }
3248 int GetXMax() { return -1; }
3249 int GetYMax() { return -1; }
3250 int GetZMax() { return -1; }
3251 int GetNumberButtons() { return -1; }
3252 int GetNumberAxes() { return -1; }
3253 int GetMaxButtons() { return -1; }
3254 int GetMaxAxes() { return -1; }
3255 int GetPollingMin() { return -1; }
3256 int GetPollingMax() { return -1; }
3257 int GetRudderMin() { return -1; }
3258 int GetRudderMax() { return -1; }
3259 int GetUMin() { return -1; }
3260 int GetUMax() { return -1; }
3261 int GetVMin() { return -1; }
3262 int GetVMax() { return -1; }
3263
3264 bool HasRudder() { return false; }
3265 bool HasZ() { return false; }
3266 bool HasU() { return false; }
3267 bool HasV() { return false; }
3268 bool HasPOV() { return false; }
3269 bool HasPOV4Dir() { return false; }
3270 bool HasPOVCTS() { return false; }
3271
3272 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3273 bool ReleaseCapture() { return false; }
3274 };
3275 #endif
3276
3277
3278 #include <wx/sound.h>
3279
3280
3281 #if !wxUSE_SOUND
3282 // A C++ stub class for wxWave for platforms that don't have it.
3283 class wxSound : public wxObject
3284 {
3285 public:
3286 wxSound() {
3287 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3288 PyErr_SetString(PyExc_NotImplementedError,
3289 "wxSound is not available on this platform.");
3290 wxPyEndBlockThreads(blocked);
3291 }
3292 wxSound(const wxString&/*, bool*/) {
3293 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3294 PyErr_SetString(PyExc_NotImplementedError,
3295 "wxSound is not available on this platform.");
3296 wxPyEndBlockThreads(blocked);
3297 }
3298 wxSound(int, const wxByte*) {
3299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3300 PyErr_SetString(PyExc_NotImplementedError,
3301 "wxSound is not available on this platform.");
3302 wxPyEndBlockThreads(blocked);
3303 }
3304
3305 ~wxSound() {};
3306
3307 bool Create(const wxString&/*, bool*/) { return false; }
3308 bool Create(int, const wxByte*) { return false; };
3309 bool IsOk() { return false; };
3310 bool Play(unsigned) const { return false; }
3311 static bool Play(const wxString&, unsigned) { return false; }
3312 static void Stop() {}
3313 };
3314
3315 #endif
3316
3317 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3318 if (fileName.Length() == 0)
3319 return new wxSound;
3320 else
3321 return new wxSound(fileName);
3322 }
3323 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3324 unsigned char* buffer; int size;
3325 wxSound *sound = NULL;
3326
3327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3328 if (!PyArg_Parse(data, "t#", &buffer, &size))
3329 goto done;
3330 sound = new wxSound(size, buffer);
3331 done:
3332 wxPyEndBlockThreads(blocked);
3333 return sound;
3334 }
3335 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3336 #ifndef __WXMAC__
3337 unsigned char* buffer;
3338 int size;
3339 bool rv = false;
3340
3341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3342 if (!PyArg_Parse(data, "t#", &buffer, &size))
3343 goto done;
3344 rv = self->Create(size, buffer);
3345 done:
3346 wxPyEndBlockThreads(blocked);
3347 return rv;
3348 #else
3349 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3350 PyErr_SetString(PyExc_NotImplementedError,
3351 "Create from data is not available on this platform.");
3352 wxPyEndBlockThreads(blocked);
3353 return false;
3354 #endif
3355 }
3356
3357 #include <wx/mimetype.h>
3358
3359 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3360 wxString str;
3361 if (self->GetMimeType(&str))
3362 return wx2PyString(str);
3363 else
3364 RETURN_NONE();
3365 }
3366 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3367 wxArrayString arr;
3368 if (self->GetMimeTypes(arr))
3369 return wxArrayString2PyList_helper(arr);
3370 else
3371 RETURN_NONE();
3372 }
3373 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3374 wxArrayString arr;
3375 if (self->GetExtensions(arr))
3376 return wxArrayString2PyList_helper(arr);
3377 else
3378 RETURN_NONE();
3379 }
3380 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3381 wxIconLocation loc;
3382 if (self->GetIcon(&loc))
3383 return new wxIcon(loc);
3384 else
3385 return NULL;
3386 }
3387 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3388 wxIconLocation loc;
3389 if (self->GetIcon(&loc)) {
3390 wxString iconFile = loc.GetFileName();
3391 int iconIndex = -1;
3392
3393
3394
3395 // Make a tuple and put the values in it
3396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3397 PyObject* tuple = PyTuple_New(3);
3398 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3399 wxT("wxIcon"), true));
3400 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3401 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3402 wxPyEndBlockThreads(blocked);
3403 return tuple;
3404 }
3405 else
3406 RETURN_NONE();
3407 }
3408 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3409 wxString str;
3410 if (self->GetDescription(&str))
3411 return wx2PyString(str);
3412 else
3413 RETURN_NONE();
3414 }
3415 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3416 wxString str;
3417 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3418 return wx2PyString(str);
3419 else
3420 RETURN_NONE();
3421 }
3422 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3423 wxString str;
3424 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3425 return wx2PyString(str);
3426 else
3427 RETURN_NONE();
3428 }
3429 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3430 wxArrayString verbs;
3431 wxArrayString commands;
3432 if (self->GetAllCommands(&verbs, &commands,
3433 wxFileType::MessageParameters(filename, mimetype))) {
3434 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3435 PyObject* tuple = PyTuple_New(2);
3436 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3437 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3438 wxPyEndBlockThreads(blocked);
3439 return tuple;
3440 }
3441 else
3442 RETURN_NONE();
3443 }
3444 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3445 return wxFileType::ExpandCommand(command,
3446 wxFileType::MessageParameters(filename, mimetype));
3447 }
3448 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3449 wxArrayString arr;
3450 self->EnumAllFileTypes(arr);
3451 return wxArrayString2PyList_helper(arr);
3452 }
3453
3454 #include <wx/artprov.h>
3455
3456 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3457 static const wxString wxPyART_MENU(wxART_MENU);
3458 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3459 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3460 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3461 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3462 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3463 static const wxString wxPyART_OTHER(wxART_OTHER);
3464 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3465 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3466 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3467 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3468 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3469 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3470 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3471 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3472 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3473 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3474 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3475 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3476 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3477 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3478 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3479 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3480 static const wxString wxPyART_PRINT(wxART_PRINT);
3481 static const wxString wxPyART_HELP(wxART_HELP);
3482 static const wxString wxPyART_TIP(wxART_TIP);
3483 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3484 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3485 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3486 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3487 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3488 static const wxString wxPyART_CDROM(wxART_CDROM);
3489 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3490 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3491 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3492 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3493 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3494 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3495 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3496 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3497 static const wxString wxPyART_ERROR(wxART_ERROR);
3498 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3499 static const wxString wxPyART_WARNING(wxART_WARNING);
3500 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3501 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3502 static const wxString wxPyART_COPY(wxART_COPY);
3503 static const wxString wxPyART_CUT(wxART_CUT);
3504 static const wxString wxPyART_PASTE(wxART_PASTE);
3505 static const wxString wxPyART_DELETE(wxART_DELETE);
3506 static const wxString wxPyART_NEW(wxART_NEW);
3507 static const wxString wxPyART_UNDO(wxART_UNDO);
3508 static const wxString wxPyART_REDO(wxART_REDO);
3509 static const wxString wxPyART_QUIT(wxART_QUIT);
3510 static const wxString wxPyART_FIND(wxART_FIND);
3511 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3512 // Python aware wxArtProvider
3513 class wxPyArtProvider : public wxArtProvider {
3514 public:
3515
3516 virtual wxBitmap CreateBitmap(const wxArtID& id,
3517 const wxArtClient& client,
3518 const wxSize& size) {
3519 wxBitmap rval = wxNullBitmap;
3520 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3521 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3522 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3523 PyObject* ro;
3524 wxBitmap* ptr;
3525 PyObject* s1, *s2;
3526 s1 = wx2PyString(id);
3527 s2 = wx2PyString(client);
3528 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3529 Py_DECREF(so);
3530 Py_DECREF(s1);
3531 Py_DECREF(s2);
3532 if (ro) {
3533 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3534 rval = *ptr;
3535 Py_DECREF(ro);
3536 }
3537 }
3538 wxPyEndBlockThreads(blocked);
3539 return rval;
3540 }
3541
3542 PYPRIVATE;
3543 };
3544
3545 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3546
3547
3548
3549 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3550 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3551 PyObject* ret = PyTuple_New(3);
3552 if (ret) {
3553 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3554 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3555 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3556 }
3557 wxPyEndBlockThreads(blocked);
3558 return ret;
3559 }
3560
3561 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3562 bool cont;
3563 long index = 0;
3564 wxString value;
3565
3566 cont = self->GetFirstGroup(value, index);
3567 return __EnumerationHelper(cont, value, index);
3568 }
3569 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3570 bool cont;
3571 wxString value;
3572
3573 cont = self->GetNextGroup(value, index);
3574 return __EnumerationHelper(cont, value, index);
3575 }
3576 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3577 bool cont;
3578 long index = 0;
3579 wxString value;
3580
3581 cont = self->GetFirstEntry(value, index);
3582 return __EnumerationHelper(cont, value, index);
3583 }
3584 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3585 bool cont;
3586 wxString value;
3587
3588 cont = self->GetNextEntry(value, index);
3589 return __EnumerationHelper(cont, value, index);
3590 }
3591 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3592 long rv;
3593 self->Read(key, &rv, defaultVal);
3594 return rv;
3595 }
3596
3597 SWIGINTERN int
3598 SWIG_AsVal_double (PyObject *obj, double* val)
3599 {
3600 if (PyNumber_Check(obj)) {
3601 if (val) *val = PyFloat_AsDouble(obj);
3602 return SWIG_OK;
3603 }
3604 return SWIG_TypeError;
3605 }
3606
3607 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3608 double rv;
3609 self->Read(key, &rv, defaultVal);
3610 return rv;
3611 }
3612
3613 #define SWIG_From_double PyFloat_FromDouble
3614
3615 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3616 bool rv;
3617 self->Read(key, &rv, defaultVal);
3618 return rv;
3619 }
3620
3621 #include <wx/datetime.h>
3622
3623 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3624 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3625
3626 #define LOCAL_TZ wxDateTime::Local
3627
3628 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3629 wxString am;
3630 wxString pm;
3631 wxDateTime::GetAmPmStrings(&am, &pm);
3632 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3633 PyObject* tup = PyTuple_New(2);
3634 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3635 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3636 wxPyEndBlockThreads(blocked);
3637 return tup;
3638 }
3639
3640 SWIGINTERNINLINE PyObject *
3641 SWIG_From_unsigned_SS_int (unsigned int value)
3642 {
3643 return SWIG_From_unsigned_SS_long (value);
3644 }
3645
3646 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3647 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3648 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3649 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3650 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3651 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3653 return (*self < *other);
3654 }
3655 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3657 return (*self <= *other);
3658 }
3659 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3661 return (*self > *other);
3662 }
3663 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3665 return (*self >= *other);
3666 }
3667 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3668 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3669 return (*self == *other);
3670 }
3671 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3672 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3673 return (*self != *other);
3674 }
3675 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3676 const wxChar* rv;
3677 const wxChar* _date = date;
3678 rv = self->ParseRfc822Date(_date);
3679 if (rv == NULL) return -1;
3680 return rv - _date;
3681 }
3682 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3683 const wxChar* rv;
3684 const wxChar* _date = date;
3685 rv = self->ParseFormat(_date, format, dateDef);
3686 if (rv == NULL) return -1;
3687 return rv - _date;
3688 }
3689 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3690 const wxChar* rv;
3691 const wxChar* _datetime = datetime;
3692 rv = self->ParseDateTime(_datetime);
3693 if (rv == NULL) return -1;
3694 return rv - _datetime;
3695 }
3696 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3697 const wxChar* rv;
3698 const wxChar* _date = date;
3699 rv = self->ParseDate(_date);
3700 if (rv == NULL) return -1;
3701 return rv - _date;
3702 }
3703 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3704 const wxChar* rv;
3705 const wxChar* _time = time;
3706 rv = self->ParseTime(_time);
3707 if (rv == NULL) return -1;
3708 return rv - _time;
3709 }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3712 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3713 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3714 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3716 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3717 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3718 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3719 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3720 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3721 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3722 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3723 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3724 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3725 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3726
3727 #include <wx/dataobj.h>
3728
3729 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3730 size_t count = self->GetFormatCount(dir);
3731 wxDataFormat* formats = new wxDataFormat[count];
3732 self->GetAllFormats(formats, dir);
3733
3734 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3735 PyObject* list = PyList_New(count);
3736 for (size_t i=0; i<count; i++) {
3737 wxDataFormat* format = new wxDataFormat(formats[i]);
3738 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3739 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3740 }
3741 wxPyEndBlockThreads(blocked);
3742 delete [] formats;
3743 return list;
3744 }
3745 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3746 PyObject* rval = NULL;
3747 size_t size = self->GetDataSize(format);
3748 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3749 if (size) {
3750 char* buf = new char[size];
3751 if (self->GetDataHere(format, buf))
3752 rval = PyString_FromStringAndSize(buf, size);
3753 delete [] buf;
3754 }
3755 if (! rval) {
3756 rval = Py_None;
3757 Py_INCREF(rval);
3758 }
3759 wxPyEndBlockThreads(blocked);
3760 return rval;
3761 }
3762 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3763 bool rval;
3764 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3765 if (PyString_Check(data)) {
3766 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3767 }
3768 else {
3769 // raise a TypeError if not a string
3770 PyErr_SetString(PyExc_TypeError, "String expected.");
3771 rval = false;
3772 }
3773 wxPyEndBlockThreads(blocked);
3774 return rval;
3775 }
3776 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3777 PyObject* rval = NULL;
3778 size_t size = self->GetDataSize();
3779 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3780 if (size) {
3781 char* buf = new char[size];
3782 if (self->GetDataHere(buf))
3783 rval = PyString_FromStringAndSize(buf, size);
3784 delete [] buf;
3785 }
3786 if (! rval) {
3787 rval = Py_None;
3788 Py_INCREF(rval);
3789 }
3790 wxPyEndBlockThreads(blocked);
3791 return rval;
3792 }
3793 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3794 bool rval;
3795 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3796 if (PyString_Check(data)) {
3797 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3798 }
3799 else {
3800 // raise a TypeError if not a string
3801 PyErr_SetString(PyExc_TypeError, "String expected.");
3802 rval = false;
3803 }
3804 wxPyEndBlockThreads(blocked);
3805 return rval;
3806 }
3807 // Create a new class for wxPython to use
3808 class wxPyDataObjectSimple : public wxDataObjectSimple {
3809 public:
3810 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3811 : wxDataObjectSimple(format) {}
3812
3813 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3814 bool GetDataHere(void *buf) const;
3815 bool SetData(size_t len, const void *buf);
3816 PYPRIVATE;
3817 };
3818
3819 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3820
3821 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3822 // We need to get the data for this object and write it to buf. I think
3823 // the best way to do this for wxPython is to have the Python method
3824 // return either a string or None and then act appropriately with the
3825 // C++ version.
3826
3827 bool rval = false;
3828 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3829 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3830 PyObject* ro;
3831 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3832 if (ro) {
3833 rval = (ro != Py_None && PyString_Check(ro));
3834 if (rval)
3835 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3836 Py_DECREF(ro);
3837 }
3838 }
3839 wxPyEndBlockThreads(blocked);
3840 return rval;
3841 }
3842
3843 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3844 // For this one we simply need to make a string from buf and len
3845 // and send it to the Python method.
3846 bool rval = false;
3847 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3848 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3849 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3850 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3851 Py_DECREF(data);
3852 }
3853 wxPyEndBlockThreads(blocked);
3854 return rval;
3855 }
3856
3857 // Create a new class for wxPython to use
3858 class wxPyTextDataObject : public wxTextDataObject {
3859 public:
3860 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3861 : wxTextDataObject(text) {}
3862
3863 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3864 DEC_PYCALLBACK_STRING__const(GetText);
3865 DEC_PYCALLBACK__STRING(SetText);
3866 PYPRIVATE;
3867 };
3868
3869 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3870 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3871 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3872
3873
3874 // Create a new class for wxPython to use
3875 class wxPyBitmapDataObject : public wxBitmapDataObject {
3876 public:
3877 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3878 : wxBitmapDataObject(bitmap) {}
3879
3880 wxBitmap GetBitmap() const;
3881 void SetBitmap(const wxBitmap& bitmap);
3882 PYPRIVATE;
3883 };
3884
3885 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3886 wxBitmap* rval = &wxNullBitmap;
3887 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3888 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3889 PyObject* ro;
3890 wxBitmap* ptr;
3891 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3892 if (ro) {
3893 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3894 rval = ptr;
3895 Py_DECREF(ro);
3896 }
3897 }
3898 wxPyEndBlockThreads(blocked);
3899 return *rval;
3900 }
3901
3902 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3904 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3905 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3906 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3907 Py_DECREF(bo);
3908 }
3909 wxPyEndBlockThreads(blocked);
3910 }
3911
3912 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3913 return new wxCustomDataObject(wxDataFormat(formatName));
3914 }
3915 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3916 bool rval;
3917 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3918 if (PyString_Check(data)) {
3919 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3920 }
3921 else {
3922 // raise a TypeError if not a string
3923 PyErr_SetString(PyExc_TypeError, "String expected.");
3924 rval = false;
3925 }
3926 wxPyEndBlockThreads(blocked);
3927 return rval;
3928 }
3929 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3930 PyObject* obj;
3931 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3932 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3933 wxPyEndBlockThreads(blocked);
3934 return obj;
3935 }
3936
3937 #include <wx/metafile.h>
3938
3939
3940 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3941
3942
3943 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3945 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3946 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3947 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3948
3949
3950 class wxPyTextDropTarget : public wxTextDropTarget {
3951 public:
3952 wxPyTextDropTarget() {}
3953
3954 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3955
3956 DEC_PYCALLBACK__(OnLeave);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3960 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3961
3962 PYPRIVATE;
3963 };
3964
3965 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3966 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3970 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3971
3972
3973
3974 class wxPyFileDropTarget : public wxFileDropTarget {
3975 public:
3976 wxPyFileDropTarget() {}
3977
3978 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3979
3980 DEC_PYCALLBACK__(OnLeave);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3984 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3985
3986 PYPRIVATE;
3987 };
3988
3989 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3990 const wxArrayString& filenames) {
3991 bool rval = false;
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3994 PyObject* list = wxArrayString2PyList_helper(filenames);
3995 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3996 Py_DECREF(list);
3997 }
3998 wxPyEndBlockThreads(blocked);
3999 return rval;
4000 }
4001
4002
4003
4004 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4008 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4009
4010
4011
4012
4013 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4014
4015 #include <wx/display.h>
4016 #include <wx/vidmode.h>
4017
4018 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4019 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4020
4021 #if !wxUSE_DISPLAY
4022 const wxVideoMode wxDefaultVideoMode;
4023 #endif
4024
4025 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4026 #if wxUSE_DISPLAY
4027 PyObject* pyList = NULL;
4028 wxArrayVideoModes arr = self->GetModes(mode);
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 pyList = PyList_New(0);
4031 for (size_t i=0; i < arr.GetCount(); i++)
4032 {
4033 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4034 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4035 PyList_Append(pyList, pyObj);
4036 Py_DECREF(pyObj);
4037 }
4038 wxPyEndBlockThreads(blocked);
4039 return pyList;
4040 #else
4041 wxPyRaiseNotImplemented();
4042 return NULL;
4043 #endif
4044 }
4045 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4046 #if wxUSE_DISPLAY
4047 return self->GetCurrentMode();
4048 #else
4049 wxPyRaiseNotImplemented();
4050 return wxDefaultVideoMode;
4051 #endif
4052 }
4053 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4054 #if wxUSE_DISPLAY
4055 return self->ChangeMode(mode);
4056 #else
4057 wxPyRaiseNotImplemented();
4058 return false;
4059 #endif
4060 }
4061 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4062 #if wxUSE_DISPLAY
4063 self->ResetMode();
4064 #else
4065 wxPyRaiseNotImplemented();
4066 #endif
4067 }
4068
4069 #include <wx/stdpaths.h>
4070
4071 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4072 return (wxStandardPaths*) &wxStandardPaths::Get();
4073 }
4074 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4075 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4076
4077 #ifndef wxHAS_POWER_EVENTS
4078 // Dummy class and other definitions for platforms that don't have them
4079
4080 // See wxPython_int.h for wxPowerEvent
4081
4082 enum {
4083 wxEVT_POWER_SUSPENDING,
4084 wxEVT_POWER_SUSPENDED,
4085 wxEVT_POWER_SUSPEND_CANCEL,
4086 wxEVT_POWER_RESUME,
4087 };
4088
4089 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4090 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4091
4092 #endif
4093
4094
4095 #include <wx/aboutdlg.h>
4096
4097 #ifdef __cplusplus
4098 extern "C" {
4099 #endif
4100 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj = 0;
4102 wxSystemColour arg1 ;
4103 wxColour result;
4104 int val1 ;
4105 int ecode1 = 0 ;
4106 PyObject * obj0 = 0 ;
4107 char * kwnames[] = {
4108 (char *) "index", NULL
4109 };
4110
4111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4112 ecode1 = SWIG_AsVal_int(obj0, &val1);
4113 if (!SWIG_IsOK(ecode1)) {
4114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4115 }
4116 arg1 = static_cast< wxSystemColour >(val1);
4117 {
4118 if (!wxPyCheckForApp()) SWIG_fail;
4119 PyThreadState* __tstate = wxPyBeginAllowThreads();
4120 result = wxSystemSettings::GetColour(arg1);
4121 wxPyEndAllowThreads(__tstate);
4122 if (PyErr_Occurred()) SWIG_fail;
4123 }
4124 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4125 return resultobj;
4126 fail:
4127 return NULL;
4128 }
4129
4130
4131 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4132 PyObject *resultobj = 0;
4133 wxSystemFont arg1 ;
4134 wxFont result;
4135 int val1 ;
4136 int ecode1 = 0 ;
4137 PyObject * obj0 = 0 ;
4138 char * kwnames[] = {
4139 (char *) "index", NULL
4140 };
4141
4142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4143 ecode1 = SWIG_AsVal_int(obj0, &val1);
4144 if (!SWIG_IsOK(ecode1)) {
4145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4146 }
4147 arg1 = static_cast< wxSystemFont >(val1);
4148 {
4149 if (!wxPyCheckForApp()) SWIG_fail;
4150 PyThreadState* __tstate = wxPyBeginAllowThreads();
4151 result = wxSystemSettings::GetFont(arg1);
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4163 PyObject *resultobj = 0;
4164 wxSystemMetric arg1 ;
4165 wxWindow *arg2 = (wxWindow *) NULL ;
4166 int result;
4167 int val1 ;
4168 int ecode1 = 0 ;
4169 void *argp2 = 0 ;
4170 int res2 = 0 ;
4171 PyObject * obj0 = 0 ;
4172 PyObject * obj1 = 0 ;
4173 char * kwnames[] = {
4174 (char *) "index",(char *) "win", NULL
4175 };
4176
4177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4178 ecode1 = SWIG_AsVal_int(obj0, &val1);
4179 if (!SWIG_IsOK(ecode1)) {
4180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4181 }
4182 arg1 = static_cast< wxSystemMetric >(val1);
4183 if (obj1) {
4184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4185 if (!SWIG_IsOK(res2)) {
4186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4187 }
4188 arg2 = reinterpret_cast< wxWindow * >(argp2);
4189 }
4190 {
4191 if (!wxPyCheckForApp()) SWIG_fail;
4192 PyThreadState* __tstate = wxPyBeginAllowThreads();
4193 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4194 wxPyEndAllowThreads(__tstate);
4195 if (PyErr_Occurred()) SWIG_fail;
4196 }
4197 resultobj = SWIG_From_int(static_cast< int >(result));
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj = 0;
4206 wxSystemFeature arg1 ;
4207 bool result;
4208 int val1 ;
4209 int ecode1 = 0 ;
4210 PyObject * obj0 = 0 ;
4211 char * kwnames[] = {
4212 (char *) "index", NULL
4213 };
4214
4215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4216 ecode1 = SWIG_AsVal_int(obj0, &val1);
4217 if (!SWIG_IsOK(ecode1)) {
4218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4219 }
4220 arg1 = static_cast< wxSystemFeature >(val1);
4221 {
4222 if (!wxPyCheckForApp()) SWIG_fail;
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = (bool)wxSystemSettings::HasFeature(arg1);
4225 wxPyEndAllowThreads(__tstate);
4226 if (PyErr_Occurred()) SWIG_fail;
4227 }
4228 {
4229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4230 }
4231 return resultobj;
4232 fail:
4233 return NULL;
4234 }
4235
4236
4237 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4238 PyObject *resultobj = 0;
4239 wxSystemScreenType result;
4240
4241 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4242 {
4243 if (!wxPyCheckForApp()) SWIG_fail;
4244 PyThreadState* __tstate = wxPyBeginAllowThreads();
4245 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 resultobj = SWIG_From_int(static_cast< int >(result));
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj = 0;
4258 wxSystemScreenType arg1 ;
4259 int val1 ;
4260 int ecode1 = 0 ;
4261 PyObject * obj0 = 0 ;
4262 char * kwnames[] = {
4263 (char *) "screen", NULL
4264 };
4265
4266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4267 ecode1 = SWIG_AsVal_int(obj0, &val1);
4268 if (!SWIG_IsOK(ecode1)) {
4269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4270 }
4271 arg1 = static_cast< wxSystemScreenType >(val1);
4272 {
4273 if (!wxPyCheckForApp()) SWIG_fail;
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 wxSystemSettings::SetScreenType(arg1);
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 resultobj = SWIG_Py_Void();
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4287 PyObject *obj;
4288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4289 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4290 return SWIG_Py_Void();
4291 }
4292
4293 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4294 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4295 return 1;
4296 }
4297
4298
4299 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4300 PyObject *pyobj = 0;
4301
4302 {
4303 #if wxUSE_UNICODE
4304 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4305 #else
4306 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4307 #endif
4308 }
4309 return pyobj;
4310 }
4311
4312
4313 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4314 PyObject *resultobj = 0;
4315 wxSystemOptions *result = 0 ;
4316
4317 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 result = (wxSystemOptions *)new wxSystemOptions();
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4325 return resultobj;
4326 fail:
4327 return NULL;
4328 }
4329
4330
4331 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4332 PyObject *resultobj = 0;
4333 wxString *arg1 = 0 ;
4334 wxString *arg2 = 0 ;
4335 bool temp1 = false ;
4336 bool temp2 = false ;
4337 PyObject * obj0 = 0 ;
4338 PyObject * obj1 = 0 ;
4339 char * kwnames[] = {
4340 (char *) "name",(char *) "value", NULL
4341 };
4342
4343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4344 {
4345 arg1 = wxString_in_helper(obj0);
4346 if (arg1 == NULL) SWIG_fail;
4347 temp1 = true;
4348 }
4349 {
4350 arg2 = wxString_in_helper(obj1);
4351 if (arg2 == NULL) SWIG_fail;
4352 temp2 = true;
4353 }
4354 {
4355 PyThreadState* __tstate = wxPyBeginAllowThreads();
4356 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4357 wxPyEndAllowThreads(__tstate);
4358 if (PyErr_Occurred()) SWIG_fail;
4359 }
4360 resultobj = SWIG_Py_Void();
4361 {
4362 if (temp1)
4363 delete arg1;
4364 }
4365 {
4366 if (temp2)
4367 delete arg2;
4368 }
4369 return resultobj;
4370 fail:
4371 {
4372 if (temp1)
4373 delete arg1;
4374 }
4375 {
4376 if (temp2)
4377 delete arg2;
4378 }
4379 return NULL;
4380 }
4381
4382
4383 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4384 PyObject *resultobj = 0;
4385 wxString *arg1 = 0 ;
4386 int arg2 ;
4387 bool temp1 = false ;
4388 int val2 ;
4389 int ecode2 = 0 ;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4392 char * kwnames[] = {
4393 (char *) "name",(char *) "value", NULL
4394 };
4395
4396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4397 {
4398 arg1 = wxString_in_helper(obj0);
4399 if (arg1 == NULL) SWIG_fail;
4400 temp1 = true;
4401 }
4402 ecode2 = SWIG_AsVal_int(obj1, &val2);
4403 if (!SWIG_IsOK(ecode2)) {
4404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4405 }
4406 arg2 = static_cast< int >(val2);
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4410 wxPyEndAllowThreads(__tstate);
4411 if (PyErr_Occurred()) SWIG_fail;
4412 }
4413 resultobj = SWIG_Py_Void();
4414 {
4415 if (temp1)
4416 delete arg1;
4417 }
4418 return resultobj;
4419 fail:
4420 {
4421 if (temp1)
4422 delete arg1;
4423 }
4424 return NULL;
4425 }
4426
4427
4428 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4429 PyObject *resultobj = 0;
4430 wxString *arg1 = 0 ;
4431 wxString result;
4432 bool temp1 = false ;
4433 PyObject * obj0 = 0 ;
4434 char * kwnames[] = {
4435 (char *) "name", NULL
4436 };
4437
4438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4439 {
4440 arg1 = wxString_in_helper(obj0);
4441 if (arg1 == NULL) SWIG_fail;
4442 temp1 = true;
4443 }
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4447 wxPyEndAllowThreads(__tstate);
4448 if (PyErr_Occurred()) SWIG_fail;
4449 }
4450 {
4451 #if wxUSE_UNICODE
4452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4453 #else
4454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4455 #endif
4456 }
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return resultobj;
4462 fail:
4463 {
4464 if (temp1)
4465 delete arg1;
4466 }
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj = 0;
4473 wxString *arg1 = 0 ;
4474 int result;
4475 bool temp1 = false ;
4476 PyObject * obj0 = 0 ;
4477 char * kwnames[] = {
4478 (char *) "name", NULL
4479 };
4480
4481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4482 {
4483 arg1 = wxString_in_helper(obj0);
4484 if (arg1 == NULL) SWIG_fail;
4485 temp1 = true;
4486 }
4487 {
4488 PyThreadState* __tstate = wxPyBeginAllowThreads();
4489 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 resultobj = SWIG_From_int(static_cast< int >(result));
4494 {
4495 if (temp1)
4496 delete arg1;
4497 }
4498 return resultobj;
4499 fail:
4500 {
4501 if (temp1)
4502 delete arg1;
4503 }
4504 return NULL;
4505 }
4506
4507
4508 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4509 PyObject *resultobj = 0;
4510 wxString *arg1 = 0 ;
4511 bool result;
4512 bool temp1 = false ;
4513 PyObject * obj0 = 0 ;
4514 char * kwnames[] = {
4515 (char *) "name", NULL
4516 };
4517
4518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4519 {
4520 arg1 = wxString_in_helper(obj0);
4521 if (arg1 == NULL) SWIG_fail;
4522 temp1 = true;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4527 wxPyEndAllowThreads(__tstate);
4528 if (PyErr_Occurred()) SWIG_fail;
4529 }
4530 {
4531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4532 }
4533 {
4534 if (temp1)
4535 delete arg1;
4536 }
4537 return resultobj;
4538 fail:
4539 {
4540 if (temp1)
4541 delete arg1;
4542 }
4543 return NULL;
4544 }
4545
4546
4547 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj = 0;
4549 wxString *arg1 = 0 ;
4550 bool result;
4551 bool temp1 = false ;
4552 PyObject * obj0 = 0 ;
4553 char * kwnames[] = {
4554 (char *) "name", NULL
4555 };
4556
4557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4558 {
4559 arg1 = wxString_in_helper(obj0);
4560 if (arg1 == NULL) SWIG_fail;
4561 temp1 = true;
4562 }
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 {
4570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4571 }
4572 {
4573 if (temp1)
4574 delete arg1;
4575 }
4576 return resultobj;
4577 fail:
4578 {
4579 if (temp1)
4580 delete arg1;
4581 }
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4587 PyObject *obj;
4588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4589 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4590 return SWIG_Py_Void();
4591 }
4592
4593 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4594 return SWIG_Python_InitShadowInstance(args);
4595 }
4596
4597 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4598 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4599 return 1;
4600 }
4601
4602
4603 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4604 PyObject *pyobj = 0;
4605
4606 {
4607 #if wxUSE_UNICODE
4608 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4609 #else
4610 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4611 #endif
4612 }
4613 return pyobj;
4614 }
4615
4616
4617 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4618 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4619 return 1;
4620 }
4621
4622
4623 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4624 PyObject *pyobj = 0;
4625
4626 {
4627 #if wxUSE_UNICODE
4628 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4629 #else
4630 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4631 #endif
4632 }
4633 return pyobj;
4634 }
4635
4636
4637 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4638 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4639 return 1;
4640 }
4641
4642
4643 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4644 PyObject *pyobj = 0;
4645
4646 {
4647 #if wxUSE_UNICODE
4648 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4649 #else
4650 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4651 #endif
4652 }
4653 return pyobj;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658 PyObject *resultobj = 0;
4659 long result;
4660
4661 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4662 {
4663 PyThreadState* __tstate = wxPyBeginAllowThreads();
4664 result = (long)wxNewId();
4665 wxPyEndAllowThreads(__tstate);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 resultobj = SWIG_From_long(static_cast< long >(result));
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 long arg1 ;
4678 long val1 ;
4679 int ecode1 = 0 ;
4680 PyObject * obj0 = 0 ;
4681 char * kwnames[] = {
4682 (char *) "id", NULL
4683 };
4684
4685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4686 ecode1 = SWIG_AsVal_long(obj0, &val1);
4687 if (!SWIG_IsOK(ecode1)) {
4688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4689 }
4690 arg1 = static_cast< long >(val1);
4691 {
4692 PyThreadState* __tstate = wxPyBeginAllowThreads();
4693 wxRegisterId(arg1);
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_Py_Void();
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4705 PyObject *resultobj = 0;
4706 long result;
4707
4708 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 result = (long)wxGetCurrentId();
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 resultobj = SWIG_From_long(static_cast< long >(result));
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj = 0;
4724 int arg1 ;
4725 bool result;
4726 int val1 ;
4727 int ecode1 = 0 ;
4728 PyObject * obj0 = 0 ;
4729 char * kwnames[] = {
4730 (char *) "id", NULL
4731 };
4732
4733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4734 ecode1 = SWIG_AsVal_int(obj0, &val1);
4735 if (!SWIG_IsOK(ecode1)) {
4736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4737 }
4738 arg1 = static_cast< int >(val1);
4739 {
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 result = (bool)wxIsStockID(arg1);
4742 wxPyEndAllowThreads(__tstate);
4743 if (PyErr_Occurred()) SWIG_fail;
4744 }
4745 {
4746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4747 }
4748 return resultobj;
4749 fail:
4750 return NULL;
4751 }
4752
4753
4754 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4755 PyObject *resultobj = 0;
4756 int arg1 ;
4757 wxString *arg2 = 0 ;
4758 bool result;
4759 int val1 ;
4760 int ecode1 = 0 ;
4761 bool temp2 = false ;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 char * kwnames[] = {
4765 (char *) "id",(char *) "label", NULL
4766 };
4767
4768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4769 ecode1 = SWIG_AsVal_int(obj0, &val1);
4770 if (!SWIG_IsOK(ecode1)) {
4771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4772 }
4773 arg1 = static_cast< int >(val1);
4774 {
4775 arg2 = wxString_in_helper(obj1);
4776 if (arg2 == NULL) SWIG_fail;
4777 temp2 = true;
4778 }
4779 {
4780 PyThreadState* __tstate = wxPyBeginAllowThreads();
4781 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4782 wxPyEndAllowThreads(__tstate);
4783 if (PyErr_Occurred()) SWIG_fail;
4784 }
4785 {
4786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4787 }
4788 {
4789 if (temp2)
4790 delete arg2;
4791 }
4792 return resultobj;
4793 fail:
4794 {
4795 if (temp2)
4796 delete arg2;
4797 }
4798 return NULL;
4799 }
4800
4801
4802 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4803 PyObject *resultobj = 0;
4804 int arg1 ;
4805 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4806 wxString result;
4807 int val1 ;
4808 int ecode1 = 0 ;
4809 long val2 ;
4810 int ecode2 = 0 ;
4811 PyObject * obj0 = 0 ;
4812 PyObject * obj1 = 0 ;
4813 char * kwnames[] = {
4814 (char *) "id",(char *) "flags", NULL
4815 };
4816
4817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4818 ecode1 = SWIG_AsVal_int(obj0, &val1);
4819 if (!SWIG_IsOK(ecode1)) {
4820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4821 }
4822 arg1 = static_cast< int >(val1);
4823 if (obj1) {
4824 ecode2 = SWIG_AsVal_long(obj1, &val2);
4825 if (!SWIG_IsOK(ecode2)) {
4826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4827 }
4828 arg2 = static_cast< long >(val2);
4829 }
4830 {
4831 PyThreadState* __tstate = wxPyBeginAllowThreads();
4832 result = wxGetStockLabel(arg1,arg2);
4833 wxPyEndAllowThreads(__tstate);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 {
4837 #if wxUSE_UNICODE
4838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4839 #else
4840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4841 #endif
4842 }
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 int arg1 ;
4852 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4853 wxString result;
4854 int val1 ;
4855 int ecode1 = 0 ;
4856 int val2 ;
4857 int ecode2 = 0 ;
4858 PyObject * obj0 = 0 ;
4859 PyObject * obj1 = 0 ;
4860 char * kwnames[] = {
4861 (char *) "id",(char *) "client", NULL
4862 };
4863
4864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4865 ecode1 = SWIG_AsVal_int(obj0, &val1);
4866 if (!SWIG_IsOK(ecode1)) {
4867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4868 }
4869 arg1 = static_cast< int >(val1);
4870 if (obj1) {
4871 ecode2 = SWIG_AsVal_int(obj1, &val2);
4872 if (!SWIG_IsOK(ecode2)) {
4873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4874 }
4875 arg2 = static_cast< wxStockHelpStringClient >(val2);
4876 }
4877 {
4878 PyThreadState* __tstate = wxPyBeginAllowThreads();
4879 result = wxGetStockHelpString(arg1,arg2);
4880 wxPyEndAllowThreads(__tstate);
4881 if (PyErr_Occurred()) SWIG_fail;
4882 }
4883 {
4884 #if wxUSE_UNICODE
4885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4886 #else
4887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4888 #endif
4889 }
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4897 PyObject *resultobj = 0;
4898
4899 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4900 {
4901 if (!wxPyCheckForApp()) SWIG_fail;
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 wxBell();
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 resultobj = SWIG_Py_Void();
4908 return resultobj;
4909 fail:
4910 return NULL;
4911 }
4912
4913
4914 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4915 PyObject *resultobj = 0;
4916
4917 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4918 {
4919 if (!wxPyCheckForApp()) SWIG_fail;
4920 PyThreadState* __tstate = wxPyBeginAllowThreads();
4921 wxEndBusyCursor();
4922 wxPyEndAllowThreads(__tstate);
4923 if (PyErr_Occurred()) SWIG_fail;
4924 }
4925 resultobj = SWIG_Py_Void();
4926 return resultobj;
4927 fail:
4928 return NULL;
4929 }
4930
4931
4932 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4933 PyObject *resultobj = 0;
4934 bool arg1 = (bool) true ;
4935 long result;
4936 bool val1 ;
4937 int ecode1 = 0 ;
4938 PyObject * obj0 = 0 ;
4939 char * kwnames[] = {
4940 (char *) "resetTimer", NULL
4941 };
4942
4943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4944 if (obj0) {
4945 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4946 if (!SWIG_IsOK(ecode1)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4948 }
4949 arg1 = static_cast< bool >(val1);
4950 }
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 result = (long)wxGetElapsedTime(arg1);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_From_long(static_cast< long >(result));
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4965 PyObject *resultobj = 0;
4966 bool result;
4967
4968 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4969 {
4970 PyThreadState* __tstate = wxPyBeginAllowThreads();
4971 result = (bool)wxIsBusy();
4972 wxPyEndAllowThreads(__tstate);
4973 if (PyErr_Occurred()) SWIG_fail;
4974 }
4975 {
4976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4977 }
4978 return resultobj;
4979 fail:
4980 return NULL;
4981 }
4982
4983
4984 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4985 PyObject *resultobj = 0;
4986 wxString result;
4987
4988 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 result = wxNow();
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 {
4996 #if wxUSE_UNICODE
4997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4998 #else
4999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5000 #endif
5001 }
5002 return resultobj;
5003 fail:
5004 return NULL;
5005 }
5006
5007
5008 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5009 PyObject *resultobj = 0;
5010 wxString const &arg1_defvalue = wxPyEmptyString ;
5011 wxString *arg1 = (wxString *) &arg1_defvalue ;
5012 bool result;
5013 bool temp1 = false ;
5014 PyObject * obj0 = 0 ;
5015 char * kwnames[] = {
5016 (char *) "command", NULL
5017 };
5018
5019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5020 if (obj0) {
5021 {
5022 arg1 = wxString_in_helper(obj0);
5023 if (arg1 == NULL) SWIG_fail;
5024 temp1 = true;
5025 }
5026 }
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 result = (bool)wxShell((wxString const &)*arg1);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 {
5034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5035 }
5036 {
5037 if (temp1)
5038 delete arg1;
5039 }
5040 return resultobj;
5041 fail:
5042 {
5043 if (temp1)
5044 delete arg1;
5045 }
5046 return NULL;
5047 }
5048
5049
5050 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5051 PyObject *resultobj = 0;
5052
5053 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5054 {
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 wxStartTimer();
5057 wxPyEndAllowThreads(__tstate);
5058 if (PyErr_Occurred()) SWIG_fail;
5059 }
5060 resultobj = SWIG_Py_Void();
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068 PyObject *resultobj = 0;
5069 int *arg1 = (int *) 0 ;
5070 int *arg2 = (int *) 0 ;
5071 int result;
5072 int temp1 ;
5073 int res1 = SWIG_TMPOBJ ;
5074 int temp2 ;
5075 int res2 = SWIG_TMPOBJ ;
5076
5077 arg1 = &temp1;
5078 arg2 = &temp2;
5079 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5080 {
5081 PyThreadState* __tstate = wxPyBeginAllowThreads();
5082 result = (int)wxGetOsVersion(arg1,arg2);
5083 wxPyEndAllowThreads(__tstate);
5084 if (PyErr_Occurred()) SWIG_fail;
5085 }
5086 resultobj = SWIG_From_int(static_cast< int >(result));
5087 if (SWIG_IsTmpObj(res1)) {
5088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5089 } else {
5090 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5092 }
5093 if (SWIG_IsTmpObj(res2)) {
5094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5095 } else {
5096 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5098 }
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5106 PyObject *resultobj = 0;
5107 wxString result;
5108
5109 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = wxGetOsDescription();
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 #if wxUSE_UNICODE
5118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5119 #else
5120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5121 #endif
5122 }
5123 return resultobj;
5124 fail:
5125 return NULL;
5126 }
5127
5128
5129 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5130 PyObject *resultobj = 0;
5131 bool result;
5132
5133 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5134 {
5135 PyThreadState* __tstate = wxPyBeginAllowThreads();
5136 result = (bool)wxIsPlatformLittleEndian();
5137 wxPyEndAllowThreads(__tstate);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 {
5141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5142 }
5143 return resultobj;
5144 fail:
5145 return NULL;
5146 }
5147
5148
5149 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5150 PyObject *resultobj = 0;
5151 bool result;
5152
5153 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5154 {
5155 PyThreadState* __tstate = wxPyBeginAllowThreads();
5156 result = (bool)wxIsPlatform64Bit();
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 {
5161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5162 }
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5170 PyObject *resultobj = 0;
5171 wxMemorySize result;
5172
5173 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5174 {
5175 PyThreadState* __tstate = wxPyBeginAllowThreads();
5176 result = wxGetFreeMemory();
5177 wxPyEndAllowThreads(__tstate);
5178 if (PyErr_Occurred()) SWIG_fail;
5179 }
5180 {
5181 #if wxUSE_LONGLONG
5182 resultobj = PyLong_FromLongLong((&result)->GetValue());
5183 #else
5184 resultobj = PyInt_FromLong(result);
5185 #endif
5186 }
5187 return resultobj;
5188 fail:
5189 return NULL;
5190 }
5191
5192
5193 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5194 PyObject *resultobj = 0;
5195 wxShutdownFlags arg1 ;
5196 bool result;
5197 int val1 ;
5198 int ecode1 = 0 ;
5199 PyObject * obj0 = 0 ;
5200 char * kwnames[] = {
5201 (char *) "wFlags", NULL
5202 };
5203
5204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5205 ecode1 = SWIG_AsVal_int(obj0, &val1);
5206 if (!SWIG_IsOK(ecode1)) {
5207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5208 }
5209 arg1 = static_cast< wxShutdownFlags >(val1);
5210 {
5211 if (!wxPyCheckForApp()) SWIG_fail;
5212 PyThreadState* __tstate = wxPyBeginAllowThreads();
5213 result = (bool)wxShutdown(arg1);
5214 wxPyEndAllowThreads(__tstate);
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 {
5218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5219 }
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj = 0;
5228 int arg1 ;
5229 int val1 ;
5230 int ecode1 = 0 ;
5231 PyObject * obj0 = 0 ;
5232 char * kwnames[] = {
5233 (char *) "secs", NULL
5234 };
5235
5236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5237 ecode1 = SWIG_AsVal_int(obj0, &val1);
5238 if (!SWIG_IsOK(ecode1)) {
5239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5240 }
5241 arg1 = static_cast< int >(val1);
5242 {
5243 PyThreadState* __tstate = wxPyBeginAllowThreads();
5244 wxSleep(arg1);
5245 wxPyEndAllowThreads(__tstate);
5246 if (PyErr_Occurred()) SWIG_fail;
5247 }
5248 resultobj = SWIG_Py_Void();
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5256 PyObject *resultobj = 0;
5257 unsigned long arg1 ;
5258 unsigned long val1 ;
5259 int ecode1 = 0 ;
5260 PyObject * obj0 = 0 ;
5261 char * kwnames[] = {
5262 (char *) "milliseconds", NULL
5263 };
5264
5265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5266 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5267 if (!SWIG_IsOK(ecode1)) {
5268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5269 }
5270 arg1 = static_cast< unsigned long >(val1);
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 wxMilliSleep(arg1);
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5285 PyObject *resultobj = 0;
5286 unsigned long arg1 ;
5287 unsigned long val1 ;
5288 int ecode1 = 0 ;
5289 PyObject * obj0 = 0 ;
5290 char * kwnames[] = {
5291 (char *) "microseconds", NULL
5292 };
5293
5294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5295 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5296 if (!SWIG_IsOK(ecode1)) {
5297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5298 }
5299 arg1 = static_cast< unsigned long >(val1);
5300 {
5301 PyThreadState* __tstate = wxPyBeginAllowThreads();
5302 wxMicroSleep(arg1);
5303 wxPyEndAllowThreads(__tstate);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 resultobj = SWIG_Py_Void();
5307 return resultobj;
5308 fail:
5309 return NULL;
5310 }
5311
5312
5313 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5314 PyObject *resultobj = 0;
5315 bool arg1 ;
5316 bool val1 ;
5317 int ecode1 = 0 ;
5318 PyObject * obj0 = 0 ;
5319 char * kwnames[] = {
5320 (char *) "enable", NULL
5321 };
5322
5323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5324 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5327 }
5328 arg1 = static_cast< bool >(val1);
5329 {
5330 PyThreadState* __tstate = wxPyBeginAllowThreads();
5331 wxEnableTopLevelWindows(arg1);
5332 wxPyEndAllowThreads(__tstate);
5333 if (PyErr_Occurred()) SWIG_fail;
5334 }
5335 resultobj = SWIG_Py_Void();
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj = 0;
5344 wxString *arg1 = 0 ;
5345 wxString result;
5346 bool temp1 = false ;
5347 PyObject * obj0 = 0 ;
5348 char * kwnames[] = {
5349 (char *) "in", NULL
5350 };
5351
5352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5353 {
5354 arg1 = wxString_in_helper(obj0);
5355 if (arg1 == NULL) SWIG_fail;
5356 temp1 = true;
5357 }
5358 {
5359 PyThreadState* __tstate = wxPyBeginAllowThreads();
5360 result = wxStripMenuCodes((wxString const &)*arg1);
5361 wxPyEndAllowThreads(__tstate);
5362 if (PyErr_Occurred()) SWIG_fail;
5363 }
5364 {
5365 #if wxUSE_UNICODE
5366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5367 #else
5368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5369 #endif
5370 }
5371 {
5372 if (temp1)
5373 delete arg1;
5374 }
5375 return resultobj;
5376 fail:
5377 {
5378 if (temp1)
5379 delete arg1;
5380 }
5381 return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5386 PyObject *resultobj = 0;
5387 wxString result;
5388
5389 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 result = wxGetEmailAddress();
5393 wxPyEndAllowThreads(__tstate);
5394 if (PyErr_Occurred()) SWIG_fail;
5395 }
5396 {
5397 #if wxUSE_UNICODE
5398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5399 #else
5400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5401 #endif
5402 }
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5410 PyObject *resultobj = 0;
5411 wxString result;
5412
5413 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5414 {
5415 PyThreadState* __tstate = wxPyBeginAllowThreads();
5416 result = wxGetHostName();
5417 wxPyEndAllowThreads(__tstate);
5418 if (PyErr_Occurred()) SWIG_fail;
5419 }
5420 {
5421 #if wxUSE_UNICODE
5422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5423 #else
5424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5425 #endif
5426 }
5427 return resultobj;
5428 fail:
5429 return NULL;
5430 }
5431
5432
5433 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5434 PyObject *resultobj = 0;
5435 wxString result;
5436
5437 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5438 {
5439 PyThreadState* __tstate = wxPyBeginAllowThreads();
5440 result = wxGetFullHostName();
5441 wxPyEndAllowThreads(__tstate);
5442 if (PyErr_Occurred()) SWIG_fail;
5443 }
5444 {
5445 #if wxUSE_UNICODE
5446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5447 #else
5448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5449 #endif
5450 }
5451 return resultobj;
5452 fail:
5453 return NULL;
5454 }
5455
5456
5457 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5458 PyObject *resultobj = 0;
5459 wxString result;
5460
5461 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = wxGetUserId();
5465 wxPyEndAllowThreads(__tstate);
5466 if (PyErr_Occurred()) SWIG_fail;
5467 }
5468 {
5469 #if wxUSE_UNICODE
5470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5471 #else
5472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5473 #endif
5474 }
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5482 PyObject *resultobj = 0;
5483 wxString result;
5484
5485 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5486 {
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = wxGetUserName();
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 {
5493 #if wxUSE_UNICODE
5494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5495 #else
5496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5497 #endif
5498 }
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5506 PyObject *resultobj = 0;
5507 wxString result;
5508
5509 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5510 {
5511 PyThreadState* __tstate = wxPyBeginAllowThreads();
5512 result = wxGetHomeDir();
5513 wxPyEndAllowThreads(__tstate);
5514 if (PyErr_Occurred()) SWIG_fail;
5515 }
5516 {
5517 #if wxUSE_UNICODE
5518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5519 #else
5520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5521 #endif
5522 }
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj = 0;
5531 wxString const &arg1_defvalue = wxPyEmptyString ;
5532 wxString *arg1 = (wxString *) &arg1_defvalue ;
5533 wxString result;
5534 bool temp1 = false ;
5535 PyObject * obj0 = 0 ;
5536 char * kwnames[] = {
5537 (char *) "user", NULL
5538 };
5539
5540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5541 if (obj0) {
5542 {
5543 arg1 = wxString_in_helper(obj0);
5544 if (arg1 == NULL) SWIG_fail;
5545 temp1 = true;
5546 }
5547 }
5548 {
5549 PyThreadState* __tstate = wxPyBeginAllowThreads();
5550 result = wxGetUserHome((wxString const &)*arg1);
5551 wxPyEndAllowThreads(__tstate);
5552 if (PyErr_Occurred()) SWIG_fail;
5553 }
5554 {
5555 #if wxUSE_UNICODE
5556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5557 #else
5558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5559 #endif
5560 }
5561 {
5562 if (temp1)
5563 delete arg1;
5564 }
5565 return resultobj;
5566 fail:
5567 {
5568 if (temp1)
5569 delete arg1;
5570 }
5571 return NULL;
5572 }
5573
5574
5575 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5576 PyObject *resultobj = 0;
5577 unsigned long result;
5578
5579 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (unsigned long)wxGetProcessId();
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *resultobj = 0;
5595
5596 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5597 {
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 wxTrap();
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 resultobj = SWIG_Py_Void();
5604 return resultobj;
5605 fail:
5606 return NULL;
5607 }
5608
5609
5610 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5611 PyObject *resultobj = 0;
5612 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5613 wxString *arg1 = (wxString *) &arg1_defvalue ;
5614 wxString const &arg2_defvalue = wxPyEmptyString ;
5615 wxString *arg2 = (wxString *) &arg2_defvalue ;
5616 wxString const &arg3_defvalue = wxPyEmptyString ;
5617 wxString *arg3 = (wxString *) &arg3_defvalue ;
5618 wxString const &arg4_defvalue = wxPyEmptyString ;
5619 wxString *arg4 = (wxString *) &arg4_defvalue ;
5620 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5621 wxString *arg5 = (wxString *) &arg5_defvalue ;
5622 int arg6 = (int) 0 ;
5623 wxWindow *arg7 = (wxWindow *) NULL ;
5624 int arg8 = (int) -1 ;
5625 int arg9 = (int) -1 ;
5626 wxString result;
5627 bool temp1 = false ;
5628 bool temp2 = false ;
5629 bool temp3 = false ;
5630 bool temp4 = false ;
5631 bool temp5 = false ;
5632 int val6 ;
5633 int ecode6 = 0 ;
5634 void *argp7 = 0 ;
5635 int res7 = 0 ;
5636 int val8 ;
5637 int ecode8 = 0 ;
5638 int val9 ;
5639 int ecode9 = 0 ;
5640 PyObject * obj0 = 0 ;
5641 PyObject * obj1 = 0 ;
5642 PyObject * obj2 = 0 ;
5643 PyObject * obj3 = 0 ;
5644 PyObject * obj4 = 0 ;
5645 PyObject * obj5 = 0 ;
5646 PyObject * obj6 = 0 ;
5647 PyObject * obj7 = 0 ;
5648 PyObject * obj8 = 0 ;
5649 char * kwnames[] = {
5650 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5651 };
5652
5653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5654 if (obj0) {
5655 {
5656 arg1 = wxString_in_helper(obj0);
5657 if (arg1 == NULL) SWIG_fail;
5658 temp1 = true;
5659 }
5660 }
5661 if (obj1) {
5662 {
5663 arg2 = wxString_in_helper(obj1);
5664 if (arg2 == NULL) SWIG_fail;
5665 temp2 = true;
5666 }
5667 }
5668 if (obj2) {
5669 {
5670 arg3 = wxString_in_helper(obj2);
5671 if (arg3 == NULL) SWIG_fail;
5672 temp3 = true;
5673 }
5674 }
5675 if (obj3) {
5676 {
5677 arg4 = wxString_in_helper(obj3);
5678 if (arg4 == NULL) SWIG_fail;
5679 temp4 = true;
5680 }
5681 }
5682 if (obj4) {
5683 {
5684 arg5 = wxString_in_helper(obj4);
5685 if (arg5 == NULL) SWIG_fail;
5686 temp5 = true;
5687 }
5688 }
5689 if (obj5) {
5690 ecode6 = SWIG_AsVal_int(obj5, &val6);
5691 if (!SWIG_IsOK(ecode6)) {
5692 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5693 }
5694 arg6 = static_cast< int >(val6);
5695 }
5696 if (obj6) {
5697 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5698 if (!SWIG_IsOK(res7)) {
5699 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5700 }
5701 arg7 = reinterpret_cast< wxWindow * >(argp7);
5702 }
5703 if (obj7) {
5704 ecode8 = SWIG_AsVal_int(obj7, &val8);
5705 if (!SWIG_IsOK(ecode8)) {
5706 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5707 }
5708 arg8 = static_cast< int >(val8);
5709 }
5710 if (obj8) {
5711 ecode9 = SWIG_AsVal_int(obj8, &val9);
5712 if (!SWIG_IsOK(ecode9)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5714 }
5715 arg9 = static_cast< int >(val9);
5716 }
5717 {
5718 if (!wxPyCheckForApp()) SWIG_fail;
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5721 wxPyEndAllowThreads(__tstate);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 {
5725 #if wxUSE_UNICODE
5726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5727 #else
5728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5729 #endif
5730 }
5731 {
5732 if (temp1)
5733 delete arg1;
5734 }
5735 {
5736 if (temp2)
5737 delete arg2;
5738 }
5739 {
5740 if (temp3)
5741 delete arg3;
5742 }
5743 {
5744 if (temp4)
5745 delete arg4;
5746 }
5747 {
5748 if (temp5)
5749 delete arg5;
5750 }
5751 return resultobj;
5752 fail:
5753 {
5754 if (temp1)
5755 delete arg1;
5756 }
5757 {
5758 if (temp2)
5759 delete arg2;
5760 }
5761 {
5762 if (temp3)
5763 delete arg3;
5764 }
5765 {
5766 if (temp4)
5767 delete arg4;
5768 }
5769 {
5770 if (temp5)
5771 delete arg5;
5772 }
5773 return NULL;
5774 }
5775
5776
5777 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj = 0;
5779 wxString *arg1 = 0 ;
5780 wxString *arg2 = 0 ;
5781 wxString const &arg3_defvalue = wxPyEmptyString ;
5782 wxString *arg3 = (wxString *) &arg3_defvalue ;
5783 wxWindow *arg4 = (wxWindow *) NULL ;
5784 wxString result;
5785 bool temp1 = false ;
5786 bool temp2 = false ;
5787 bool temp3 = false ;
5788 void *argp4 = 0 ;
5789 int res4 = 0 ;
5790 PyObject * obj0 = 0 ;
5791 PyObject * obj1 = 0 ;
5792 PyObject * obj2 = 0 ;
5793 PyObject * obj3 = 0 ;
5794 char * kwnames[] = {
5795 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5796 };
5797
5798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5799 {
5800 arg1 = wxString_in_helper(obj0);
5801 if (arg1 == NULL) SWIG_fail;
5802 temp1 = true;
5803 }
5804 {
5805 arg2 = wxString_in_helper(obj1);
5806 if (arg2 == NULL) SWIG_fail;
5807 temp2 = true;
5808 }
5809 if (obj2) {
5810 {
5811 arg3 = wxString_in_helper(obj2);
5812 if (arg3 == NULL) SWIG_fail;
5813 temp3 = true;
5814 }
5815 }
5816 if (obj3) {
5817 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5818 if (!SWIG_IsOK(res4)) {
5819 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5820 }
5821 arg4 = reinterpret_cast< wxWindow * >(argp4);
5822 }
5823 {
5824 if (!wxPyCheckForApp()) SWIG_fail;
5825 PyThreadState* __tstate = wxPyBeginAllowThreads();
5826 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5827 wxPyEndAllowThreads(__tstate);
5828 if (PyErr_Occurred()) SWIG_fail;
5829 }
5830 {
5831 #if wxUSE_UNICODE
5832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5833 #else
5834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5835 #endif
5836 }
5837 {
5838 if (temp1)
5839 delete arg1;
5840 }
5841 {
5842 if (temp2)
5843 delete arg2;
5844 }
5845 {
5846 if (temp3)
5847 delete arg3;
5848 }
5849 return resultobj;
5850 fail:
5851 {
5852 if (temp1)
5853 delete arg1;
5854 }
5855 {
5856 if (temp2)
5857 delete arg2;
5858 }
5859 {
5860 if (temp3)
5861 delete arg3;
5862 }
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5868 PyObject *resultobj = 0;
5869 wxString *arg1 = 0 ;
5870 wxString *arg2 = 0 ;
5871 wxString const &arg3_defvalue = wxPyEmptyString ;
5872 wxString *arg3 = (wxString *) &arg3_defvalue ;
5873 wxWindow *arg4 = (wxWindow *) NULL ;
5874 wxString result;
5875 bool temp1 = false ;
5876 bool temp2 = false ;
5877 bool temp3 = false ;
5878 void *argp4 = 0 ;
5879 int res4 = 0 ;
5880 PyObject * obj0 = 0 ;
5881 PyObject * obj1 = 0 ;
5882 PyObject * obj2 = 0 ;
5883 PyObject * obj3 = 0 ;
5884 char * kwnames[] = {
5885 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5886 };
5887
5888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5889 {
5890 arg1 = wxString_in_helper(obj0);
5891 if (arg1 == NULL) SWIG_fail;
5892 temp1 = true;
5893 }
5894 {
5895 arg2 = wxString_in_helper(obj1);
5896 if (arg2 == NULL) SWIG_fail;
5897 temp2 = true;
5898 }
5899 if (obj2) {
5900 {
5901 arg3 = wxString_in_helper(obj2);
5902 if (arg3 == NULL) SWIG_fail;
5903 temp3 = true;
5904 }
5905 }
5906 if (obj3) {
5907 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5908 if (!SWIG_IsOK(res4)) {
5909 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5910 }
5911 arg4 = reinterpret_cast< wxWindow * >(argp4);
5912 }
5913 {
5914 if (!wxPyCheckForApp()) SWIG_fail;
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 {
5921 #if wxUSE_UNICODE
5922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5923 #else
5924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5925 #endif
5926 }
5927 {
5928 if (temp1)
5929 delete arg1;
5930 }
5931 {
5932 if (temp2)
5933 delete arg2;
5934 }
5935 {
5936 if (temp3)
5937 delete arg3;
5938 }
5939 return resultobj;
5940 fail:
5941 {
5942 if (temp1)
5943 delete arg1;
5944 }
5945 {
5946 if (temp2)
5947 delete arg2;
5948 }
5949 {
5950 if (temp3)
5951 delete arg3;
5952 }
5953 return NULL;
5954 }
5955
5956
5957 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5958 PyObject *resultobj = 0;
5959 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5960 wxString *arg1 = (wxString *) &arg1_defvalue ;
5961 wxString const &arg2_defvalue = wxPyEmptyString ;
5962 wxString *arg2 = (wxString *) &arg2_defvalue ;
5963 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5964 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5965 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5966 wxWindow *arg5 = (wxWindow *) NULL ;
5967 wxString result;
5968 bool temp1 = false ;
5969 bool temp2 = false ;
5970 long val3 ;
5971 int ecode3 = 0 ;
5972 wxPoint temp4 ;
5973 void *argp5 = 0 ;
5974 int res5 = 0 ;
5975 PyObject * obj0 = 0 ;
5976 PyObject * obj1 = 0 ;
5977 PyObject * obj2 = 0 ;
5978 PyObject * obj3 = 0 ;
5979 PyObject * obj4 = 0 ;
5980 char * kwnames[] = {
5981 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5982 };
5983
5984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5985 if (obj0) {
5986 {
5987 arg1 = wxString_in_helper(obj0);
5988 if (arg1 == NULL) SWIG_fail;
5989 temp1 = true;
5990 }
5991 }
5992 if (obj1) {
5993 {
5994 arg2 = wxString_in_helper(obj1);
5995 if (arg2 == NULL) SWIG_fail;
5996 temp2 = true;
5997 }
5998 }
5999 if (obj2) {
6000 ecode3 = SWIG_AsVal_long(obj2, &val3);
6001 if (!SWIG_IsOK(ecode3)) {
6002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6003 }
6004 arg3 = static_cast< long >(val3);
6005 }
6006 if (obj3) {
6007 {
6008 arg4 = &temp4;
6009 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6010 }
6011 }
6012 if (obj4) {
6013 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6014 if (!SWIG_IsOK(res5)) {
6015 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6016 }
6017 arg5 = reinterpret_cast< wxWindow * >(argp5);
6018 }
6019 {
6020 if (!wxPyCheckForApp()) SWIG_fail;
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 {
6027 #if wxUSE_UNICODE
6028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6029 #else
6030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6031 #endif
6032 }
6033 {
6034 if (temp1)
6035 delete arg1;
6036 }
6037 {
6038 if (temp2)
6039 delete arg2;
6040 }
6041 return resultobj;
6042 fail:
6043 {
6044 if (temp1)
6045 delete arg1;
6046 }
6047 {
6048 if (temp2)
6049 delete arg2;
6050 }
6051 return NULL;
6052 }
6053
6054
6055 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6056 PyObject *resultobj = 0;
6057 wxString *arg1 = 0 ;
6058 wxString const &arg2_defvalue = wxPyEmptyString ;
6059 wxString *arg2 = (wxString *) &arg2_defvalue ;
6060 wxString const &arg3_defvalue = wxPyEmptyString ;
6061 wxString *arg3 = (wxString *) &arg3_defvalue ;
6062 wxWindow *arg4 = (wxWindow *) NULL ;
6063 int arg5 = (int) -1 ;
6064 int arg6 = (int) -1 ;
6065 bool arg7 = (bool) true ;
6066 wxString result;
6067 bool temp1 = false ;
6068 bool temp2 = false ;
6069 bool temp3 = false ;
6070 void *argp4 = 0 ;
6071 int res4 = 0 ;
6072 int val5 ;
6073 int ecode5 = 0 ;
6074 int val6 ;
6075 int ecode6 = 0 ;
6076 bool val7 ;
6077 int ecode7 = 0 ;
6078 PyObject * obj0 = 0 ;
6079 PyObject * obj1 = 0 ;
6080 PyObject * obj2 = 0 ;
6081 PyObject * obj3 = 0 ;
6082 PyObject * obj4 = 0 ;
6083 PyObject * obj5 = 0 ;
6084 PyObject * obj6 = 0 ;
6085 char * kwnames[] = {
6086 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6087 };
6088
6089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6090 {
6091 arg1 = wxString_in_helper(obj0);
6092 if (arg1 == NULL) SWIG_fail;
6093 temp1 = true;
6094 }
6095 if (obj1) {
6096 {
6097 arg2 = wxString_in_helper(obj1);
6098 if (arg2 == NULL) SWIG_fail;
6099 temp2 = true;
6100 }
6101 }
6102 if (obj2) {
6103 {
6104 arg3 = wxString_in_helper(obj2);
6105 if (arg3 == NULL) SWIG_fail;
6106 temp3 = true;
6107 }
6108 }
6109 if (obj3) {
6110 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6111 if (!SWIG_IsOK(res4)) {
6112 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6113 }
6114 arg4 = reinterpret_cast< wxWindow * >(argp4);
6115 }
6116 if (obj4) {
6117 ecode5 = SWIG_AsVal_int(obj4, &val5);
6118 if (!SWIG_IsOK(ecode5)) {
6119 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6120 }
6121 arg5 = static_cast< int >(val5);
6122 }
6123 if (obj5) {
6124 ecode6 = SWIG_AsVal_int(obj5, &val6);
6125 if (!SWIG_IsOK(ecode6)) {
6126 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6127 }
6128 arg6 = static_cast< int >(val6);
6129 }
6130 if (obj6) {
6131 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6132 if (!SWIG_IsOK(ecode7)) {
6133 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6134 }
6135 arg7 = static_cast< bool >(val7);
6136 }
6137 {
6138 if (!wxPyCheckForApp()) SWIG_fail;
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 {
6145 #if wxUSE_UNICODE
6146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6147 #else
6148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6149 #endif
6150 }
6151 {
6152 if (temp1)
6153 delete arg1;
6154 }
6155 {
6156 if (temp2)
6157 delete arg2;
6158 }
6159 {
6160 if (temp3)
6161 delete arg3;
6162 }
6163 return resultobj;
6164 fail:
6165 {
6166 if (temp1)
6167 delete arg1;
6168 }
6169 {
6170 if (temp2)
6171 delete arg2;
6172 }
6173 {
6174 if (temp3)
6175 delete arg3;
6176 }
6177 return NULL;
6178 }
6179
6180
6181 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj = 0;
6183 wxString *arg1 = 0 ;
6184 wxString const &arg2_defvalue = wxPyEmptyString ;
6185 wxString *arg2 = (wxString *) &arg2_defvalue ;
6186 wxString const &arg3_defvalue = wxPyEmptyString ;
6187 wxString *arg3 = (wxString *) &arg3_defvalue ;
6188 wxWindow *arg4 = (wxWindow *) NULL ;
6189 wxString result;
6190 bool temp1 = false ;
6191 bool temp2 = false ;
6192 bool temp3 = false ;
6193 void *argp4 = 0 ;
6194 int res4 = 0 ;
6195 PyObject * obj0 = 0 ;
6196 PyObject * obj1 = 0 ;
6197 PyObject * obj2 = 0 ;
6198 PyObject * obj3 = 0 ;
6199 char * kwnames[] = {
6200 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6201 };
6202
6203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6204 {
6205 arg1 = wxString_in_helper(obj0);
6206 if (arg1 == NULL) SWIG_fail;
6207 temp1 = true;
6208 }
6209 if (obj1) {
6210 {
6211 arg2 = wxString_in_helper(obj1);
6212 if (arg2 == NULL) SWIG_fail;
6213 temp2 = true;
6214 }
6215 }
6216 if (obj2) {
6217 {
6218 arg3 = wxString_in_helper(obj2);
6219 if (arg3 == NULL) SWIG_fail;
6220 temp3 = true;
6221 }
6222 }
6223 if (obj3) {
6224 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6225 if (!SWIG_IsOK(res4)) {
6226 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6227 }
6228 arg4 = reinterpret_cast< wxWindow * >(argp4);
6229 }
6230 {
6231 if (!wxPyCheckForApp()) SWIG_fail;
6232 PyThreadState* __tstate = wxPyBeginAllowThreads();
6233 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6234 wxPyEndAllowThreads(__tstate);
6235 if (PyErr_Occurred()) SWIG_fail;
6236 }
6237 {
6238 #if wxUSE_UNICODE
6239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6240 #else
6241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6242 #endif
6243 }
6244 {
6245 if (temp1)
6246 delete arg1;
6247 }
6248 {
6249 if (temp2)
6250 delete arg2;
6251 }
6252 {
6253 if (temp3)
6254 delete arg3;
6255 }
6256 return resultobj;
6257 fail:
6258 {
6259 if (temp1)
6260 delete arg1;
6261 }
6262 {
6263 if (temp2)
6264 delete arg2;
6265 }
6266 {
6267 if (temp3)
6268 delete arg3;
6269 }
6270 return NULL;
6271 }
6272
6273
6274 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6275 PyObject *resultobj = 0;
6276 wxString *arg1 = 0 ;
6277 wxString *arg2 = 0 ;
6278 int arg3 ;
6279 wxString *arg4 = (wxString *) 0 ;
6280 wxWindow *arg5 = (wxWindow *) NULL ;
6281 int arg6 = (int) -1 ;
6282 int arg7 = (int) -1 ;
6283 bool arg8 = (bool) true ;
6284 int arg9 = (int) 150 ;
6285 int arg10 = (int) 200 ;
6286 wxString result;
6287 bool temp1 = false ;
6288 bool temp2 = false ;
6289 void *argp5 = 0 ;
6290 int res5 = 0 ;
6291 int val6 ;
6292 int ecode6 = 0 ;
6293 int val7 ;
6294 int ecode7 = 0 ;
6295 bool val8 ;
6296 int ecode8 = 0 ;
6297 int val9 ;
6298 int ecode9 = 0 ;
6299 int val10 ;
6300 int ecode10 = 0 ;
6301 PyObject * obj0 = 0 ;
6302 PyObject * obj1 = 0 ;
6303 PyObject * obj2 = 0 ;
6304 PyObject * obj3 = 0 ;
6305 PyObject * obj4 = 0 ;
6306 PyObject * obj5 = 0 ;
6307 PyObject * obj6 = 0 ;
6308 PyObject * obj7 = 0 ;
6309 PyObject * obj8 = 0 ;
6310 char * kwnames[] = {
6311 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6312 };
6313
6314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6315 {
6316 arg1 = wxString_in_helper(obj0);
6317 if (arg1 == NULL) SWIG_fail;
6318 temp1 = true;
6319 }
6320 {
6321 arg2 = wxString_in_helper(obj1);
6322 if (arg2 == NULL) SWIG_fail;
6323 temp2 = true;
6324 }
6325 {
6326 arg3 = PyList_Size(obj2);
6327 arg4 = wxString_LIST_helper(obj2);
6328 if (arg4 == NULL) SWIG_fail;
6329 }
6330 if (obj3) {
6331 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6332 if (!SWIG_IsOK(res5)) {
6333 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6334 }
6335 arg5 = reinterpret_cast< wxWindow * >(argp5);
6336 }
6337 if (obj4) {
6338 ecode6 = SWIG_AsVal_int(obj4, &val6);
6339 if (!SWIG_IsOK(ecode6)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6341 }
6342 arg6 = static_cast< int >(val6);
6343 }
6344 if (obj5) {
6345 ecode7 = SWIG_AsVal_int(obj5, &val7);
6346 if (!SWIG_IsOK(ecode7)) {
6347 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6348 }
6349 arg7 = static_cast< int >(val7);
6350 }
6351 if (obj6) {
6352 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6353 if (!SWIG_IsOK(ecode8)) {
6354 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6355 }
6356 arg8 = static_cast< bool >(val8);
6357 }
6358 if (obj7) {
6359 ecode9 = SWIG_AsVal_int(obj7, &val9);
6360 if (!SWIG_IsOK(ecode9)) {
6361 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6362 }
6363 arg9 = static_cast< int >(val9);
6364 }
6365 if (obj8) {
6366 ecode10 = SWIG_AsVal_int(obj8, &val10);
6367 if (!SWIG_IsOK(ecode10)) {
6368 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6369 }
6370 arg10 = static_cast< int >(val10);
6371 }
6372 {
6373 if (!wxPyCheckForApp()) SWIG_fail;
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6376 wxPyEndAllowThreads(__tstate);
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 {
6380 #if wxUSE_UNICODE
6381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6382 #else
6383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6384 #endif
6385 }
6386 {
6387 if (temp1)
6388 delete arg1;
6389 }
6390 {
6391 if (temp2)
6392 delete arg2;
6393 }
6394 {
6395 if (arg4) delete [] arg4;
6396 }
6397 return resultobj;
6398 fail:
6399 {
6400 if (temp1)
6401 delete arg1;
6402 }
6403 {
6404 if (temp2)
6405 delete arg2;
6406 }
6407 {
6408 if (arg4) delete [] arg4;
6409 }
6410 return NULL;
6411 }
6412
6413
6414 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj = 0;
6416 wxString *arg1 = 0 ;
6417 wxString *arg2 = 0 ;
6418 int arg3 ;
6419 wxString *arg4 = (wxString *) 0 ;
6420 wxWindow *arg5 = (wxWindow *) NULL ;
6421 int arg6 = (int) -1 ;
6422 int arg7 = (int) -1 ;
6423 bool arg8 = (bool) true ;
6424 int arg9 = (int) 150 ;
6425 int arg10 = (int) 200 ;
6426 int result;
6427 bool temp1 = false ;
6428 bool temp2 = false ;
6429 void *argp5 = 0 ;
6430 int res5 = 0 ;
6431 int val6 ;
6432 int ecode6 = 0 ;
6433 int val7 ;
6434 int ecode7 = 0 ;
6435 bool val8 ;
6436 int ecode8 = 0 ;
6437 int val9 ;
6438 int ecode9 = 0 ;
6439 int val10 ;
6440 int ecode10 = 0 ;
6441 PyObject * obj0 = 0 ;
6442 PyObject * obj1 = 0 ;
6443 PyObject * obj2 = 0 ;
6444 PyObject * obj3 = 0 ;
6445 PyObject * obj4 = 0 ;
6446 PyObject * obj5 = 0 ;
6447 PyObject * obj6 = 0 ;
6448 PyObject * obj7 = 0 ;
6449 PyObject * obj8 = 0 ;
6450 char * kwnames[] = {
6451 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6452 };
6453
6454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6455 {
6456 arg1 = wxString_in_helper(obj0);
6457 if (arg1 == NULL) SWIG_fail;
6458 temp1 = true;
6459 }
6460 {
6461 arg2 = wxString_in_helper(obj1);
6462 if (arg2 == NULL) SWIG_fail;
6463 temp2 = true;
6464 }
6465 {
6466 arg3 = PyList_Size(obj2);
6467 arg4 = wxString_LIST_helper(obj2);
6468 if (arg4 == NULL) SWIG_fail;
6469 }
6470 if (obj3) {
6471 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6472 if (!SWIG_IsOK(res5)) {
6473 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6474 }
6475 arg5 = reinterpret_cast< wxWindow * >(argp5);
6476 }
6477 if (obj4) {
6478 ecode6 = SWIG_AsVal_int(obj4, &val6);
6479 if (!SWIG_IsOK(ecode6)) {
6480 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6481 }
6482 arg6 = static_cast< int >(val6);
6483 }
6484 if (obj5) {
6485 ecode7 = SWIG_AsVal_int(obj5, &val7);
6486 if (!SWIG_IsOK(ecode7)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6488 }
6489 arg7 = static_cast< int >(val7);
6490 }
6491 if (obj6) {
6492 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6493 if (!SWIG_IsOK(ecode8)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6495 }
6496 arg8 = static_cast< bool >(val8);
6497 }
6498 if (obj7) {
6499 ecode9 = SWIG_AsVal_int(obj7, &val9);
6500 if (!SWIG_IsOK(ecode9)) {
6501 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6502 }
6503 arg9 = static_cast< int >(val9);
6504 }
6505 if (obj8) {
6506 ecode10 = SWIG_AsVal_int(obj8, &val10);
6507 if (!SWIG_IsOK(ecode10)) {
6508 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6509 }
6510 arg10 = static_cast< int >(val10);
6511 }
6512 {
6513 if (!wxPyCheckForApp()) SWIG_fail;
6514 PyThreadState* __tstate = wxPyBeginAllowThreads();
6515 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6516 wxPyEndAllowThreads(__tstate);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 resultobj = SWIG_From_int(static_cast< int >(result));
6520 {
6521 if (temp1)
6522 delete arg1;
6523 }
6524 {
6525 if (temp2)
6526 delete arg2;
6527 }
6528 {
6529 if (arg4) delete [] arg4;
6530 }
6531 return resultobj;
6532 fail:
6533 {
6534 if (temp1)
6535 delete arg1;
6536 }
6537 {
6538 if (temp2)
6539 delete arg2;
6540 }
6541 {
6542 if (arg4) delete [] arg4;
6543 }
6544 return NULL;
6545 }
6546
6547
6548 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj = 0;
6550 wxString *arg1 = 0 ;
6551 wxString const &arg2_defvalue = wxPyEmptyString ;
6552 wxString *arg2 = (wxString *) &arg2_defvalue ;
6553 int arg3 = (int) wxOK|wxCENTRE ;
6554 wxWindow *arg4 = (wxWindow *) NULL ;
6555 int arg5 = (int) -1 ;
6556 int arg6 = (int) -1 ;
6557 int result;
6558 bool temp1 = false ;
6559 bool temp2 = false ;
6560 int val3 ;
6561 int ecode3 = 0 ;
6562 void *argp4 = 0 ;
6563 int res4 = 0 ;
6564 int val5 ;
6565 int ecode5 = 0 ;
6566 int val6 ;
6567 int ecode6 = 0 ;
6568 PyObject * obj0 = 0 ;
6569 PyObject * obj1 = 0 ;
6570 PyObject * obj2 = 0 ;
6571 PyObject * obj3 = 0 ;
6572 PyObject * obj4 = 0 ;
6573 PyObject * obj5 = 0 ;
6574 char * kwnames[] = {
6575 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6576 };
6577
6578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6579 {
6580 arg1 = wxString_in_helper(obj0);
6581 if (arg1 == NULL) SWIG_fail;
6582 temp1 = true;
6583 }
6584 if (obj1) {
6585 {
6586 arg2 = wxString_in_helper(obj1);
6587 if (arg2 == NULL) SWIG_fail;
6588 temp2 = true;
6589 }
6590 }
6591 if (obj2) {
6592 ecode3 = SWIG_AsVal_int(obj2, &val3);
6593 if (!SWIG_IsOK(ecode3)) {
6594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6595 }
6596 arg3 = static_cast< int >(val3);
6597 }
6598 if (obj3) {
6599 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6600 if (!SWIG_IsOK(res4)) {
6601 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6602 }
6603 arg4 = reinterpret_cast< wxWindow * >(argp4);
6604 }
6605 if (obj4) {
6606 ecode5 = SWIG_AsVal_int(obj4, &val5);
6607 if (!SWIG_IsOK(ecode5)) {
6608 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6609 }
6610 arg5 = static_cast< int >(val5);
6611 }
6612 if (obj5) {
6613 ecode6 = SWIG_AsVal_int(obj5, &val6);
6614 if (!SWIG_IsOK(ecode6)) {
6615 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6616 }
6617 arg6 = static_cast< int >(val6);
6618 }
6619 {
6620 if (!wxPyCheckForApp()) SWIG_fail;
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_From_int(static_cast< int >(result));
6627 {
6628 if (temp1)
6629 delete arg1;
6630 }
6631 {
6632 if (temp2)
6633 delete arg2;
6634 }
6635 return resultobj;
6636 fail:
6637 {
6638 if (temp1)
6639 delete arg1;
6640 }
6641 {
6642 if (temp2)
6643 delete arg2;
6644 }
6645 return NULL;
6646 }
6647
6648
6649 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6650 PyObject *resultobj = 0;
6651 wxString *arg1 = 0 ;
6652 wxString *arg2 = 0 ;
6653 wxString *arg3 = 0 ;
6654 long arg4 ;
6655 long arg5 = (long) 0 ;
6656 long arg6 = (long) 100 ;
6657 wxWindow *arg7 = (wxWindow *) NULL ;
6658 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6659 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6660 long result;
6661 bool temp1 = false ;
6662 bool temp2 = false ;
6663 bool temp3 = false ;
6664 long val4 ;
6665 int ecode4 = 0 ;
6666 long val5 ;
6667 int ecode5 = 0 ;
6668 long val6 ;
6669 int ecode6 = 0 ;
6670 void *argp7 = 0 ;
6671 int res7 = 0 ;
6672 wxPoint temp8 ;
6673 PyObject * obj0 = 0 ;
6674 PyObject * obj1 = 0 ;
6675 PyObject * obj2 = 0 ;
6676 PyObject * obj3 = 0 ;
6677 PyObject * obj4 = 0 ;
6678 PyObject * obj5 = 0 ;
6679 PyObject * obj6 = 0 ;
6680 PyObject * obj7 = 0 ;
6681 char * kwnames[] = {
6682 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6683 };
6684
6685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6686 {
6687 arg1 = wxString_in_helper(obj0);
6688 if (arg1 == NULL) SWIG_fail;
6689 temp1 = true;
6690 }
6691 {
6692 arg2 = wxString_in_helper(obj1);
6693 if (arg2 == NULL) SWIG_fail;
6694 temp2 = true;
6695 }
6696 {
6697 arg3 = wxString_in_helper(obj2);
6698 if (arg3 == NULL) SWIG_fail;
6699 temp3 = true;
6700 }
6701 ecode4 = SWIG_AsVal_long(obj3, &val4);
6702 if (!SWIG_IsOK(ecode4)) {
6703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6704 }
6705 arg4 = static_cast< long >(val4);
6706 if (obj4) {
6707 ecode5 = SWIG_AsVal_long(obj4, &val5);
6708 if (!SWIG_IsOK(ecode5)) {
6709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6710 }
6711 arg5 = static_cast< long >(val5);
6712 }
6713 if (obj5) {
6714 ecode6 = SWIG_AsVal_long(obj5, &val6);
6715 if (!SWIG_IsOK(ecode6)) {
6716 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6717 }
6718 arg6 = static_cast< long >(val6);
6719 }
6720 if (obj6) {
6721 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6722 if (!SWIG_IsOK(res7)) {
6723 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6724 }
6725 arg7 = reinterpret_cast< wxWindow * >(argp7);
6726 }
6727 if (obj7) {
6728 {
6729 arg8 = &temp8;
6730 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6731 }
6732 }
6733 {
6734 if (!wxPyCheckForApp()) SWIG_fail;
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 resultobj = SWIG_From_long(static_cast< long >(result));
6741 {
6742 if (temp1)
6743 delete arg1;
6744 }
6745 {
6746 if (temp2)
6747 delete arg2;
6748 }
6749 {
6750 if (temp3)
6751 delete arg3;
6752 }
6753 return resultobj;
6754 fail:
6755 {
6756 if (temp1)
6757 delete arg1;
6758 }
6759 {
6760 if (temp2)
6761 delete arg2;
6762 }
6763 {
6764 if (temp3)
6765 delete arg3;
6766 }
6767 return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6772 PyObject *resultobj = 0;
6773 bool result;
6774
6775 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6776 {
6777 if (!wxPyCheckForApp()) SWIG_fail;
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = (bool)wxColourDisplay();
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 {
6784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6785 }
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6793 PyObject *resultobj = 0;
6794 int result;
6795
6796 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6797 {
6798 if (!wxPyCheckForApp()) SWIG_fail;
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 result = (int)wxDisplayDepth();
6801 wxPyEndAllowThreads(__tstate);
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 resultobj = SWIG_From_int(static_cast< int >(result));
6805 return resultobj;
6806 fail:
6807 return NULL;
6808 }
6809
6810
6811 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6812 PyObject *resultobj = 0;
6813 int result;
6814
6815 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6816 {
6817 if (!wxPyCheckForApp()) SWIG_fail;
6818 PyThreadState* __tstate = wxPyBeginAllowThreads();
6819 result = (int)wxGetDisplayDepth();
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 resultobj = SWIG_From_int(static_cast< int >(result));
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6831 PyObject *resultobj = 0;
6832 int *arg1 = (int *) 0 ;
6833 int *arg2 = (int *) 0 ;
6834 int temp1 ;
6835 int res1 = SWIG_TMPOBJ ;
6836 int temp2 ;
6837 int res2 = SWIG_TMPOBJ ;
6838
6839 arg1 = &temp1;
6840 arg2 = &temp2;
6841 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6842 {
6843 if (!wxPyCheckForApp()) SWIG_fail;
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 wxDisplaySize(arg1,arg2);
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_Py_Void();
6850 if (SWIG_IsTmpObj(res1)) {
6851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6852 } else {
6853 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6855 }
6856 if (SWIG_IsTmpObj(res2)) {
6857 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6858 } else {
6859 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6860 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6861 }
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6869 PyObject *resultobj = 0;
6870 wxSize result;
6871
6872 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6873 {
6874 if (!wxPyCheckForApp()) SWIG_fail;
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = wxGetDisplaySize();
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6881 return resultobj;
6882 fail:
6883 return NULL;
6884 }
6885
6886
6887 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6888 PyObject *resultobj = 0;
6889 int *arg1 = (int *) 0 ;
6890 int *arg2 = (int *) 0 ;
6891 int temp1 ;
6892 int res1 = SWIG_TMPOBJ ;
6893 int temp2 ;
6894 int res2 = SWIG_TMPOBJ ;
6895
6896 arg1 = &temp1;
6897 arg2 = &temp2;
6898 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6899 {
6900 if (!wxPyCheckForApp()) SWIG_fail;
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 wxDisplaySizeMM(arg1,arg2);
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 resultobj = SWIG_Py_Void();
6907 if (SWIG_IsTmpObj(res1)) {
6908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6909 } else {
6910 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6912 }
6913 if (SWIG_IsTmpObj(res2)) {
6914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6915 } else {
6916 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6918 }
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6926 PyObject *resultobj = 0;
6927 wxSize result;
6928
6929 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6930 {
6931 if (!wxPyCheckForApp()) SWIG_fail;
6932 PyThreadState* __tstate = wxPyBeginAllowThreads();
6933 result = wxGetDisplaySizeMM();
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6945 PyObject *resultobj = 0;
6946 int *arg1 = (int *) 0 ;
6947 int *arg2 = (int *) 0 ;
6948 int *arg3 = (int *) 0 ;
6949 int *arg4 = (int *) 0 ;
6950 int temp1 ;
6951 int res1 = SWIG_TMPOBJ ;
6952 int temp2 ;
6953 int res2 = SWIG_TMPOBJ ;
6954 int temp3 ;
6955 int res3 = SWIG_TMPOBJ ;
6956 int temp4 ;
6957 int res4 = SWIG_TMPOBJ ;
6958
6959 arg1 = &temp1;
6960 arg2 = &temp2;
6961 arg3 = &temp3;
6962 arg4 = &temp4;
6963 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6964 {
6965 if (!wxPyCheckForApp()) SWIG_fail;
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 if (SWIG_IsTmpObj(res1)) {
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6974 } else {
6975 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6977 }
6978 if (SWIG_IsTmpObj(res2)) {
6979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6980 } else {
6981 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6983 }
6984 if (SWIG_IsTmpObj(res3)) {
6985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6986 } else {
6987 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6989 }
6990 if (SWIG_IsTmpObj(res4)) {
6991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6992 } else {
6993 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6995 }
6996 return resultobj;
6997 fail:
6998 return NULL;
6999 }
7000
7001
7002 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7003 PyObject *resultobj = 0;
7004 wxRect result;
7005
7006 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7007 {
7008 if (!wxPyCheckForApp()) SWIG_fail;
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 result = wxGetClientDisplayRect();
7011 wxPyEndAllowThreads(__tstate);
7012 if (PyErr_Occurred()) SWIG_fail;
7013 }
7014 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7015 return resultobj;
7016 fail:
7017 return NULL;
7018 }
7019
7020
7021 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7022 PyObject *resultobj = 0;
7023 wxCursor *arg1 = 0 ;
7024 void *argp1 = 0 ;
7025 int res1 = 0 ;
7026 PyObject * obj0 = 0 ;
7027 char * kwnames[] = {
7028 (char *) "cursor", NULL
7029 };
7030
7031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7032 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7033 if (!SWIG_IsOK(res1)) {
7034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7035 }
7036 if (!argp1) {
7037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7038 }
7039 arg1 = reinterpret_cast< wxCursor * >(argp1);
7040 {
7041 if (!wxPyCheckForApp()) SWIG_fail;
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 wxSetCursor(*arg1);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_Py_Void();
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7055 PyObject *resultobj = 0;
7056 void *result = 0 ;
7057
7058 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7059 {
7060 if (!wxPyCheckForApp()) SWIG_fail;
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 result = (void *)wxGetXDisplay();
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj = 0;
7075 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7076 void *argp1 = 0 ;
7077 int res1 = 0 ;
7078 PyObject * obj0 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "cursor", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7084 if (obj0) {
7085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7088 }
7089 arg1 = reinterpret_cast< wxCursor * >(argp1);
7090 }
7091 {
7092 if (!wxPyCheckForApp()) SWIG_fail;
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 wxBeginBusyCursor(arg1);
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 resultobj = SWIG_Py_Void();
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7106 PyObject *resultobj = 0;
7107 wxPoint result;
7108
7109 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7110 {
7111 if (!wxPyCheckForApp()) SWIG_fail;
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 result = wxGetMousePosition();
7114 wxPyEndAllowThreads(__tstate);
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7125 PyObject *resultobj = 0;
7126 wxWindow *result = 0 ;
7127
7128 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7129 {
7130 if (!wxPyCheckForApp()) SWIG_fail;
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (wxWindow *)FindWindowAtPointer();
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 {
7137 resultobj = wxPyMake_wxObject(result, 0);
7138 }
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7146 PyObject *resultobj = 0;
7147 wxWindow *result = 0 ;
7148
7149 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7150 {
7151 if (!wxPyCheckForApp()) SWIG_fail;
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 result = (wxWindow *)wxGetActiveWindow();
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 {
7158 resultobj = wxPyMake_wxObject(result, 0);
7159 }
7160 return resultobj;
7161 fail:
7162 return NULL;
7163 }
7164
7165
7166 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7167 PyObject *resultobj = 0;
7168 wxPoint *arg1 = 0 ;
7169 wxWindow *result = 0 ;
7170 wxPoint temp1 ;
7171 PyObject * obj0 = 0 ;
7172 char * kwnames[] = {
7173 (char *) "pt", NULL
7174 };
7175
7176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7177 {
7178 arg1 = &temp1;
7179 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7180 }
7181 {
7182 if (!wxPyCheckForApp()) SWIG_fail;
7183 PyThreadState* __tstate = wxPyBeginAllowThreads();
7184 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7185 wxPyEndAllowThreads(__tstate);
7186 if (PyErr_Occurred()) SWIG_fail;
7187 }
7188 {
7189 resultobj = wxPyMake_wxObject(result, 0);
7190 }
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7198 PyObject *resultobj = 0;
7199 wxPoint *arg1 = 0 ;
7200 wxWindow *result = 0 ;
7201 wxPoint temp1 ;
7202 PyObject * obj0 = 0 ;
7203 char * kwnames[] = {
7204 (char *) "pt", NULL
7205 };
7206
7207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7208 {
7209 arg1 = &temp1;
7210 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7211 }
7212 {
7213 if (!wxPyCheckForApp()) SWIG_fail;
7214 PyThreadState* __tstate = wxPyBeginAllowThreads();
7215 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 {
7220 resultobj = wxPyMake_wxObject(result, 0);
7221 }
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj = 0;
7230 wxWindow *arg1 = (wxWindow *) 0 ;
7231 wxWindow *result = 0 ;
7232 void *argp1 = 0 ;
7233 int res1 = 0 ;
7234 PyObject * obj0 = 0 ;
7235 char * kwnames[] = {
7236 (char *) "win", NULL
7237 };
7238
7239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7243 }
7244 arg1 = reinterpret_cast< wxWindow * >(argp1);
7245 {
7246 if (!wxPyCheckForApp()) SWIG_fail;
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (wxWindow *)wxGetTopLevelParent(arg1);
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 {
7253 resultobj = wxPyMake_wxObject(result, 0);
7254 }
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj = 0;
7263 wxString *arg1 = 0 ;
7264 bool result;
7265 bool temp1 = false ;
7266 PyObject * obj0 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "url", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7272 {
7273 arg1 = wxString_in_helper(obj0);
7274 if (arg1 == NULL) SWIG_fail;
7275 temp1 = true;
7276 }
7277 {
7278 PyThreadState* __tstate = wxPyBeginAllowThreads();
7279 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7280 wxPyEndAllowThreads(__tstate);
7281 if (PyErr_Occurred()) SWIG_fail;
7282 }
7283 {
7284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7285 }
7286 {
7287 if (temp1)
7288 delete arg1;
7289 }
7290 return resultobj;
7291 fail:
7292 {
7293 if (temp1)
7294 delete arg1;
7295 }
7296 return NULL;
7297 }
7298
7299
7300 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj = 0;
7302 wxKeyCode arg1 ;
7303 bool result;
7304 int val1 ;
7305 int ecode1 = 0 ;
7306 PyObject * obj0 = 0 ;
7307 char * kwnames[] = {
7308 (char *) "key", NULL
7309 };
7310
7311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7312 ecode1 = SWIG_AsVal_int(obj0, &val1);
7313 if (!SWIG_IsOK(ecode1)) {
7314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7315 }
7316 arg1 = static_cast< wxKeyCode >(val1);
7317 {
7318 if (!wxPyCheckForApp()) SWIG_fail;
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (bool)wxGetKeyState(arg1);
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 {
7325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7326 }
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7334 PyObject *resultobj = 0;
7335 wxMouseState *result = 0 ;
7336
7337 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (wxMouseState *)new wxMouseState();
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7352 PyObject *resultobj = 0;
7353 wxMouseState *arg1 = (wxMouseState *) 0 ;
7354 void *argp1 = 0 ;
7355 int res1 = 0 ;
7356 PyObject *swig_obj[1] ;
7357
7358 if (!args) SWIG_fail;
7359 swig_obj[0] = args;
7360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7361 if (!SWIG_IsOK(res1)) {
7362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7363 }
7364 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7365 {
7366 PyThreadState* __tstate = wxPyBeginAllowThreads();
7367 delete arg1;
7368
7369 wxPyEndAllowThreads(__tstate);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 resultobj = SWIG_Py_Void();
7373 return resultobj;
7374 fail:
7375 return NULL;
7376 }
7377
7378
7379 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7380 PyObject *resultobj = 0;
7381 wxMouseState *arg1 = (wxMouseState *) 0 ;
7382 int result;
7383 void *argp1 = 0 ;
7384 int res1 = 0 ;
7385 PyObject *swig_obj[1] ;
7386
7387 if (!args) SWIG_fail;
7388 swig_obj[0] = args;
7389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7392 }
7393 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 result = (int)(arg1)->GetX();
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 resultobj = SWIG_From_int(static_cast< int >(result));
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7408 PyObject *resultobj = 0;
7409 wxMouseState *arg1 = (wxMouseState *) 0 ;
7410 int result;
7411 void *argp1 = 0 ;
7412 int res1 = 0 ;
7413 PyObject *swig_obj[1] ;
7414
7415 if (!args) SWIG_fail;
7416 swig_obj[0] = args;
7417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7418 if (!SWIG_IsOK(res1)) {
7419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7420 }
7421 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7422 {
7423 PyThreadState* __tstate = wxPyBeginAllowThreads();
7424 result = (int)(arg1)->GetY();
7425 wxPyEndAllowThreads(__tstate);
7426 if (PyErr_Occurred()) SWIG_fail;
7427 }
7428 resultobj = SWIG_From_int(static_cast< int >(result));
7429 return resultobj;
7430 fail:
7431 return NULL;
7432 }
7433
7434
7435 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7436 PyObject *resultobj = 0;
7437 wxMouseState *arg1 = (wxMouseState *) 0 ;
7438 bool result;
7439 void *argp1 = 0 ;
7440 int res1 = 0 ;
7441 PyObject *swig_obj[1] ;
7442
7443 if (!args) SWIG_fail;
7444 swig_obj[0] = args;
7445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7446 if (!SWIG_IsOK(res1)) {
7447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7448 }
7449 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (bool)(arg1)->LeftDown();
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7466 PyObject *resultobj = 0;
7467 wxMouseState *arg1 = (wxMouseState *) 0 ;
7468 bool result;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 PyObject *swig_obj[1] ;
7472
7473 if (!args) SWIG_fail;
7474 swig_obj[0] = args;
7475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7478 }
7479 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7480 {
7481 PyThreadState* __tstate = wxPyBeginAllowThreads();
7482 result = (bool)(arg1)->MiddleDown();
7483 wxPyEndAllowThreads(__tstate);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 {
7487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7488 }
7489 return resultobj;
7490 fail:
7491 return NULL;
7492 }
7493
7494
7495 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7496 PyObject *resultobj = 0;
7497 wxMouseState *arg1 = (wxMouseState *) 0 ;
7498 bool result;
7499 void *argp1 = 0 ;
7500 int res1 = 0 ;
7501 PyObject *swig_obj[1] ;
7502
7503 if (!args) SWIG_fail;
7504 swig_obj[0] = args;
7505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7506 if (!SWIG_IsOK(res1)) {
7507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7508 }
7509 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 result = (bool)(arg1)->RightDown();
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 {
7517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7518 }
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7526 PyObject *resultobj = 0;
7527 wxMouseState *arg1 = (wxMouseState *) 0 ;
7528 bool result;
7529 void *argp1 = 0 ;
7530 int res1 = 0 ;
7531 PyObject *swig_obj[1] ;
7532
7533 if (!args) SWIG_fail;
7534 swig_obj[0] = args;
7535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7536 if (!SWIG_IsOK(res1)) {
7537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7538 }
7539 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (bool)(arg1)->ControlDown();
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 {
7547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7548 }
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7556 PyObject *resultobj = 0;
7557 wxMouseState *arg1 = (wxMouseState *) 0 ;
7558 bool result;
7559 void *argp1 = 0 ;
7560 int res1 = 0 ;
7561 PyObject *swig_obj[1] ;
7562
7563 if (!args) SWIG_fail;
7564 swig_obj[0] = args;
7565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7566 if (!SWIG_IsOK(res1)) {
7567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7568 }
7569 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = (bool)(arg1)->ShiftDown();
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 {
7577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7578 }
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7586 PyObject *resultobj = 0;
7587 wxMouseState *arg1 = (wxMouseState *) 0 ;
7588 bool result;
7589 void *argp1 = 0 ;
7590 int res1 = 0 ;
7591 PyObject *swig_obj[1] ;
7592
7593 if (!args) SWIG_fail;
7594 swig_obj[0] = args;
7595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7596 if (!SWIG_IsOK(res1)) {
7597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7598 }
7599 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7600 {
7601 PyThreadState* __tstate = wxPyBeginAllowThreads();
7602 result = (bool)(arg1)->AltDown();
7603 wxPyEndAllowThreads(__tstate);
7604 if (PyErr_Occurred()) SWIG_fail;
7605 }
7606 {
7607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7608 }
7609 return resultobj;
7610 fail:
7611 return NULL;
7612 }
7613
7614
7615 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7616 PyObject *resultobj = 0;
7617 wxMouseState *arg1 = (wxMouseState *) 0 ;
7618 bool result;
7619 void *argp1 = 0 ;
7620 int res1 = 0 ;
7621 PyObject *swig_obj[1] ;
7622
7623 if (!args) SWIG_fail;
7624 swig_obj[0] = args;
7625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7626 if (!SWIG_IsOK(res1)) {
7627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7628 }
7629 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 result = (bool)(arg1)->MetaDown();
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 {
7637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7638 }
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7646 PyObject *resultobj = 0;
7647 wxMouseState *arg1 = (wxMouseState *) 0 ;
7648 bool result;
7649 void *argp1 = 0 ;
7650 int res1 = 0 ;
7651 PyObject *swig_obj[1] ;
7652
7653 if (!args) SWIG_fail;
7654 swig_obj[0] = args;
7655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7656 if (!SWIG_IsOK(res1)) {
7657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7658 }
7659 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (bool)(arg1)->CmdDown();
7663 wxPyEndAllowThreads(__tstate);
7664 if (PyErr_Occurred()) SWIG_fail;
7665 }
7666 {
7667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7668 }
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7676 PyObject *resultobj = 0;
7677 wxMouseState *arg1 = (wxMouseState *) 0 ;
7678 int arg2 ;
7679 void *argp1 = 0 ;
7680 int res1 = 0 ;
7681 int val2 ;
7682 int ecode2 = 0 ;
7683 PyObject * obj0 = 0 ;
7684 PyObject * obj1 = 0 ;
7685 char * kwnames[] = {
7686 (char *) "self",(char *) "x", NULL
7687 };
7688
7689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7691 if (!SWIG_IsOK(res1)) {
7692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7693 }
7694 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7695 ecode2 = SWIG_AsVal_int(obj1, &val2);
7696 if (!SWIG_IsOK(ecode2)) {
7697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7698 }
7699 arg2 = static_cast< int >(val2);
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 (arg1)->SetX(arg2);
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 resultobj = SWIG_Py_Void();
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7714 PyObject *resultobj = 0;
7715 wxMouseState *arg1 = (wxMouseState *) 0 ;
7716 int arg2 ;
7717 void *argp1 = 0 ;
7718 int res1 = 0 ;
7719 int val2 ;
7720 int ecode2 = 0 ;
7721 PyObject * obj0 = 0 ;
7722 PyObject * obj1 = 0 ;
7723 char * kwnames[] = {
7724 (char *) "self",(char *) "y", NULL
7725 };
7726
7727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7729 if (!SWIG_IsOK(res1)) {
7730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7731 }
7732 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7733 ecode2 = SWIG_AsVal_int(obj1, &val2);
7734 if (!SWIG_IsOK(ecode2)) {
7735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7736 }
7737 arg2 = static_cast< int >(val2);
7738 {
7739 PyThreadState* __tstate = wxPyBeginAllowThreads();
7740 (arg1)->SetY(arg2);
7741 wxPyEndAllowThreads(__tstate);
7742 if (PyErr_Occurred()) SWIG_fail;
7743 }
7744 resultobj = SWIG_Py_Void();
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7752 PyObject *resultobj = 0;
7753 wxMouseState *arg1 = (wxMouseState *) 0 ;
7754 bool arg2 ;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 bool val2 ;
7758 int ecode2 = 0 ;
7759 PyObject * obj0 = 0 ;
7760 PyObject * obj1 = 0 ;
7761 char * kwnames[] = {
7762 (char *) "self",(char *) "down", NULL
7763 };
7764
7765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7767 if (!SWIG_IsOK(res1)) {
7768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7769 }
7770 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7772 if (!SWIG_IsOK(ecode2)) {
7773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7774 }
7775 arg2 = static_cast< bool >(val2);
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 (arg1)->SetLeftDown(arg2);
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 resultobj = SWIG_Py_Void();
7783 return resultobj;
7784 fail:
7785 return NULL;
7786 }
7787
7788
7789 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7790 PyObject *resultobj = 0;
7791 wxMouseState *arg1 = (wxMouseState *) 0 ;
7792 bool arg2 ;
7793 void *argp1 = 0 ;
7794 int res1 = 0 ;
7795 bool val2 ;
7796 int ecode2 = 0 ;
7797 PyObject * obj0 = 0 ;
7798 PyObject * obj1 = 0 ;
7799 char * kwnames[] = {
7800 (char *) "self",(char *) "down", NULL
7801 };
7802
7803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7805 if (!SWIG_IsOK(res1)) {
7806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7807 }
7808 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7810 if (!SWIG_IsOK(ecode2)) {
7811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7812 }
7813 arg2 = static_cast< bool >(val2);
7814 {
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 (arg1)->SetMiddleDown(arg2);
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 resultobj = SWIG_Py_Void();
7821 return resultobj;
7822 fail:
7823 return NULL;
7824 }
7825
7826
7827 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7828 PyObject *resultobj = 0;
7829 wxMouseState *arg1 = (wxMouseState *) 0 ;
7830 bool arg2 ;
7831 void *argp1 = 0 ;
7832 int res1 = 0 ;
7833 bool val2 ;
7834 int ecode2 = 0 ;
7835 PyObject * obj0 = 0 ;
7836 PyObject * obj1 = 0 ;
7837 char * kwnames[] = {
7838 (char *) "self",(char *) "down", NULL
7839 };
7840
7841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7843 if (!SWIG_IsOK(res1)) {
7844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7845 }
7846 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7848 if (!SWIG_IsOK(ecode2)) {
7849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7850 }
7851 arg2 = static_cast< bool >(val2);
7852 {
7853 PyThreadState* __tstate = wxPyBeginAllowThreads();
7854 (arg1)->SetRightDown(arg2);
7855 wxPyEndAllowThreads(__tstate);
7856 if (PyErr_Occurred()) SWIG_fail;
7857 }
7858 resultobj = SWIG_Py_Void();
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7866 PyObject *resultobj = 0;
7867 wxMouseState *arg1 = (wxMouseState *) 0 ;
7868 bool arg2 ;
7869 void *argp1 = 0 ;
7870 int res1 = 0 ;
7871 bool val2 ;
7872 int ecode2 = 0 ;
7873 PyObject * obj0 = 0 ;
7874 PyObject * obj1 = 0 ;
7875 char * kwnames[] = {
7876 (char *) "self",(char *) "down", NULL
7877 };
7878
7879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7881 if (!SWIG_IsOK(res1)) {
7882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7883 }
7884 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7885 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7886 if (!SWIG_IsOK(ecode2)) {
7887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7888 }
7889 arg2 = static_cast< bool >(val2);
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 (arg1)->SetControlDown(arg2);
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 resultobj = SWIG_Py_Void();
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7904 PyObject *resultobj = 0;
7905 wxMouseState *arg1 = (wxMouseState *) 0 ;
7906 bool arg2 ;
7907 void *argp1 = 0 ;
7908 int res1 = 0 ;
7909 bool val2 ;
7910 int ecode2 = 0 ;
7911 PyObject * obj0 = 0 ;
7912 PyObject * obj1 = 0 ;
7913 char * kwnames[] = {
7914 (char *) "self",(char *) "down", NULL
7915 };
7916
7917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7919 if (!SWIG_IsOK(res1)) {
7920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7921 }
7922 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7923 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7924 if (!SWIG_IsOK(ecode2)) {
7925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7926 }
7927 arg2 = static_cast< bool >(val2);
7928 {
7929 PyThreadState* __tstate = wxPyBeginAllowThreads();
7930 (arg1)->SetShiftDown(arg2);
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 resultobj = SWIG_Py_Void();
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7942 PyObject *resultobj = 0;
7943 wxMouseState *arg1 = (wxMouseState *) 0 ;
7944 bool arg2 ;
7945 void *argp1 = 0 ;
7946 int res1 = 0 ;
7947 bool val2 ;
7948 int ecode2 = 0 ;
7949 PyObject * obj0 = 0 ;
7950 PyObject * obj1 = 0 ;
7951 char * kwnames[] = {
7952 (char *) "self",(char *) "down", NULL
7953 };
7954
7955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7957 if (!SWIG_IsOK(res1)) {
7958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7959 }
7960 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7961 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7962 if (!SWIG_IsOK(ecode2)) {
7963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7964 }
7965 arg2 = static_cast< bool >(val2);
7966 {
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 (arg1)->SetAltDown(arg2);
7969 wxPyEndAllowThreads(__tstate);
7970 if (PyErr_Occurred()) SWIG_fail;
7971 }
7972 resultobj = SWIG_Py_Void();
7973 return resultobj;
7974 fail:
7975 return NULL;
7976 }
7977
7978
7979 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7980 PyObject *resultobj = 0;
7981 wxMouseState *arg1 = (wxMouseState *) 0 ;
7982 bool arg2 ;
7983 void *argp1 = 0 ;
7984 int res1 = 0 ;
7985 bool val2 ;
7986 int ecode2 = 0 ;
7987 PyObject * obj0 = 0 ;
7988 PyObject * obj1 = 0 ;
7989 char * kwnames[] = {
7990 (char *) "self",(char *) "down", NULL
7991 };
7992
7993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7995 if (!SWIG_IsOK(res1)) {
7996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7997 }
7998 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7999 ecode2 = SWIG_AsVal_bool(obj1, &val2);
8000 if (!SWIG_IsOK(ecode2)) {
8001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8002 }
8003 arg2 = static_cast< bool >(val2);
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 (arg1)->SetMetaDown(arg2);
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 resultobj = SWIG_Py_Void();
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8018 PyObject *obj;
8019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8020 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8021 return SWIG_Py_Void();
8022 }
8023
8024 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 return SWIG_Python_InitShadowInstance(args);
8026 }
8027
8028 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8029 PyObject *resultobj = 0;
8030 wxMouseState result;
8031
8032 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = wxGetMouseState();
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8047 PyObject *resultobj = 0;
8048
8049 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8050 {
8051 if (!wxPyCheckForApp()) SWIG_fail;
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 wxWakeUpMainThread();
8054 wxPyEndAllowThreads(__tstate);
8055 if (PyErr_Occurred()) SWIG_fail;
8056 }
8057 resultobj = SWIG_Py_Void();
8058 return resultobj;
8059 fail:
8060 return NULL;
8061 }
8062
8063
8064 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8065 PyObject *resultobj = 0;
8066
8067 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8068 {
8069 if (!wxPyCheckForApp()) SWIG_fail;
8070 PyThreadState* __tstate = wxPyBeginAllowThreads();
8071 wxMutexGuiEnter();
8072 wxPyEndAllowThreads(__tstate);
8073 if (PyErr_Occurred()) SWIG_fail;
8074 }
8075 resultobj = SWIG_Py_Void();
8076 return resultobj;
8077 fail:
8078 return NULL;
8079 }
8080
8081
8082 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8083 PyObject *resultobj = 0;
8084
8085 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8086 {
8087 if (!wxPyCheckForApp()) SWIG_fail;
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 wxMutexGuiLeave();
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 resultobj = SWIG_Py_Void();
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8101 PyObject *resultobj = 0;
8102 wxMutexGuiLocker *result = 0 ;
8103
8104 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8105 {
8106 if (!wxPyCheckForApp()) SWIG_fail;
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8120 PyObject *resultobj = 0;
8121 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8122 void *argp1 = 0 ;
8123 int res1 = 0 ;
8124 PyObject *swig_obj[1] ;
8125
8126 if (!args) SWIG_fail;
8127 swig_obj[0] = args;
8128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8129 if (!SWIG_IsOK(res1)) {
8130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8131 }
8132 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 delete arg1;
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8148 PyObject *obj;
8149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8150 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8151 return SWIG_Py_Void();
8152 }
8153
8154 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8155 return SWIG_Python_InitShadowInstance(args);
8156 }
8157
8158 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8159 PyObject *resultobj = 0;
8160 bool result;
8161
8162 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (bool)wxThread_IsMain();
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 {
8170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8171 }
8172 return resultobj;
8173 fail:
8174 return NULL;
8175 }
8176
8177
8178 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8179 PyObject *resultobj = 0;
8180 wxString *arg1 = 0 ;
8181 wxToolTip *result = 0 ;
8182 bool temp1 = false ;
8183 PyObject * obj0 = 0 ;
8184 char * kwnames[] = {
8185 (char *) "tip", NULL
8186 };
8187
8188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8189 {
8190 arg1 = wxString_in_helper(obj0);
8191 if (arg1 == NULL) SWIG_fail;
8192 temp1 = true;
8193 }
8194 {
8195 if (!wxPyCheckForApp()) SWIG_fail;
8196 PyThreadState* __tstate = wxPyBeginAllowThreads();
8197 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8202 {
8203 if (temp1)
8204 delete arg1;
8205 }
8206 return resultobj;
8207 fail:
8208 {
8209 if (temp1)
8210 delete arg1;
8211 }
8212 return NULL;
8213 }
8214
8215
8216 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8217 PyObject *resultobj = 0;
8218 wxToolTip *arg1 = (wxToolTip *) 0 ;
8219 void *argp1 = 0 ;
8220 int res1 = 0 ;
8221 PyObject *swig_obj[1] ;
8222
8223 if (!args) SWIG_fail;
8224 swig_obj[0] = args;
8225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8226 if (!SWIG_IsOK(res1)) {
8227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8228 }
8229 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 delete arg1;
8233
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = SWIG_Py_Void();
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj = 0;
8246 wxToolTip *arg1 = (wxToolTip *) 0 ;
8247 wxString *arg2 = 0 ;
8248 void *argp1 = 0 ;
8249 int res1 = 0 ;
8250 bool temp2 = false ;
8251 PyObject * obj0 = 0 ;
8252 PyObject * obj1 = 0 ;
8253 char * kwnames[] = {
8254 (char *) "self",(char *) "tip", NULL
8255 };
8256
8257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8259 if (!SWIG_IsOK(res1)) {
8260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8261 }
8262 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8263 {
8264 arg2 = wxString_in_helper(obj1);
8265 if (arg2 == NULL) SWIG_fail;
8266 temp2 = true;
8267 }
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 (arg1)->SetTip((wxString const &)*arg2);
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = SWIG_Py_Void();
8275 {
8276 if (temp2)
8277 delete arg2;
8278 }
8279 return resultobj;
8280 fail:
8281 {
8282 if (temp2)
8283 delete arg2;
8284 }
8285 return NULL;
8286 }
8287
8288
8289 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8290 PyObject *resultobj = 0;
8291 wxToolTip *arg1 = (wxToolTip *) 0 ;
8292 wxString result;
8293 void *argp1 = 0 ;
8294 int res1 = 0 ;
8295 PyObject *swig_obj[1] ;
8296
8297 if (!args) SWIG_fail;
8298 swig_obj[0] = args;
8299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8300 if (!SWIG_IsOK(res1)) {
8301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8302 }
8303 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8304 {
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (arg1)->GetTip();
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 {
8311 #if wxUSE_UNICODE
8312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8313 #else
8314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8315 #endif
8316 }
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8324 PyObject *resultobj = 0;
8325 wxToolTip *arg1 = (wxToolTip *) 0 ;
8326 wxWindow *result = 0 ;
8327 void *argp1 = 0 ;
8328 int res1 = 0 ;
8329 PyObject *swig_obj[1] ;
8330
8331 if (!args) SWIG_fail;
8332 swig_obj[0] = args;
8333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8334 if (!SWIG_IsOK(res1)) {
8335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8336 }
8337 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8338 {
8339 PyThreadState* __tstate = wxPyBeginAllowThreads();
8340 result = (wxWindow *)(arg1)->GetWindow();
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 {
8345 resultobj = wxPyMake_wxObject(result, 0);
8346 }
8347 return resultobj;
8348 fail:
8349 return NULL;
8350 }
8351
8352
8353 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8354 PyObject *resultobj = 0;
8355 bool arg1 ;
8356 bool val1 ;
8357 int ecode1 = 0 ;
8358 PyObject * obj0 = 0 ;
8359 char * kwnames[] = {
8360 (char *) "flag", NULL
8361 };
8362
8363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8364 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8365 if (!SWIG_IsOK(ecode1)) {
8366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8367 }
8368 arg1 = static_cast< bool >(val1);
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 wxToolTip::Enable(arg1);
8372 wxPyEndAllowThreads(__tstate);
8373 if (PyErr_Occurred()) SWIG_fail;
8374 }
8375 resultobj = SWIG_Py_Void();
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj = 0;
8384 long arg1 ;
8385 long val1 ;
8386 int ecode1 = 0 ;
8387 PyObject * obj0 = 0 ;
8388 char * kwnames[] = {
8389 (char *) "milliseconds", NULL
8390 };
8391
8392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8393 ecode1 = SWIG_AsVal_long(obj0, &val1);
8394 if (!SWIG_IsOK(ecode1)) {
8395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8396 }
8397 arg1 = static_cast< long >(val1);
8398 {
8399 PyThreadState* __tstate = wxPyBeginAllowThreads();
8400 wxToolTip::SetDelay(arg1);
8401 wxPyEndAllowThreads(__tstate);
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 resultobj = SWIG_Py_Void();
8405 return resultobj;
8406 fail:
8407 return NULL;
8408 }
8409
8410
8411 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8412 PyObject *obj;
8413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8414 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8415 return SWIG_Py_Void();
8416 }
8417
8418 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8419 return SWIG_Python_InitShadowInstance(args);
8420 }
8421
8422 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8423 PyObject *resultobj = 0;
8424 wxWindow *arg1 = (wxWindow *) 0 ;
8425 wxSize *arg2 = 0 ;
8426 wxCaret *result = 0 ;
8427 void *argp1 = 0 ;
8428 int res1 = 0 ;
8429 wxSize temp2 ;
8430 PyObject * obj0 = 0 ;
8431 PyObject * obj1 = 0 ;
8432 char * kwnames[] = {
8433 (char *) "window",(char *) "size", NULL
8434 };
8435
8436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8438 if (!SWIG_IsOK(res1)) {
8439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8440 }
8441 arg1 = reinterpret_cast< wxWindow * >(argp1);
8442 {
8443 arg2 = &temp2;
8444 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8445 }
8446 {
8447 if (!wxPyCheckForApp()) SWIG_fail;
8448 PyThreadState* __tstate = wxPyBeginAllowThreads();
8449 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8454 return resultobj;
8455 fail:
8456 return NULL;
8457 }
8458
8459
8460 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8461 PyObject *resultobj = 0;
8462 wxCaret *arg1 = (wxCaret *) 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 PyObject *swig_obj[1] ;
8466
8467 if (!args) SWIG_fail;
8468 swig_obj[0] = args;
8469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8470 if (!SWIG_IsOK(res1)) {
8471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8472 }
8473 arg1 = reinterpret_cast< wxCaret * >(argp1);
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 delete arg1;
8477
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 resultobj = SWIG_Py_Void();
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8489 PyObject *resultobj = 0;
8490 wxCaret *arg1 = (wxCaret *) 0 ;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 PyObject *swig_obj[1] ;
8494
8495 if (!args) SWIG_fail;
8496 swig_obj[0] = args;
8497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8500 }
8501 arg1 = reinterpret_cast< wxCaret * >(argp1);
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 wxCaret_Destroy(arg1);
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 resultobj = SWIG_Py_Void();
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8516 PyObject *resultobj = 0;
8517 wxCaret *arg1 = (wxCaret *) 0 ;
8518 bool result;
8519 void *argp1 = 0 ;
8520 int res1 = 0 ;
8521 PyObject *swig_obj[1] ;
8522
8523 if (!args) SWIG_fail;
8524 swig_obj[0] = args;
8525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8526 if (!SWIG_IsOK(res1)) {
8527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8528 }
8529 arg1 = reinterpret_cast< wxCaret * >(argp1);
8530 {
8531 PyThreadState* __tstate = wxPyBeginAllowThreads();
8532 result = (bool)(arg1)->IsOk();
8533 wxPyEndAllowThreads(__tstate);
8534 if (PyErr_Occurred()) SWIG_fail;
8535 }
8536 {
8537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8538 }
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxCaret *arg1 = (wxCaret *) 0 ;
8548 bool result;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 PyObject *swig_obj[1] ;
8552
8553 if (!args) SWIG_fail;
8554 swig_obj[0] = args;
8555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8558 }
8559 arg1 = reinterpret_cast< wxCaret * >(argp1);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (bool)(arg1)->IsVisible();
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 {
8567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8568 }
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8576 PyObject *resultobj = 0;
8577 wxCaret *arg1 = (wxCaret *) 0 ;
8578 wxPoint result;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 PyObject *swig_obj[1] ;
8582
8583 if (!args) SWIG_fail;
8584 swig_obj[0] = args;
8585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8586 if (!SWIG_IsOK(res1)) {
8587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8588 }
8589 arg1 = reinterpret_cast< wxCaret * >(argp1);
8590 {
8591 PyThreadState* __tstate = wxPyBeginAllowThreads();
8592 result = (arg1)->GetPosition();
8593 wxPyEndAllowThreads(__tstate);
8594 if (PyErr_Occurred()) SWIG_fail;
8595 }
8596 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8597 return resultobj;
8598 fail:
8599 return NULL;
8600 }
8601
8602
8603 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8604 PyObject *resultobj = 0;
8605 wxCaret *arg1 = (wxCaret *) 0 ;
8606 int *arg2 = (int *) 0 ;
8607 int *arg3 = (int *) 0 ;
8608 void *argp1 = 0 ;
8609 int res1 = 0 ;
8610 int temp2 ;
8611 int res2 = SWIG_TMPOBJ ;
8612 int temp3 ;
8613 int res3 = SWIG_TMPOBJ ;
8614 PyObject *swig_obj[1] ;
8615
8616 arg2 = &temp2;
8617 arg3 = &temp3;
8618 if (!args) SWIG_fail;
8619 swig_obj[0] = args;
8620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8621 if (!SWIG_IsOK(res1)) {
8622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8623 }
8624 arg1 = reinterpret_cast< wxCaret * >(argp1);
8625 {
8626 PyThreadState* __tstate = wxPyBeginAllowThreads();
8627 (arg1)->GetPosition(arg2,arg3);
8628 wxPyEndAllowThreads(__tstate);
8629 if (PyErr_Occurred()) SWIG_fail;
8630 }
8631 resultobj = SWIG_Py_Void();
8632 if (SWIG_IsTmpObj(res2)) {
8633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8634 } else {
8635 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8637 }
8638 if (SWIG_IsTmpObj(res3)) {
8639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8640 } else {
8641 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8643 }
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8651 PyObject *resultobj = 0;
8652 wxCaret *arg1 = (wxCaret *) 0 ;
8653 wxSize result;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 PyObject *swig_obj[1] ;
8657
8658 if (!args) SWIG_fail;
8659 swig_obj[0] = args;
8660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8661 if (!SWIG_IsOK(res1)) {
8662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8663 }
8664 arg1 = reinterpret_cast< wxCaret * >(argp1);
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 result = (arg1)->GetSize();
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8679 PyObject *resultobj = 0;
8680 wxCaret *arg1 = (wxCaret *) 0 ;
8681 int *arg2 = (int *) 0 ;
8682 int *arg3 = (int *) 0 ;
8683 void *argp1 = 0 ;
8684 int res1 = 0 ;
8685 int temp2 ;
8686 int res2 = SWIG_TMPOBJ ;
8687 int temp3 ;
8688 int res3 = SWIG_TMPOBJ ;
8689 PyObject *swig_obj[1] ;
8690
8691 arg2 = &temp2;
8692 arg3 = &temp3;
8693 if (!args) SWIG_fail;
8694 swig_obj[0] = args;
8695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8696 if (!SWIG_IsOK(res1)) {
8697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8698 }
8699 arg1 = reinterpret_cast< wxCaret * >(argp1);
8700 {
8701 PyThreadState* __tstate = wxPyBeginAllowThreads();
8702 (arg1)->GetSize(arg2,arg3);
8703 wxPyEndAllowThreads(__tstate);
8704 if (PyErr_Occurred()) SWIG_fail;
8705 }
8706 resultobj = SWIG_Py_Void();
8707 if (SWIG_IsTmpObj(res2)) {
8708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8709 } else {
8710 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8712 }
8713 if (SWIG_IsTmpObj(res3)) {
8714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8715 } else {
8716 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8718 }
8719 return resultobj;
8720 fail:
8721 return NULL;
8722 }
8723
8724
8725 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8726 PyObject *resultobj = 0;
8727 wxCaret *arg1 = (wxCaret *) 0 ;
8728 wxWindow *result = 0 ;
8729 void *argp1 = 0 ;
8730 int res1 = 0 ;
8731 PyObject *swig_obj[1] ;
8732
8733 if (!args) SWIG_fail;
8734 swig_obj[0] = args;
8735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8736 if (!SWIG_IsOK(res1)) {
8737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8738 }
8739 arg1 = reinterpret_cast< wxCaret * >(argp1);
8740 {
8741 PyThreadState* __tstate = wxPyBeginAllowThreads();
8742 result = (wxWindow *)(arg1)->GetWindow();
8743 wxPyEndAllowThreads(__tstate);
8744 if (PyErr_Occurred()) SWIG_fail;
8745 }
8746 {
8747 resultobj = wxPyMake_wxObject(result, 0);
8748 }
8749 return resultobj;
8750 fail:
8751 return NULL;
8752 }
8753
8754
8755 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8756 PyObject *resultobj = 0;
8757 wxCaret *arg1 = (wxCaret *) 0 ;
8758 int arg2 ;
8759 int arg3 ;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 int val2 ;
8763 int ecode2 = 0 ;
8764 int val3 ;
8765 int ecode3 = 0 ;
8766 PyObject * obj0 = 0 ;
8767 PyObject * obj1 = 0 ;
8768 PyObject * obj2 = 0 ;
8769 char * kwnames[] = {
8770 (char *) "self",(char *) "x",(char *) "y", NULL
8771 };
8772
8773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8775 if (!SWIG_IsOK(res1)) {
8776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8777 }
8778 arg1 = reinterpret_cast< wxCaret * >(argp1);
8779 ecode2 = SWIG_AsVal_int(obj1, &val2);
8780 if (!SWIG_IsOK(ecode2)) {
8781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8782 }
8783 arg2 = static_cast< int >(val2);
8784 ecode3 = SWIG_AsVal_int(obj2, &val3);
8785 if (!SWIG_IsOK(ecode3)) {
8786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8787 }
8788 arg3 = static_cast< int >(val3);
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 (arg1)->Move(arg2,arg3);
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 resultobj = SWIG_Py_Void();
8796 return resultobj;
8797 fail:
8798 return NULL;
8799 }
8800
8801
8802 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8803 PyObject *resultobj = 0;
8804 wxCaret *arg1 = (wxCaret *) 0 ;
8805 wxPoint *arg2 = 0 ;
8806 void *argp1 = 0 ;
8807 int res1 = 0 ;
8808 wxPoint temp2 ;
8809 PyObject * obj0 = 0 ;
8810 PyObject * obj1 = 0 ;
8811 char * kwnames[] = {
8812 (char *) "self",(char *) "pt", NULL
8813 };
8814
8815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) 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_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8819 }
8820 arg1 = reinterpret_cast< wxCaret * >(argp1);
8821 {
8822 arg2 = &temp2;
8823 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8824 }
8825 {
8826 PyThreadState* __tstate = wxPyBeginAllowThreads();
8827 (arg1)->Move((wxPoint const &)*arg2);
8828 wxPyEndAllowThreads(__tstate);
8829 if (PyErr_Occurred()) SWIG_fail;
8830 }
8831 resultobj = SWIG_Py_Void();
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj = 0;
8840 wxCaret *arg1 = (wxCaret *) 0 ;
8841 int arg2 ;
8842 int arg3 ;
8843 void *argp1 = 0 ;
8844 int res1 = 0 ;
8845 int val2 ;
8846 int ecode2 = 0 ;
8847 int val3 ;
8848 int ecode3 = 0 ;
8849 PyObject * obj0 = 0 ;
8850 PyObject * obj1 = 0 ;
8851 PyObject * obj2 = 0 ;
8852 char * kwnames[] = {
8853 (char *) "self",(char *) "width",(char *) "height", NULL
8854 };
8855
8856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8858 if (!SWIG_IsOK(res1)) {
8859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8860 }
8861 arg1 = reinterpret_cast< wxCaret * >(argp1);
8862 ecode2 = SWIG_AsVal_int(obj1, &val2);
8863 if (!SWIG_IsOK(ecode2)) {
8864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8865 }
8866 arg2 = static_cast< int >(val2);
8867 ecode3 = SWIG_AsVal_int(obj2, &val3);
8868 if (!SWIG_IsOK(ecode3)) {
8869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8870 }
8871 arg3 = static_cast< int >(val3);
8872 {
8873 PyThreadState* __tstate = wxPyBeginAllowThreads();
8874 (arg1)->SetSize(arg2,arg3);
8875 wxPyEndAllowThreads(__tstate);
8876 if (PyErr_Occurred()) SWIG_fail;
8877 }
8878 resultobj = SWIG_Py_Void();
8879 return resultobj;
8880 fail:
8881 return NULL;
8882 }
8883
8884
8885 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8886 PyObject *resultobj = 0;
8887 wxCaret *arg1 = (wxCaret *) 0 ;
8888 wxSize *arg2 = 0 ;
8889 void *argp1 = 0 ;
8890 int res1 = 0 ;
8891 wxSize temp2 ;
8892 PyObject * obj0 = 0 ;
8893 PyObject * obj1 = 0 ;
8894 char * kwnames[] = {
8895 (char *) "self",(char *) "size", NULL
8896 };
8897
8898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8900 if (!SWIG_IsOK(res1)) {
8901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8902 }
8903 arg1 = reinterpret_cast< wxCaret * >(argp1);
8904 {
8905 arg2 = &temp2;
8906 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8907 }
8908 {
8909 PyThreadState* __tstate = wxPyBeginAllowThreads();
8910 (arg1)->SetSize((wxSize const &)*arg2);
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 resultobj = SWIG_Py_Void();
8915 return resultobj;
8916 fail:
8917 return NULL;
8918 }
8919
8920
8921 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8922 PyObject *resultobj = 0;
8923 wxCaret *arg1 = (wxCaret *) 0 ;
8924 int arg2 = (int) true ;
8925 void *argp1 = 0 ;
8926 int res1 = 0 ;
8927 int val2 ;
8928 int ecode2 = 0 ;
8929 PyObject * obj0 = 0 ;
8930 PyObject * obj1 = 0 ;
8931 char * kwnames[] = {
8932 (char *) "self",(char *) "show", NULL
8933 };
8934
8935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8937 if (!SWIG_IsOK(res1)) {
8938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8939 }
8940 arg1 = reinterpret_cast< wxCaret * >(argp1);
8941 if (obj1) {
8942 ecode2 = SWIG_AsVal_int(obj1, &val2);
8943 if (!SWIG_IsOK(ecode2)) {
8944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8945 }
8946 arg2 = static_cast< int >(val2);
8947 }
8948 {
8949 PyThreadState* __tstate = wxPyBeginAllowThreads();
8950 (arg1)->Show(arg2);
8951 wxPyEndAllowThreads(__tstate);
8952 if (PyErr_Occurred()) SWIG_fail;
8953 }
8954 resultobj = SWIG_Py_Void();
8955 return resultobj;
8956 fail:
8957 return NULL;
8958 }
8959
8960
8961 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8962 PyObject *resultobj = 0;
8963 wxCaret *arg1 = (wxCaret *) 0 ;
8964 void *argp1 = 0 ;
8965 int res1 = 0 ;
8966 PyObject *swig_obj[1] ;
8967
8968 if (!args) SWIG_fail;
8969 swig_obj[0] = args;
8970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8971 if (!SWIG_IsOK(res1)) {
8972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8973 }
8974 arg1 = reinterpret_cast< wxCaret * >(argp1);
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 (arg1)->Hide();
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 resultobj = SWIG_Py_Void();
8982 return resultobj;
8983 fail:
8984 return NULL;
8985 }
8986
8987
8988 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8989 PyObject *resultobj = 0;
8990 int result;
8991
8992 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8993 {
8994 PyThreadState* __tstate = wxPyBeginAllowThreads();
8995 result = (int)wxCaret::GetBlinkTime();
8996 wxPyEndAllowThreads(__tstate);
8997 if (PyErr_Occurred()) SWIG_fail;
8998 }
8999 resultobj = SWIG_From_int(static_cast< int >(result));
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj = 0;
9008 int arg1 ;
9009 int val1 ;
9010 int ecode1 = 0 ;
9011 PyObject * obj0 = 0 ;
9012 char * kwnames[] = {
9013 (char *) "milliseconds", NULL
9014 };
9015
9016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9017 ecode1 = SWIG_AsVal_int(obj0, &val1);
9018 if (!SWIG_IsOK(ecode1)) {
9019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9020 }
9021 arg1 = static_cast< int >(val1);
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 wxCaret::SetBlinkTime(arg1);
9025 wxPyEndAllowThreads(__tstate);
9026 if (PyErr_Occurred()) SWIG_fail;
9027 }
9028 resultobj = SWIG_Py_Void();
9029 return resultobj;
9030 fail:
9031 return NULL;
9032 }
9033
9034
9035 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9036 PyObject *obj;
9037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9038 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9039 return SWIG_Py_Void();
9040 }
9041
9042 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9043 return SWIG_Python_InitShadowInstance(args);
9044 }
9045
9046 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj = 0;
9048 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9049 wxBusyCursor *result = 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 PyObject * obj0 = 0 ;
9053 char * kwnames[] = {
9054 (char *) "cursor", NULL
9055 };
9056
9057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9058 if (obj0) {
9059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9060 if (!SWIG_IsOK(res1)) {
9061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9062 }
9063 arg1 = reinterpret_cast< wxCursor * >(argp1);
9064 }
9065 {
9066 if (!wxPyCheckForApp()) SWIG_fail;
9067 PyThreadState* __tstate = wxPyBeginAllowThreads();
9068 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9080 PyObject *resultobj = 0;
9081 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9082 void *argp1 = 0 ;
9083 int res1 = 0 ;
9084 PyObject *swig_obj[1] ;
9085
9086 if (!args) SWIG_fail;
9087 swig_obj[0] = args;
9088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9089 if (!SWIG_IsOK(res1)) {
9090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9091 }
9092 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9093 {
9094 PyThreadState* __tstate = wxPyBeginAllowThreads();
9095 delete arg1;
9096
9097 wxPyEndAllowThreads(__tstate);
9098 if (PyErr_Occurred()) SWIG_fail;
9099 }
9100 resultobj = SWIG_Py_Void();
9101 return resultobj;
9102 fail:
9103 return NULL;
9104 }
9105
9106
9107 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9108 PyObject *obj;
9109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9110 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9111 return SWIG_Py_Void();
9112 }
9113
9114 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 return SWIG_Python_InitShadowInstance(args);
9116 }
9117
9118 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9119 PyObject *resultobj = 0;
9120 wxWindow *arg1 = (wxWindow *) NULL ;
9121 wxWindowDisabler *result = 0 ;
9122 void *argp1 = 0 ;
9123 int res1 = 0 ;
9124 PyObject * obj0 = 0 ;
9125 char * kwnames[] = {
9126 (char *) "winToSkip", NULL
9127 };
9128
9129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9130 if (obj0) {
9131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9132 if (!SWIG_IsOK(res1)) {
9133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9134 }
9135 arg1 = reinterpret_cast< wxWindow * >(argp1);
9136 }
9137 {
9138 if (!wxPyCheckForApp()) SWIG_fail;
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9141 wxPyEndAllowThreads(__tstate);
9142 if (PyErr_Occurred()) SWIG_fail;
9143 }
9144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9145 return resultobj;
9146 fail:
9147 return NULL;
9148 }
9149
9150
9151 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9152 PyObject *resultobj = 0;
9153 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9154 void *argp1 = 0 ;
9155 int res1 = 0 ;
9156 PyObject *swig_obj[1] ;
9157
9158 if (!args) SWIG_fail;
9159 swig_obj[0] = args;
9160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9161 if (!SWIG_IsOK(res1)) {
9162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9163 }
9164 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9165 {
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 delete arg1;
9168
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_Py_Void();
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9180 PyObject *obj;
9181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9182 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9183 return SWIG_Py_Void();
9184 }
9185
9186 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9187 return SWIG_Python_InitShadowInstance(args);
9188 }
9189
9190 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9191 PyObject *resultobj = 0;
9192 wxString *arg1 = 0 ;
9193 wxWindow *arg2 = (wxWindow *) NULL ;
9194 wxBusyInfo *result = 0 ;
9195 bool temp1 = false ;
9196 void *argp2 = 0 ;
9197 int res2 = 0 ;
9198 PyObject * obj0 = 0 ;
9199 PyObject * obj1 = 0 ;
9200 char * kwnames[] = {
9201 (char *) "message",(char *) "parent", NULL
9202 };
9203
9204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9205 {
9206 arg1 = wxString_in_helper(obj0);
9207 if (arg1 == NULL) SWIG_fail;
9208 temp1 = true;
9209 }
9210 if (obj1) {
9211 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9212 if (!SWIG_IsOK(res2)) {
9213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9214 }
9215 arg2 = reinterpret_cast< wxWindow * >(argp2);
9216 }
9217 {
9218 if (!wxPyCheckForApp()) SWIG_fail;
9219 PyThreadState* __tstate = wxPyBeginAllowThreads();
9220 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9221 wxPyEndAllowThreads(__tstate);
9222 if (PyErr_Occurred()) SWIG_fail;
9223 }
9224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9225 {
9226 if (temp1)
9227 delete arg1;
9228 }
9229 return resultobj;
9230 fail:
9231 {
9232 if (temp1)
9233 delete arg1;
9234 }
9235 return NULL;
9236 }
9237
9238
9239 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9240 PyObject *resultobj = 0;
9241 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9242 void *argp1 = 0 ;
9243 int res1 = 0 ;
9244 PyObject *swig_obj[1] ;
9245
9246 if (!args) SWIG_fail;
9247 swig_obj[0] = args;
9248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9249 if (!SWIG_IsOK(res1)) {
9250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9251 }
9252 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 delete arg1;
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 resultobj = SWIG_Py_Void();
9261 return resultobj;
9262 fail:
9263 return NULL;
9264 }
9265
9266
9267 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9268 PyObject *obj;
9269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9270 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9271 return SWIG_Py_Void();
9272 }
9273
9274 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 return SWIG_Python_InitShadowInstance(args);
9276 }
9277
9278 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279 PyObject *resultobj = 0;
9280 wxStopWatch *result = 0 ;
9281
9282 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 result = (wxStopWatch *)new wxStopWatch();
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9297 PyObject *resultobj = 0;
9298 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9299 void *argp1 = 0 ;
9300 int res1 = 0 ;
9301 PyObject *swig_obj[1] ;
9302
9303 if (!args) SWIG_fail;
9304 swig_obj[0] = args;
9305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9306 if (!SWIG_IsOK(res1)) {
9307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9308 }
9309 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9310 {
9311 PyThreadState* __tstate = wxPyBeginAllowThreads();
9312 delete arg1;
9313
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_Py_Void();
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9325 PyObject *resultobj = 0;
9326 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9327 long arg2 = (long) 0 ;
9328 void *argp1 = 0 ;
9329 int res1 = 0 ;
9330 long val2 ;
9331 int ecode2 = 0 ;
9332 PyObject * obj0 = 0 ;
9333 PyObject * obj1 = 0 ;
9334 char * kwnames[] = {
9335 (char *) "self",(char *) "t0", NULL
9336 };
9337
9338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9340 if (!SWIG_IsOK(res1)) {
9341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9342 }
9343 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9344 if (obj1) {
9345 ecode2 = SWIG_AsVal_long(obj1, &val2);
9346 if (!SWIG_IsOK(ecode2)) {
9347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9348 }
9349 arg2 = static_cast< long >(val2);
9350 }
9351 {
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 (arg1)->Start(arg2);
9354 wxPyEndAllowThreads(__tstate);
9355 if (PyErr_Occurred()) SWIG_fail;
9356 }
9357 resultobj = SWIG_Py_Void();
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9365 PyObject *resultobj = 0;
9366 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 PyObject *swig_obj[1] ;
9370
9371 if (!args) SWIG_fail;
9372 swig_obj[0] = args;
9373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9374 if (!SWIG_IsOK(res1)) {
9375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9376 }
9377 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9378 {
9379 PyThreadState* __tstate = wxPyBeginAllowThreads();
9380 (arg1)->Pause();
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 resultobj = SWIG_Py_Void();
9385 return resultobj;
9386 fail:
9387 return NULL;
9388 }
9389
9390
9391 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9392 PyObject *resultobj = 0;
9393 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9394 void *argp1 = 0 ;
9395 int res1 = 0 ;
9396 PyObject *swig_obj[1] ;
9397
9398 if (!args) SWIG_fail;
9399 swig_obj[0] = args;
9400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9401 if (!SWIG_IsOK(res1)) {
9402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9403 }
9404 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9405 {
9406 PyThreadState* __tstate = wxPyBeginAllowThreads();
9407 (arg1)->Resume();
9408 wxPyEndAllowThreads(__tstate);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 resultobj = SWIG_Py_Void();
9412 return resultobj;
9413 fail:
9414 return NULL;
9415 }
9416
9417
9418 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9419 PyObject *resultobj = 0;
9420 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9421 long result;
9422 void *argp1 = 0 ;
9423 int res1 = 0 ;
9424 PyObject *swig_obj[1] ;
9425
9426 if (!args) SWIG_fail;
9427 swig_obj[0] = args;
9428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9429 if (!SWIG_IsOK(res1)) {
9430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9431 }
9432 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9433 {
9434 PyThreadState* __tstate = wxPyBeginAllowThreads();
9435 result = (long)((wxStopWatch const *)arg1)->Time();
9436 wxPyEndAllowThreads(__tstate);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 resultobj = SWIG_From_long(static_cast< long >(result));
9440 return resultobj;
9441 fail:
9442 return NULL;
9443 }
9444
9445
9446 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9447 PyObject *obj;
9448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9449 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9450 return SWIG_Py_Void();
9451 }
9452
9453 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9454 return SWIG_Python_InitShadowInstance(args);
9455 }
9456
9457 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9458 PyObject *resultobj = 0;
9459 int arg1 = (int) 9 ;
9460 int arg2 = (int) wxID_FILE1 ;
9461 wxFileHistory *result = 0 ;
9462 int val1 ;
9463 int ecode1 = 0 ;
9464 int val2 ;
9465 int ecode2 = 0 ;
9466 PyObject * obj0 = 0 ;
9467 PyObject * obj1 = 0 ;
9468 char * kwnames[] = {
9469 (char *) "maxFiles",(char *) "idBase", NULL
9470 };
9471
9472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9473 if (obj0) {
9474 ecode1 = SWIG_AsVal_int(obj0, &val1);
9475 if (!SWIG_IsOK(ecode1)) {
9476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9477 }
9478 arg1 = static_cast< int >(val1);
9479 }
9480 if (obj1) {
9481 ecode2 = SWIG_AsVal_int(obj1, &val2);
9482 if (!SWIG_IsOK(ecode2)) {
9483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9484 }
9485 arg2 = static_cast< int >(val2);
9486 }
9487 {
9488 PyThreadState* __tstate = wxPyBeginAllowThreads();
9489 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9490 wxPyEndAllowThreads(__tstate);
9491 if (PyErr_Occurred()) SWIG_fail;
9492 }
9493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9494 return resultobj;
9495 fail:
9496 return NULL;
9497 }
9498
9499
9500 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9501 PyObject *resultobj = 0;
9502 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9503 void *argp1 = 0 ;
9504 int res1 = 0 ;
9505 PyObject *swig_obj[1] ;
9506
9507 if (!args) SWIG_fail;
9508 swig_obj[0] = args;
9509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9510 if (!SWIG_IsOK(res1)) {
9511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9512 }
9513 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 delete arg1;
9517
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 resultobj = SWIG_Py_Void();
9522 return resultobj;
9523 fail:
9524 return NULL;
9525 }
9526
9527
9528 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9529 PyObject *resultobj = 0;
9530 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9531 wxString *arg2 = 0 ;
9532 void *argp1 = 0 ;
9533 int res1 = 0 ;
9534 bool temp2 = false ;
9535 PyObject * obj0 = 0 ;
9536 PyObject * obj1 = 0 ;
9537 char * kwnames[] = {
9538 (char *) "self",(char *) "file", NULL
9539 };
9540
9541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9543 if (!SWIG_IsOK(res1)) {
9544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9545 }
9546 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9547 {
9548 arg2 = wxString_in_helper(obj1);
9549 if (arg2 == NULL) SWIG_fail;
9550 temp2 = true;
9551 }
9552 {
9553 PyThreadState* __tstate = wxPyBeginAllowThreads();
9554 (arg1)->AddFileToHistory((wxString const &)*arg2);
9555 wxPyEndAllowThreads(__tstate);
9556 if (PyErr_Occurred()) SWIG_fail;
9557 }
9558 resultobj = SWIG_Py_Void();
9559 {
9560 if (temp2)
9561 delete arg2;
9562 }
9563 return resultobj;
9564 fail:
9565 {
9566 if (temp2)
9567 delete arg2;
9568 }
9569 return NULL;
9570 }
9571
9572
9573 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9574 PyObject *resultobj = 0;
9575 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9576 int arg2 ;
9577 void *argp1 = 0 ;
9578 int res1 = 0 ;
9579 int val2 ;
9580 int ecode2 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 char * kwnames[] = {
9584 (char *) "self",(char *) "i", NULL
9585 };
9586
9587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9589 if (!SWIG_IsOK(res1)) {
9590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9591 }
9592 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9593 ecode2 = SWIG_AsVal_int(obj1, &val2);
9594 if (!SWIG_IsOK(ecode2)) {
9595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9596 }
9597 arg2 = static_cast< int >(val2);
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 (arg1)->RemoveFileFromHistory(arg2);
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_Py_Void();
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612 PyObject *resultobj = 0;
9613 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9614 int result;
9615 void *argp1 = 0 ;
9616 int res1 = 0 ;
9617 PyObject *swig_obj[1] ;
9618
9619 if (!args) SWIG_fail;
9620 swig_obj[0] = args;
9621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9622 if (!SWIG_IsOK(res1)) {
9623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9624 }
9625 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9626 {
9627 PyThreadState* __tstate = wxPyBeginAllowThreads();
9628 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 resultobj = SWIG_From_int(static_cast< int >(result));
9633 return resultobj;
9634 fail:
9635 return NULL;
9636 }
9637
9638
9639 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9640 PyObject *resultobj = 0;
9641 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9642 wxMenu *arg2 = (wxMenu *) 0 ;
9643 void *argp1 = 0 ;
9644 int res1 = 0 ;
9645 void *argp2 = 0 ;
9646 int res2 = 0 ;
9647 PyObject * obj0 = 0 ;
9648 PyObject * obj1 = 0 ;
9649 char * kwnames[] = {
9650 (char *) "self",(char *) "menu", NULL
9651 };
9652
9653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9655 if (!SWIG_IsOK(res1)) {
9656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9657 }
9658 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9660 if (!SWIG_IsOK(res2)) {
9661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9662 }
9663 arg2 = reinterpret_cast< wxMenu * >(argp2);
9664 {
9665 PyThreadState* __tstate = wxPyBeginAllowThreads();
9666 (arg1)->UseMenu(arg2);
9667 wxPyEndAllowThreads(__tstate);
9668 if (PyErr_Occurred()) SWIG_fail;
9669 }
9670 resultobj = SWIG_Py_Void();
9671 return resultobj;
9672 fail:
9673 return NULL;
9674 }
9675
9676
9677 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9678 PyObject *resultobj = 0;
9679 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9680 wxMenu *arg2 = (wxMenu *) 0 ;
9681 void *argp1 = 0 ;
9682 int res1 = 0 ;
9683 void *argp2 = 0 ;
9684 int res2 = 0 ;
9685 PyObject * obj0 = 0 ;
9686 PyObject * obj1 = 0 ;
9687 char * kwnames[] = {
9688 (char *) "self",(char *) "menu", NULL
9689 };
9690
9691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9693 if (!SWIG_IsOK(res1)) {
9694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9695 }
9696 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9698 if (!SWIG_IsOK(res2)) {
9699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9700 }
9701 arg2 = reinterpret_cast< wxMenu * >(argp2);
9702 {
9703 PyThreadState* __tstate = wxPyBeginAllowThreads();
9704 (arg1)->RemoveMenu(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_Load(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_Load",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_Load" "', 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_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9738 }
9739 if (!argp2) {
9740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9741 }
9742 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9743 {
9744 PyThreadState* __tstate = wxPyBeginAllowThreads();
9745 (arg1)->Load(*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_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9757 PyObject *resultobj = 0;
9758 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9759 wxConfigBase *arg2 = 0 ;
9760 void *argp1 = 0 ;
9761 int res1 = 0 ;
9762 void *argp2 = 0 ;
9763 int res2 = 0 ;
9764 PyObject * obj0 = 0 ;
9765 PyObject * obj1 = 0 ;
9766 char * kwnames[] = {
9767 (char *) "self",(char *) "config", NULL
9768 };
9769
9770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9774 }
9775 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9776 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9777 if (!SWIG_IsOK(res2)) {
9778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9779 }
9780 if (!argp2) {
9781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9782 }
9783 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9784 {
9785 PyThreadState* __tstate = wxPyBeginAllowThreads();
9786 (arg1)->Save(*arg2);
9787 wxPyEndAllowThreads(__tstate);
9788 if (PyErr_Occurred()) SWIG_fail;
9789 }
9790 resultobj = SWIG_Py_Void();
9791 return resultobj;
9792 fail:
9793 return NULL;
9794 }
9795
9796
9797 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9798 PyObject *resultobj = 0;
9799 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9800 void *argp1 = 0 ;
9801 int res1 = 0 ;
9802 PyObject *swig_obj[1] ;
9803
9804 if (!args) SWIG_fail;
9805 swig_obj[0] = args;
9806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9807 if (!SWIG_IsOK(res1)) {
9808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9809 }
9810 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9811 {
9812 PyThreadState* __tstate = wxPyBeginAllowThreads();
9813 (arg1)->AddFilesToMenu();
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 resultobj = SWIG_Py_Void();
9818 return resultobj;
9819 fail:
9820 return NULL;
9821 }
9822
9823
9824 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj = 0;
9826 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9827 wxMenu *arg2 = (wxMenu *) 0 ;
9828 void *argp1 = 0 ;
9829 int res1 = 0 ;
9830 void *argp2 = 0 ;
9831 int res2 = 0 ;
9832 PyObject * obj0 = 0 ;
9833 PyObject * obj1 = 0 ;
9834 char * kwnames[] = {
9835 (char *) "self",(char *) "menu", NULL
9836 };
9837
9838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9840 if (!SWIG_IsOK(res1)) {
9841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9842 }
9843 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9844 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9845 if (!SWIG_IsOK(res2)) {
9846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9847 }
9848 arg2 = reinterpret_cast< wxMenu * >(argp2);
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 (arg1)->AddFilesToMenu(arg2);
9852 wxPyEndAllowThreads(__tstate);
9853 if (PyErr_Occurred()) SWIG_fail;
9854 }
9855 resultobj = SWIG_Py_Void();
9856 return resultobj;
9857 fail:
9858 return NULL;
9859 }
9860
9861
9862 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9863 PyObject *resultobj = 0;
9864 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9865 int arg2 ;
9866 wxString result;
9867 void *argp1 = 0 ;
9868 int res1 = 0 ;
9869 int val2 ;
9870 int ecode2 = 0 ;
9871 PyObject * obj0 = 0 ;
9872 PyObject * obj1 = 0 ;
9873 char * kwnames[] = {
9874 (char *) "self",(char *) "i", NULL
9875 };
9876
9877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9879 if (!SWIG_IsOK(res1)) {
9880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9881 }
9882 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9883 ecode2 = SWIG_AsVal_int(obj1, &val2);
9884 if (!SWIG_IsOK(ecode2)) {
9885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9886 }
9887 arg2 = static_cast< int >(val2);
9888 {
9889 PyThreadState* __tstate = wxPyBeginAllowThreads();
9890 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9891 wxPyEndAllowThreads(__tstate);
9892 if (PyErr_Occurred()) SWIG_fail;
9893 }
9894 {
9895 #if wxUSE_UNICODE
9896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9897 #else
9898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9899 #endif
9900 }
9901 return resultobj;
9902 fail:
9903 return NULL;
9904 }
9905
9906
9907 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9908 PyObject *resultobj = 0;
9909 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9910 int result;
9911 void *argp1 = 0 ;
9912 int res1 = 0 ;
9913 PyObject *swig_obj[1] ;
9914
9915 if (!args) SWIG_fail;
9916 swig_obj[0] = args;
9917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9918 if (!SWIG_IsOK(res1)) {
9919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9920 }
9921 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 result = (int)((wxFileHistory const *)arg1)->GetCount();
9925 wxPyEndAllowThreads(__tstate);
9926 if (PyErr_Occurred()) SWIG_fail;
9927 }
9928 resultobj = SWIG_From_int(static_cast< int >(result));
9929 return resultobj;
9930 fail:
9931 return NULL;
9932 }
9933
9934
9935 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9936 PyObject *obj;
9937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9938 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9939 return SWIG_Py_Void();
9940 }
9941
9942 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9943 return SWIG_Python_InitShadowInstance(args);
9944 }
9945
9946 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj = 0;
9948 wxString *arg1 = 0 ;
9949 wxString const &arg2_defvalue = wxPyEmptyString ;
9950 wxString *arg2 = (wxString *) &arg2_defvalue ;
9951 wxSingleInstanceChecker *result = 0 ;
9952 bool temp1 = false ;
9953 bool temp2 = false ;
9954 PyObject * obj0 = 0 ;
9955 PyObject * obj1 = 0 ;
9956 char * kwnames[] = {
9957 (char *) "name",(char *) "path", NULL
9958 };
9959
9960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9961 {
9962 arg1 = wxString_in_helper(obj0);
9963 if (arg1 == NULL) SWIG_fail;
9964 temp1 = true;
9965 }
9966 if (obj1) {
9967 {
9968 arg2 = wxString_in_helper(obj1);
9969 if (arg2 == NULL) SWIG_fail;
9970 temp2 = true;
9971 }
9972 }
9973 {
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9976 wxPyEndAllowThreads(__tstate);
9977 if (PyErr_Occurred()) SWIG_fail;
9978 }
9979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9980 {
9981 if (temp1)
9982 delete arg1;
9983 }
9984 {
9985 if (temp2)
9986 delete arg2;
9987 }
9988 return resultobj;
9989 fail:
9990 {
9991 if (temp1)
9992 delete arg1;
9993 }
9994 {
9995 if (temp2)
9996 delete arg2;
9997 }
9998 return NULL;
9999 }
10000
10001
10002 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10003 PyObject *resultobj = 0;
10004 wxSingleInstanceChecker *result = 0 ;
10005
10006 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
10007 {
10008 PyThreadState* __tstate = wxPyBeginAllowThreads();
10009 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10010 wxPyEndAllowThreads(__tstate);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10014 return resultobj;
10015 fail:
10016 return NULL;
10017 }
10018
10019
10020 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021 PyObject *resultobj = 0;
10022 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10023 void *argp1 = 0 ;
10024 int res1 = 0 ;
10025 PyObject *swig_obj[1] ;
10026
10027 if (!args) SWIG_fail;
10028 swig_obj[0] = args;
10029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10030 if (!SWIG_IsOK(res1)) {
10031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10032 }
10033 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10034 {
10035 PyThreadState* __tstate = wxPyBeginAllowThreads();
10036 delete arg1;
10037
10038 wxPyEndAllowThreads(__tstate);
10039 if (PyErr_Occurred()) SWIG_fail;
10040 }
10041 resultobj = SWIG_Py_Void();
10042 return resultobj;
10043 fail:
10044 return NULL;
10045 }
10046
10047
10048 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10049 PyObject *resultobj = 0;
10050 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10051 wxString *arg2 = 0 ;
10052 wxString const &arg3_defvalue = wxPyEmptyString ;
10053 wxString *arg3 = (wxString *) &arg3_defvalue ;
10054 bool result;
10055 void *argp1 = 0 ;
10056 int res1 = 0 ;
10057 bool temp2 = false ;
10058 bool temp3 = false ;
10059 PyObject * obj0 = 0 ;
10060 PyObject * obj1 = 0 ;
10061 PyObject * obj2 = 0 ;
10062 char * kwnames[] = {
10063 (char *) "self",(char *) "name",(char *) "path", NULL
10064 };
10065
10066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10068 if (!SWIG_IsOK(res1)) {
10069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10070 }
10071 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10072 {
10073 arg2 = wxString_in_helper(obj1);
10074 if (arg2 == NULL) SWIG_fail;
10075 temp2 = true;
10076 }
10077 if (obj2) {
10078 {
10079 arg3 = wxString_in_helper(obj2);
10080 if (arg3 == NULL) SWIG_fail;
10081 temp3 = true;
10082 }
10083 }
10084 {
10085 PyThreadState* __tstate = wxPyBeginAllowThreads();
10086 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10087 wxPyEndAllowThreads(__tstate);
10088 if (PyErr_Occurred()) SWIG_fail;
10089 }
10090 {
10091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10092 }
10093 {
10094 if (temp2)
10095 delete arg2;
10096 }
10097 {
10098 if (temp3)
10099 delete arg3;
10100 }
10101 return resultobj;
10102 fail:
10103 {
10104 if (temp2)
10105 delete arg2;
10106 }
10107 {
10108 if (temp3)
10109 delete arg3;
10110 }
10111 return NULL;
10112 }
10113
10114
10115 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10116 PyObject *resultobj = 0;
10117 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10118 bool result;
10119 void *argp1 = 0 ;
10120 int res1 = 0 ;
10121 PyObject *swig_obj[1] ;
10122
10123 if (!args) SWIG_fail;
10124 swig_obj[0] = args;
10125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10126 if (!SWIG_IsOK(res1)) {
10127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10128 }
10129 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10130 {
10131 PyThreadState* __tstate = wxPyBeginAllowThreads();
10132 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 {
10137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10138 }
10139 return resultobj;
10140 fail:
10141 return NULL;
10142 }
10143
10144
10145 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10146 PyObject *obj;
10147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10148 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10149 return SWIG_Py_Void();
10150 }
10151
10152 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10153 return SWIG_Python_InitShadowInstance(args);
10154 }
10155
10156 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10157 PyObject *resultobj = 0;
10158 wxPlatformInfo *result = 0 ;
10159
10160 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10161 {
10162 PyThreadState* __tstate = wxPyBeginAllowThreads();
10163 result = (wxPlatformInfo *)new wxPlatformInfo();
10164 wxPyEndAllowThreads(__tstate);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10168 return resultobj;
10169 fail:
10170 return NULL;
10171 }
10172
10173
10174 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj = 0;
10176 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10177 wxPlatformInfo *arg2 = 0 ;
10178 bool result;
10179 void *argp1 = 0 ;
10180 int res1 = 0 ;
10181 void *argp2 = 0 ;
10182 int res2 = 0 ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char * kwnames[] = {
10186 (char *) "self",(char *) "t", NULL
10187 };
10188
10189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10191 if (!SWIG_IsOK(res1)) {
10192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10193 }
10194 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10196 if (!SWIG_IsOK(res2)) {
10197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10198 }
10199 if (!argp2) {
10200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10201 }
10202 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 {
10210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10211 }
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj = 0;
10220 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10221 wxPlatformInfo *arg2 = 0 ;
10222 bool result;
10223 void *argp1 = 0 ;
10224 int res1 = 0 ;
10225 void *argp2 = 0 ;
10226 int res2 = 0 ;
10227 PyObject * obj0 = 0 ;
10228 PyObject * obj1 = 0 ;
10229 char * kwnames[] = {
10230 (char *) "self",(char *) "t", NULL
10231 };
10232
10233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10235 if (!SWIG_IsOK(res1)) {
10236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10237 }
10238 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10239 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10240 if (!SWIG_IsOK(res2)) {
10241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10242 }
10243 if (!argp2) {
10244 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10245 }
10246 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10247 {
10248 PyThreadState* __tstate = wxPyBeginAllowThreads();
10249 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10250 wxPyEndAllowThreads(__tstate);
10251 if (PyErr_Occurred()) SWIG_fail;
10252 }
10253 {
10254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10255 }
10256 return resultobj;
10257 fail:
10258 return NULL;
10259 }
10260
10261
10262 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10263 PyObject *resultobj = 0;
10264 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10265 int result;
10266 void *argp1 = 0 ;
10267 int res1 = 0 ;
10268 PyObject *swig_obj[1] ;
10269
10270 if (!args) SWIG_fail;
10271 swig_obj[0] = args;
10272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10273 if (!SWIG_IsOK(res1)) {
10274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10275 }
10276 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10277 {
10278 PyThreadState* __tstate = wxPyBeginAllowThreads();
10279 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10280 wxPyEndAllowThreads(__tstate);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 resultobj = SWIG_From_int(static_cast< int >(result));
10284 return resultobj;
10285 fail:
10286 return NULL;
10287 }
10288
10289
10290 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10291 PyObject *resultobj = 0;
10292 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10293 int result;
10294 void *argp1 = 0 ;
10295 int res1 = 0 ;
10296 PyObject *swig_obj[1] ;
10297
10298 if (!args) SWIG_fail;
10299 swig_obj[0] = args;
10300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10301 if (!SWIG_IsOK(res1)) {
10302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10303 }
10304 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10305 {
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10308 wxPyEndAllowThreads(__tstate);
10309 if (PyErr_Occurred()) SWIG_fail;
10310 }
10311 resultobj = SWIG_From_int(static_cast< int >(result));
10312 return resultobj;
10313 fail:
10314 return NULL;
10315 }
10316
10317
10318 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10319 PyObject *resultobj = 0;
10320 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10321 int arg2 ;
10322 int arg3 ;
10323 bool result;
10324 void *argp1 = 0 ;
10325 int res1 = 0 ;
10326 int val2 ;
10327 int ecode2 = 0 ;
10328 int val3 ;
10329 int ecode3 = 0 ;
10330 PyObject * obj0 = 0 ;
10331 PyObject * obj1 = 0 ;
10332 PyObject * obj2 = 0 ;
10333 char * kwnames[] = {
10334 (char *) "self",(char *) "major",(char *) "minor", NULL
10335 };
10336
10337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10339 if (!SWIG_IsOK(res1)) {
10340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10341 }
10342 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10343 ecode2 = SWIG_AsVal_int(obj1, &val2);
10344 if (!SWIG_IsOK(ecode2)) {
10345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10346 }
10347 arg2 = static_cast< int >(val2);
10348 ecode3 = SWIG_AsVal_int(obj2, &val3);
10349 if (!SWIG_IsOK(ecode3)) {
10350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10351 }
10352 arg3 = static_cast< int >(val3);
10353 {
10354 PyThreadState* __tstate = wxPyBeginAllowThreads();
10355 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10356 wxPyEndAllowThreads(__tstate);
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 {
10360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10361 }
10362 return resultobj;
10363 fail:
10364 return NULL;
10365 }
10366
10367
10368 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10369 PyObject *resultobj = 0;
10370 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10371 int result;
10372 void *argp1 = 0 ;
10373 int res1 = 0 ;
10374 PyObject *swig_obj[1] ;
10375
10376 if (!args) SWIG_fail;
10377 swig_obj[0] = args;
10378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10379 if (!SWIG_IsOK(res1)) {
10380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10381 }
10382 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10383 {
10384 PyThreadState* __tstate = wxPyBeginAllowThreads();
10385 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10386 wxPyEndAllowThreads(__tstate);
10387 if (PyErr_Occurred()) SWIG_fail;
10388 }
10389 resultobj = SWIG_From_int(static_cast< int >(result));
10390 return resultobj;
10391 fail:
10392 return NULL;
10393 }
10394
10395
10396 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10397 PyObject *resultobj = 0;
10398 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10399 int result;
10400 void *argp1 = 0 ;
10401 int res1 = 0 ;
10402 PyObject *swig_obj[1] ;
10403
10404 if (!args) SWIG_fail;
10405 swig_obj[0] = args;
10406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10407 if (!SWIG_IsOK(res1)) {
10408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10409 }
10410 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 resultobj = SWIG_From_int(static_cast< int >(result));
10418 return resultobj;
10419 fail:
10420 return NULL;
10421 }
10422
10423
10424 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10425 PyObject *resultobj = 0;
10426 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10427 int arg2 ;
10428 int arg3 ;
10429 bool result;
10430 void *argp1 = 0 ;
10431 int res1 = 0 ;
10432 int val2 ;
10433 int ecode2 = 0 ;
10434 int val3 ;
10435 int ecode3 = 0 ;
10436 PyObject * obj0 = 0 ;
10437 PyObject * obj1 = 0 ;
10438 PyObject * obj2 = 0 ;
10439 char * kwnames[] = {
10440 (char *) "self",(char *) "major",(char *) "minor", NULL
10441 };
10442
10443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10445 if (!SWIG_IsOK(res1)) {
10446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10447 }
10448 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10449 ecode2 = SWIG_AsVal_int(obj1, &val2);
10450 if (!SWIG_IsOK(ecode2)) {
10451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10452 }
10453 arg2 = static_cast< int >(val2);
10454 ecode3 = SWIG_AsVal_int(obj2, &val3);
10455 if (!SWIG_IsOK(ecode3)) {
10456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10457 }
10458 arg3 = static_cast< int >(val3);
10459 {
10460 PyThreadState* __tstate = wxPyBeginAllowThreads();
10461 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10462 wxPyEndAllowThreads(__tstate);
10463 if (PyErr_Occurred()) SWIG_fail;
10464 }
10465 {
10466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10467 }
10468 return resultobj;
10469 fail:
10470 return NULL;
10471 }
10472
10473
10474 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10475 PyObject *resultobj = 0;
10476 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10477 bool result;
10478 void *argp1 = 0 ;
10479 int res1 = 0 ;
10480 PyObject *swig_obj[1] ;
10481
10482 if (!args) SWIG_fail;
10483 swig_obj[0] = args;
10484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10485 if (!SWIG_IsOK(res1)) {
10486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10487 }
10488 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 {
10496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10497 }
10498 return resultobj;
10499 fail:
10500 return NULL;
10501 }
10502
10503
10504 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10505 PyObject *resultobj = 0;
10506 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10507 wxOperatingSystemId result;
10508 void *argp1 = 0 ;
10509 int res1 = 0 ;
10510 PyObject *swig_obj[1] ;
10511
10512 if (!args) SWIG_fail;
10513 swig_obj[0] = args;
10514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10515 if (!SWIG_IsOK(res1)) {
10516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10517 }
10518 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10519 {
10520 PyThreadState* __tstate = wxPyBeginAllowThreads();
10521 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10522 wxPyEndAllowThreads(__tstate);
10523 if (PyErr_Occurred()) SWIG_fail;
10524 }
10525 resultobj = SWIG_From_int(static_cast< int >(result));
10526 return resultobj;
10527 fail:
10528 return NULL;
10529 }
10530
10531
10532 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10533 PyObject *resultobj = 0;
10534 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10535 wxPortId result;
10536 void *argp1 = 0 ;
10537 int res1 = 0 ;
10538 PyObject *swig_obj[1] ;
10539
10540 if (!args) SWIG_fail;
10541 swig_obj[0] = args;
10542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10543 if (!SWIG_IsOK(res1)) {
10544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10545 }
10546 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 resultobj = SWIG_From_int(static_cast< int >(result));
10554 return resultobj;
10555 fail:
10556 return NULL;
10557 }
10558
10559
10560 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10561 PyObject *resultobj = 0;
10562 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10563 wxArchitecture result;
10564 void *argp1 = 0 ;
10565 int res1 = 0 ;
10566 PyObject *swig_obj[1] ;
10567
10568 if (!args) SWIG_fail;
10569 swig_obj[0] = args;
10570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10571 if (!SWIG_IsOK(res1)) {
10572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10573 }
10574 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10575 {
10576 PyThreadState* __tstate = wxPyBeginAllowThreads();
10577 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10578 wxPyEndAllowThreads(__tstate);
10579 if (PyErr_Occurred()) SWIG_fail;
10580 }
10581 resultobj = SWIG_From_int(static_cast< int >(result));
10582 return resultobj;
10583 fail:
10584 return NULL;
10585 }
10586
10587
10588 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10589 PyObject *resultobj = 0;
10590 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10591 wxEndianness result;
10592 void *argp1 = 0 ;
10593 int res1 = 0 ;
10594 PyObject *swig_obj[1] ;
10595
10596 if (!args) SWIG_fail;
10597 swig_obj[0] = args;
10598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10599 if (!SWIG_IsOK(res1)) {
10600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10601 }
10602 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10603 {
10604 PyThreadState* __tstate = wxPyBeginAllowThreads();
10605 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10606 wxPyEndAllowThreads(__tstate);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 resultobj = SWIG_From_int(static_cast< int >(result));
10610 return resultobj;
10611 fail:
10612 return NULL;
10613 }
10614
10615
10616 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10617 PyObject *resultobj = 0;
10618 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10619 wxString result;
10620 void *argp1 = 0 ;
10621 int res1 = 0 ;
10622 PyObject *swig_obj[1] ;
10623
10624 if (!args) SWIG_fail;
10625 swig_obj[0] = args;
10626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10627 if (!SWIG_IsOK(res1)) {
10628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10629 }
10630 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 {
10638 #if wxUSE_UNICODE
10639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10640 #else
10641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10642 #endif
10643 }
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10651 PyObject *resultobj = 0;
10652 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10653 wxString result;
10654 void *argp1 = 0 ;
10655 int res1 = 0 ;
10656 PyObject *swig_obj[1] ;
10657
10658 if (!args) SWIG_fail;
10659 swig_obj[0] = args;
10660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10661 if (!SWIG_IsOK(res1)) {
10662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10663 }
10664 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 {
10672 #if wxUSE_UNICODE
10673 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10674 #else
10675 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10676 #endif
10677 }
10678 return resultobj;
10679 fail:
10680 return NULL;
10681 }
10682
10683
10684 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10685 PyObject *resultobj = 0;
10686 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10687 wxString result;
10688 void *argp1 = 0 ;
10689 int res1 = 0 ;
10690 PyObject *swig_obj[1] ;
10691
10692 if (!args) SWIG_fail;
10693 swig_obj[0] = args;
10694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10695 if (!SWIG_IsOK(res1)) {
10696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10697 }
10698 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10699 {
10700 PyThreadState* __tstate = wxPyBeginAllowThreads();
10701 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10702 wxPyEndAllowThreads(__tstate);
10703 if (PyErr_Occurred()) SWIG_fail;
10704 }
10705 {
10706 #if wxUSE_UNICODE
10707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10708 #else
10709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10710 #endif
10711 }
10712 return resultobj;
10713 fail:
10714 return NULL;
10715 }
10716
10717
10718 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10719 PyObject *resultobj = 0;
10720 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10721 wxString result;
10722 void *argp1 = 0 ;
10723 int res1 = 0 ;
10724 PyObject *swig_obj[1] ;
10725
10726 if (!args) SWIG_fail;
10727 swig_obj[0] = args;
10728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10729 if (!SWIG_IsOK(res1)) {
10730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10731 }
10732 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10733 {
10734 PyThreadState* __tstate = wxPyBeginAllowThreads();
10735 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10736 wxPyEndAllowThreads(__tstate);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 {
10740 #if wxUSE_UNICODE
10741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10742 #else
10743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10744 #endif
10745 }
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10753 PyObject *resultobj = 0;
10754 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10755 wxString result;
10756 void *argp1 = 0 ;
10757 int res1 = 0 ;
10758 PyObject *swig_obj[1] ;
10759
10760 if (!args) SWIG_fail;
10761 swig_obj[0] = args;
10762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10763 if (!SWIG_IsOK(res1)) {
10764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10765 }
10766 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 {
10774 #if wxUSE_UNICODE
10775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10776 #else
10777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10778 #endif
10779 }
10780 return resultobj;
10781 fail:
10782 return NULL;
10783 }
10784
10785
10786 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10787 PyObject *resultobj = 0;
10788 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10789 wxString result;
10790 void *argp1 = 0 ;
10791 int res1 = 0 ;
10792 PyObject *swig_obj[1] ;
10793
10794 if (!args) SWIG_fail;
10795 swig_obj[0] = args;
10796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10797 if (!SWIG_IsOK(res1)) {
10798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10799 }
10800 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 {
10808 #if wxUSE_UNICODE
10809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10810 #else
10811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10812 #endif
10813 }
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj = 0;
10822 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10823 int arg2 ;
10824 int arg3 ;
10825 void *argp1 = 0 ;
10826 int res1 = 0 ;
10827 int val2 ;
10828 int ecode2 = 0 ;
10829 int val3 ;
10830 int ecode3 = 0 ;
10831 PyObject * obj0 = 0 ;
10832 PyObject * obj1 = 0 ;
10833 PyObject * obj2 = 0 ;
10834 char * kwnames[] = {
10835 (char *) "self",(char *) "major",(char *) "minor", NULL
10836 };
10837
10838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10840 if (!SWIG_IsOK(res1)) {
10841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10842 }
10843 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10844 ecode2 = SWIG_AsVal_int(obj1, &val2);
10845 if (!SWIG_IsOK(ecode2)) {
10846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10847 }
10848 arg2 = static_cast< int >(val2);
10849 ecode3 = SWIG_AsVal_int(obj2, &val3);
10850 if (!SWIG_IsOK(ecode3)) {
10851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10852 }
10853 arg3 = static_cast< int >(val3);
10854 {
10855 PyThreadState* __tstate = wxPyBeginAllowThreads();
10856 (arg1)->SetOSVersion(arg2,arg3);
10857 wxPyEndAllowThreads(__tstate);
10858 if (PyErr_Occurred()) SWIG_fail;
10859 }
10860 resultobj = SWIG_Py_Void();
10861 return resultobj;
10862 fail:
10863 return NULL;
10864 }
10865
10866
10867 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10868 PyObject *resultobj = 0;
10869 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10870 int arg2 ;
10871 int arg3 ;
10872 void *argp1 = 0 ;
10873 int res1 = 0 ;
10874 int val2 ;
10875 int ecode2 = 0 ;
10876 int val3 ;
10877 int ecode3 = 0 ;
10878 PyObject * obj0 = 0 ;
10879 PyObject * obj1 = 0 ;
10880 PyObject * obj2 = 0 ;
10881 char * kwnames[] = {
10882 (char *) "self",(char *) "major",(char *) "minor", NULL
10883 };
10884
10885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10887 if (!SWIG_IsOK(res1)) {
10888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10889 }
10890 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10891 ecode2 = SWIG_AsVal_int(obj1, &val2);
10892 if (!SWIG_IsOK(ecode2)) {
10893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10894 }
10895 arg2 = static_cast< int >(val2);
10896 ecode3 = SWIG_AsVal_int(obj2, &val3);
10897 if (!SWIG_IsOK(ecode3)) {
10898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10899 }
10900 arg3 = static_cast< int >(val3);
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 (arg1)->SetToolkitVersion(arg2,arg3);
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_Py_Void();
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj = 0;
10916 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10917 wxOperatingSystemId arg2 ;
10918 void *argp1 = 0 ;
10919 int res1 = 0 ;
10920 int val2 ;
10921 int ecode2 = 0 ;
10922 PyObject * obj0 = 0 ;
10923 PyObject * obj1 = 0 ;
10924 char * kwnames[] = {
10925 (char *) "self",(char *) "n", NULL
10926 };
10927
10928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10930 if (!SWIG_IsOK(res1)) {
10931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10932 }
10933 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10934 ecode2 = SWIG_AsVal_int(obj1, &val2);
10935 if (!SWIG_IsOK(ecode2)) {
10936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10937 }
10938 arg2 = static_cast< wxOperatingSystemId >(val2);
10939 {
10940 PyThreadState* __tstate = wxPyBeginAllowThreads();
10941 (arg1)->SetOperatingSystemId(arg2);
10942 wxPyEndAllowThreads(__tstate);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 resultobj = SWIG_Py_Void();
10946 return resultobj;
10947 fail:
10948 return NULL;
10949 }
10950
10951
10952 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj = 0;
10954 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10955 wxPortId arg2 ;
10956 void *argp1 = 0 ;
10957 int res1 = 0 ;
10958 int val2 ;
10959 int ecode2 = 0 ;
10960 PyObject * obj0 = 0 ;
10961 PyObject * obj1 = 0 ;
10962 char * kwnames[] = {
10963 (char *) "self",(char *) "n", NULL
10964 };
10965
10966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10968 if (!SWIG_IsOK(res1)) {
10969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10970 }
10971 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10972 ecode2 = SWIG_AsVal_int(obj1, &val2);
10973 if (!SWIG_IsOK(ecode2)) {
10974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10975 }
10976 arg2 = static_cast< wxPortId >(val2);
10977 {
10978 PyThreadState* __tstate = wxPyBeginAllowThreads();
10979 (arg1)->SetPortId(arg2);
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 resultobj = SWIG_Py_Void();
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj = 0;
10992 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10993 wxArchitecture arg2 ;
10994 void *argp1 = 0 ;
10995 int res1 = 0 ;
10996 int val2 ;
10997 int ecode2 = 0 ;
10998 PyObject * obj0 = 0 ;
10999 PyObject * obj1 = 0 ;
11000 char * kwnames[] = {
11001 (char *) "self",(char *) "n", NULL
11002 };
11003
11004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
11005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11006 if (!SWIG_IsOK(res1)) {
11007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11008 }
11009 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11010 ecode2 = SWIG_AsVal_int(obj1, &val2);
11011 if (!SWIG_IsOK(ecode2)) {
11012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11013 }
11014 arg2 = static_cast< wxArchitecture >(val2);
11015 {
11016 PyThreadState* __tstate = wxPyBeginAllowThreads();
11017 (arg1)->SetArchitecture(arg2);
11018 wxPyEndAllowThreads(__tstate);
11019 if (PyErr_Occurred()) SWIG_fail;
11020 }
11021 resultobj = SWIG_Py_Void();
11022 return resultobj;
11023 fail:
11024 return NULL;
11025 }
11026
11027
11028 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj = 0;
11030 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11031 wxEndianness arg2 ;
11032 void *argp1 = 0 ;
11033 int res1 = 0 ;
11034 int val2 ;
11035 int ecode2 = 0 ;
11036 PyObject * obj0 = 0 ;
11037 PyObject * obj1 = 0 ;
11038 char * kwnames[] = {
11039 (char *) "self",(char *) "n", NULL
11040 };
11041
11042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11044 if (!SWIG_IsOK(res1)) {
11045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11046 }
11047 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11048 ecode2 = SWIG_AsVal_int(obj1, &val2);
11049 if (!SWIG_IsOK(ecode2)) {
11050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11051 }
11052 arg2 = static_cast< wxEndianness >(val2);
11053 {
11054 PyThreadState* __tstate = wxPyBeginAllowThreads();
11055 (arg1)->SetEndianness(arg2);
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 resultobj = SWIG_Py_Void();
11060 return resultobj;
11061 fail:
11062 return NULL;
11063 }
11064
11065
11066 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11067 PyObject *resultobj = 0;
11068 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11069 bool result;
11070 void *argp1 = 0 ;
11071 int res1 = 0 ;
11072 PyObject *swig_obj[1] ;
11073
11074 if (!args) SWIG_fail;
11075 swig_obj[0] = args;
11076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11077 if (!SWIG_IsOK(res1)) {
11078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11079 }
11080 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11081 {
11082 PyThreadState* __tstate = wxPyBeginAllowThreads();
11083 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11084 wxPyEndAllowThreads(__tstate);
11085 if (PyErr_Occurred()) SWIG_fail;
11086 }
11087 {
11088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11089 }
11090 return resultobj;
11091 fail:
11092 return NULL;
11093 }
11094
11095
11096 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11097 PyObject *obj;
11098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11099 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11100 return SWIG_Py_Void();
11101 }
11102
11103 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11104 return SWIG_Python_InitShadowInstance(args);
11105 }
11106
11107 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11108 PyObject *resultobj = 0;
11109 wxWindow *arg1 = (wxWindow *) 0 ;
11110 wxDC *arg2 = 0 ;
11111 bool result;
11112 void *argp1 = 0 ;
11113 int res1 = 0 ;
11114 void *argp2 = 0 ;
11115 int res2 = 0 ;
11116 PyObject * obj0 = 0 ;
11117 PyObject * obj1 = 0 ;
11118 char * kwnames[] = {
11119 (char *) "window",(char *) "dc", NULL
11120 };
11121
11122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11124 if (!SWIG_IsOK(res1)) {
11125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11126 }
11127 arg1 = reinterpret_cast< wxWindow * >(argp1);
11128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11129 if (!SWIG_IsOK(res2)) {
11130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11131 }
11132 if (!argp2) {
11133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11134 }
11135 arg2 = reinterpret_cast< wxDC * >(argp2);
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 {
11143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11144 }
11145 return resultobj;
11146 fail:
11147 return NULL;
11148 }
11149
11150
11151 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11152 PyObject *resultobj = 0;
11153 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 PyObject *swig_obj[1] ;
11157
11158 if (!args) SWIG_fail;
11159 swig_obj[0] = args;
11160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11161 if (!SWIG_IsOK(res1)) {
11162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11163 }
11164 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11165 {
11166 PyThreadState* __tstate = wxPyBeginAllowThreads();
11167 delete arg1;
11168
11169 wxPyEndAllowThreads(__tstate);
11170 if (PyErr_Occurred()) SWIG_fail;
11171 }
11172 resultobj = SWIG_Py_Void();
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11180 PyObject *resultobj = 0;
11181 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11182 wxString result;
11183 void *argp1 = 0 ;
11184 int res1 = 0 ;
11185 PyObject *swig_obj[1] ;
11186
11187 if (!args) SWIG_fail;
11188 swig_obj[0] = args;
11189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11190 if (!SWIG_IsOK(res1)) {
11191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11192 }
11193 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11194 {
11195 PyThreadState* __tstate = wxPyBeginAllowThreads();
11196 result = (arg1)->GetTip();
11197 wxPyEndAllowThreads(__tstate);
11198 if (PyErr_Occurred()) SWIG_fail;
11199 }
11200 {
11201 #if wxUSE_UNICODE
11202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11203 #else
11204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11205 #endif
11206 }
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11214 PyObject *resultobj = 0;
11215 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11216 size_t result;
11217 void *argp1 = 0 ;
11218 int res1 = 0 ;
11219 PyObject *swig_obj[1] ;
11220
11221 if (!args) SWIG_fail;
11222 swig_obj[0] = args;
11223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11224 if (!SWIG_IsOK(res1)) {
11225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11226 }
11227 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = (size_t)(arg1)->GetCurrentTip();
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj = 0;
11243 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11244 wxString *arg2 = 0 ;
11245 wxString result;
11246 void *argp1 = 0 ;
11247 int res1 = 0 ;
11248 bool temp2 = false ;
11249 PyObject * obj0 = 0 ;
11250 PyObject * obj1 = 0 ;
11251 char * kwnames[] = {
11252 (char *) "self",(char *) "tip", NULL
11253 };
11254
11255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11257 if (!SWIG_IsOK(res1)) {
11258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11259 }
11260 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11261 {
11262 arg2 = wxString_in_helper(obj1);
11263 if (arg2 == NULL) SWIG_fail;
11264 temp2 = true;
11265 }
11266 {
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 {
11273 #if wxUSE_UNICODE
11274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11275 #else
11276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11277 #endif
11278 }
11279 {
11280 if (temp2)
11281 delete arg2;
11282 }
11283 return resultobj;
11284 fail:
11285 {
11286 if (temp2)
11287 delete arg2;
11288 }
11289 return NULL;
11290 }
11291
11292
11293 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11294 PyObject *obj;
11295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11296 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11297 return SWIG_Py_Void();
11298 }
11299
11300 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11301 PyObject *resultobj = 0;
11302 size_t arg1 ;
11303 wxPyTipProvider *result = 0 ;
11304 size_t val1 ;
11305 int ecode1 = 0 ;
11306 PyObject * obj0 = 0 ;
11307 char * kwnames[] = {
11308 (char *) "currentTip", NULL
11309 };
11310
11311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11312 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11313 if (!SWIG_IsOK(ecode1)) {
11314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11315 }
11316 arg1 = static_cast< size_t >(val1);
11317 {
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11320 wxPyEndAllowThreads(__tstate);
11321 if (PyErr_Occurred()) SWIG_fail;
11322 }
11323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11324 return resultobj;
11325 fail:
11326 return NULL;
11327 }
11328
11329
11330 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11331 PyObject *resultobj = 0;
11332 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11333 PyObject *arg2 = (PyObject *) 0 ;
11334 PyObject *arg3 = (PyObject *) 0 ;
11335 void *argp1 = 0 ;
11336 int res1 = 0 ;
11337 PyObject * obj0 = 0 ;
11338 PyObject * obj1 = 0 ;
11339 PyObject * obj2 = 0 ;
11340 char * kwnames[] = {
11341 (char *) "self",(char *) "self",(char *) "_class", NULL
11342 };
11343
11344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11346 if (!SWIG_IsOK(res1)) {
11347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11348 }
11349 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11350 arg2 = obj1;
11351 arg3 = obj2;
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 (arg1)->_setCallbackInfo(arg2,arg3);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 return resultobj;
11360 fail:
11361 return NULL;
11362 }
11363
11364
11365 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11366 PyObject *obj;
11367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11368 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11369 return SWIG_Py_Void();
11370 }
11371
11372 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11373 return SWIG_Python_InitShadowInstance(args);
11374 }
11375
11376 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11377 PyObject *resultobj = 0;
11378 wxWindow *arg1 = (wxWindow *) 0 ;
11379 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11380 bool arg3 = (bool) true ;
11381 bool result;
11382 void *argp1 = 0 ;
11383 int res1 = 0 ;
11384 void *argp2 = 0 ;
11385 int res2 = 0 ;
11386 bool val3 ;
11387 int ecode3 = 0 ;
11388 PyObject * obj0 = 0 ;
11389 PyObject * obj1 = 0 ;
11390 PyObject * obj2 = 0 ;
11391 char * kwnames[] = {
11392 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11393 };
11394
11395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11397 if (!SWIG_IsOK(res1)) {
11398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11399 }
11400 arg1 = reinterpret_cast< wxWindow * >(argp1);
11401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11402 if (!SWIG_IsOK(res2)) {
11403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11404 }
11405 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11406 if (obj2) {
11407 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11408 if (!SWIG_IsOK(ecode3)) {
11409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11410 }
11411 arg3 = static_cast< bool >(val3);
11412 }
11413 {
11414 if (!wxPyCheckForApp()) SWIG_fail;
11415 PyThreadState* __tstate = wxPyBeginAllowThreads();
11416 result = (bool)wxShowTip(arg1,arg2,arg3);
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 {
11421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11422 }
11423 return resultobj;
11424 fail:
11425 return NULL;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 wxString *arg1 = 0 ;
11432 size_t arg2 ;
11433 wxTipProvider *result = 0 ;
11434 bool temp1 = false ;
11435 size_t val2 ;
11436 int ecode2 = 0 ;
11437 PyObject * obj0 = 0 ;
11438 PyObject * obj1 = 0 ;
11439 char * kwnames[] = {
11440 (char *) "filename",(char *) "currentTip", NULL
11441 };
11442
11443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11444 {
11445 arg1 = wxString_in_helper(obj0);
11446 if (arg1 == NULL) SWIG_fail;
11447 temp1 = true;
11448 }
11449 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11450 if (!SWIG_IsOK(ecode2)) {
11451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11452 }
11453 arg2 = static_cast< size_t >(val2);
11454 {
11455 if (!wxPyCheckForApp()) SWIG_fail;
11456 PyThreadState* __tstate = wxPyBeginAllowThreads();
11457 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11458 wxPyEndAllowThreads(__tstate);
11459 if (PyErr_Occurred()) SWIG_fail;
11460 }
11461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11462 {
11463 if (temp1)
11464 delete arg1;
11465 }
11466 return resultobj;
11467 fail:
11468 {
11469 if (temp1)
11470 delete arg1;
11471 }
11472 return NULL;
11473 }
11474
11475
11476 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11477 PyObject *resultobj = 0;
11478 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11479 int arg2 = (int) wxID_ANY ;
11480 wxPyTimer *result = 0 ;
11481 void *argp1 = 0 ;
11482 int res1 = 0 ;
11483 int val2 ;
11484 int ecode2 = 0 ;
11485 PyObject * obj0 = 0 ;
11486 PyObject * obj1 = 0 ;
11487 char * kwnames[] = {
11488 (char *) "owner",(char *) "id", NULL
11489 };
11490
11491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11492 if (obj0) {
11493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11494 if (!SWIG_IsOK(res1)) {
11495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11496 }
11497 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11498 }
11499 if (obj1) {
11500 ecode2 = SWIG_AsVal_int(obj1, &val2);
11501 if (!SWIG_IsOK(ecode2)) {
11502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11503 }
11504 arg2 = static_cast< int >(val2);
11505 }
11506 {
11507 if (!wxPyCheckForApp()) SWIG_fail;
11508 PyThreadState* __tstate = wxPyBeginAllowThreads();
11509 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11510 wxPyEndAllowThreads(__tstate);
11511 if (PyErr_Occurred()) SWIG_fail;
11512 }
11513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11514 return resultobj;
11515 fail:
11516 return NULL;
11517 }
11518
11519
11520 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11521 PyObject *resultobj = 0;
11522 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11523 void *argp1 = 0 ;
11524 int res1 = 0 ;
11525 PyObject *swig_obj[1] ;
11526
11527 if (!args) SWIG_fail;
11528 swig_obj[0] = args;
11529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11530 if (!SWIG_IsOK(res1)) {
11531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11532 }
11533 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11534 {
11535 PyThreadState* __tstate = wxPyBeginAllowThreads();
11536 delete arg1;
11537
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 resultobj = SWIG_Py_Void();
11542 return resultobj;
11543 fail:
11544 return NULL;
11545 }
11546
11547
11548 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11549 PyObject *resultobj = 0;
11550 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11551 PyObject *arg2 = (PyObject *) 0 ;
11552 PyObject *arg3 = (PyObject *) 0 ;
11553 int arg4 = (int) 0 ;
11554 void *argp1 = 0 ;
11555 int res1 = 0 ;
11556 int val4 ;
11557 int ecode4 = 0 ;
11558 PyObject * obj0 = 0 ;
11559 PyObject * obj1 = 0 ;
11560 PyObject * obj2 = 0 ;
11561 PyObject * obj3 = 0 ;
11562 char * kwnames[] = {
11563 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11564 };
11565
11566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11568 if (!SWIG_IsOK(res1)) {
11569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11570 }
11571 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11572 arg2 = obj1;
11573 arg3 = obj2;
11574 if (obj3) {
11575 ecode4 = SWIG_AsVal_int(obj3, &val4);
11576 if (!SWIG_IsOK(ecode4)) {
11577 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11578 }
11579 arg4 = static_cast< int >(val4);
11580 }
11581 {
11582 PyThreadState* __tstate = wxPyBeginAllowThreads();
11583 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11584 wxPyEndAllowThreads(__tstate);
11585 if (PyErr_Occurred()) SWIG_fail;
11586 }
11587 resultobj = SWIG_Py_Void();
11588 return resultobj;
11589 fail:
11590 return NULL;
11591 }
11592
11593
11594 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11595 PyObject *resultobj = 0;
11596 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11597 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11598 int arg3 = (int) wxID_ANY ;
11599 void *argp1 = 0 ;
11600 int res1 = 0 ;
11601 void *argp2 = 0 ;
11602 int res2 = 0 ;
11603 int val3 ;
11604 int ecode3 = 0 ;
11605 PyObject * obj0 = 0 ;
11606 PyObject * obj1 = 0 ;
11607 PyObject * obj2 = 0 ;
11608 char * kwnames[] = {
11609 (char *) "self",(char *) "owner",(char *) "id", NULL
11610 };
11611
11612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11614 if (!SWIG_IsOK(res1)) {
11615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11616 }
11617 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11618 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11619 if (!SWIG_IsOK(res2)) {
11620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11621 }
11622 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11623 if (obj2) {
11624 ecode3 = SWIG_AsVal_int(obj2, &val3);
11625 if (!SWIG_IsOK(ecode3)) {
11626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11627 }
11628 arg3 = static_cast< int >(val3);
11629 }
11630 {
11631 PyThreadState* __tstate = wxPyBeginAllowThreads();
11632 (arg1)->SetOwner(arg2,arg3);
11633 wxPyEndAllowThreads(__tstate);
11634 if (PyErr_Occurred()) SWIG_fail;
11635 }
11636 resultobj = SWIG_Py_Void();
11637 return resultobj;
11638 fail:
11639 return NULL;
11640 }
11641
11642
11643 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11644 PyObject *resultobj = 0;
11645 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11646 wxEvtHandler *result = 0 ;
11647 void *argp1 = 0 ;
11648 int res1 = 0 ;
11649 PyObject *swig_obj[1] ;
11650
11651 if (!args) SWIG_fail;
11652 swig_obj[0] = args;
11653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11656 }
11657 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11658 {
11659 PyThreadState* __tstate = wxPyBeginAllowThreads();
11660 result = (wxEvtHandler *)(arg1)->GetOwner();
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 {
11665 resultobj = wxPyMake_wxObject(result, 0);
11666 }
11667 return resultobj;
11668 fail:
11669 return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11674 PyObject *resultobj = 0;
11675 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11676 int arg2 = (int) -1 ;
11677 bool arg3 = (bool) false ;
11678 bool result;
11679 void *argp1 = 0 ;
11680 int res1 = 0 ;
11681 int val2 ;
11682 int ecode2 = 0 ;
11683 bool val3 ;
11684 int ecode3 = 0 ;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11688 char * kwnames[] = {
11689 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11690 };
11691
11692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11696 }
11697 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11698 if (obj1) {
11699 ecode2 = SWIG_AsVal_int(obj1, &val2);
11700 if (!SWIG_IsOK(ecode2)) {
11701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11702 }
11703 arg2 = static_cast< int >(val2);
11704 }
11705 if (obj2) {
11706 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11707 if (!SWIG_IsOK(ecode3)) {
11708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11709 }
11710 arg3 = static_cast< bool >(val3);
11711 }
11712 {
11713 PyThreadState* __tstate = wxPyBeginAllowThreads();
11714 result = (bool)(arg1)->Start(arg2,arg3);
11715 wxPyEndAllowThreads(__tstate);
11716 if (PyErr_Occurred()) SWIG_fail;
11717 }
11718 {
11719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11720 }
11721 return resultobj;
11722 fail:
11723 return NULL;
11724 }
11725
11726
11727 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11728 PyObject *resultobj = 0;
11729 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11730 void *argp1 = 0 ;
11731 int res1 = 0 ;
11732 PyObject *swig_obj[1] ;
11733
11734 if (!args) SWIG_fail;
11735 swig_obj[0] = args;
11736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11737 if (!SWIG_IsOK(res1)) {
11738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11739 }
11740 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11741 {
11742 PyThreadState* __tstate = wxPyBeginAllowThreads();
11743 (arg1)->Stop();
11744 wxPyEndAllowThreads(__tstate);
11745 if (PyErr_Occurred()) SWIG_fail;
11746 }
11747 resultobj = SWIG_Py_Void();
11748 return resultobj;
11749 fail:
11750 return NULL;
11751 }
11752
11753
11754 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11755 PyObject *resultobj = 0;
11756 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11757 void *argp1 = 0 ;
11758 int res1 = 0 ;
11759 PyObject *swig_obj[1] ;
11760
11761 if (!args) SWIG_fail;
11762 swig_obj[0] = args;
11763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11764 if (!SWIG_IsOK(res1)) {
11765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11766 }
11767 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11768 {
11769 PyThreadState* __tstate = wxPyBeginAllowThreads();
11770 (arg1)->Notify();
11771 wxPyEndAllowThreads(__tstate);
11772 if (PyErr_Occurred()) SWIG_fail;
11773 }
11774 resultobj = SWIG_Py_Void();
11775 return resultobj;
11776 fail:
11777 return NULL;
11778 }
11779
11780
11781 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11782 PyObject *resultobj = 0;
11783 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11784 bool result;
11785 void *argp1 = 0 ;
11786 int res1 = 0 ;
11787 PyObject *swig_obj[1] ;
11788
11789 if (!args) SWIG_fail;
11790 swig_obj[0] = args;
11791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11792 if (!SWIG_IsOK(res1)) {
11793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11794 }
11795 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 {
11803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11804 }
11805 return resultobj;
11806 fail:
11807 return NULL;
11808 }
11809
11810
11811 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11812 PyObject *resultobj = 0;
11813 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11814 int result;
11815 void *argp1 = 0 ;
11816 int res1 = 0 ;
11817 PyObject *swig_obj[1] ;
11818
11819 if (!args) SWIG_fail;
11820 swig_obj[0] = args;
11821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11822 if (!SWIG_IsOK(res1)) {
11823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11824 }
11825 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11826 {
11827 PyThreadState* __tstate = wxPyBeginAllowThreads();
11828 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11829 wxPyEndAllowThreads(__tstate);
11830 if (PyErr_Occurred()) SWIG_fail;
11831 }
11832 resultobj = SWIG_From_int(static_cast< int >(result));
11833 return resultobj;
11834 fail:
11835 return NULL;
11836 }
11837
11838
11839 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11840 PyObject *resultobj = 0;
11841 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11842 int result;
11843 void *argp1 = 0 ;
11844 int res1 = 0 ;
11845 PyObject *swig_obj[1] ;
11846
11847 if (!args) SWIG_fail;
11848 swig_obj[0] = args;
11849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11850 if (!SWIG_IsOK(res1)) {
11851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11852 }
11853 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11854 {
11855 PyThreadState* __tstate = wxPyBeginAllowThreads();
11856 result = (int)((wxPyTimer const *)arg1)->GetId();
11857 wxPyEndAllowThreads(__tstate);
11858 if (PyErr_Occurred()) SWIG_fail;
11859 }
11860 resultobj = SWIG_From_int(static_cast< int >(result));
11861 return resultobj;
11862 fail:
11863 return NULL;
11864 }
11865
11866
11867 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11868 PyObject *resultobj = 0;
11869 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11870 bool result;
11871 void *argp1 = 0 ;
11872 int res1 = 0 ;
11873 PyObject *swig_obj[1] ;
11874
11875 if (!args) SWIG_fail;
11876 swig_obj[0] = args;
11877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11878 if (!SWIG_IsOK(res1)) {
11879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11880 }
11881 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11882 {
11883 PyThreadState* __tstate = wxPyBeginAllowThreads();
11884 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11885 wxPyEndAllowThreads(__tstate);
11886 if (PyErr_Occurred()) SWIG_fail;
11887 }
11888 {
11889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11890 }
11891 return resultobj;
11892 fail:
11893 return NULL;
11894 }
11895
11896
11897 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11898 PyObject *obj;
11899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11900 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11901 return SWIG_Py_Void();
11902 }
11903
11904 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11905 return SWIG_Python_InitShadowInstance(args);
11906 }
11907
11908 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11909 PyObject *resultobj = 0;
11910 int arg1 = (int) 0 ;
11911 int arg2 = (int) 0 ;
11912 wxTimerEvent *result = 0 ;
11913 int val1 ;
11914 int ecode1 = 0 ;
11915 int val2 ;
11916 int ecode2 = 0 ;
11917 PyObject * obj0 = 0 ;
11918 PyObject * obj1 = 0 ;
11919 char * kwnames[] = {
11920 (char *) "timerid",(char *) "interval", NULL
11921 };
11922
11923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11924 if (obj0) {
11925 ecode1 = SWIG_AsVal_int(obj0, &val1);
11926 if (!SWIG_IsOK(ecode1)) {
11927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11928 }
11929 arg1 = static_cast< int >(val1);
11930 }
11931 if (obj1) {
11932 ecode2 = SWIG_AsVal_int(obj1, &val2);
11933 if (!SWIG_IsOK(ecode2)) {
11934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11935 }
11936 arg2 = static_cast< int >(val2);
11937 }
11938 {
11939 PyThreadState* __tstate = wxPyBeginAllowThreads();
11940 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11941 wxPyEndAllowThreads(__tstate);
11942 if (PyErr_Occurred()) SWIG_fail;
11943 }
11944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11952 PyObject *resultobj = 0;
11953 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11954 int result;
11955 void *argp1 = 0 ;
11956 int res1 = 0 ;
11957 PyObject *swig_obj[1] ;
11958
11959 if (!args) SWIG_fail;
11960 swig_obj[0] = args;
11961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11962 if (!SWIG_IsOK(res1)) {
11963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11964 }
11965 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 resultobj = SWIG_From_int(static_cast< int >(result));
11973 return resultobj;
11974 fail:
11975 return NULL;
11976 }
11977
11978
11979 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11980 PyObject *obj;
11981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11982 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11983 return SWIG_Py_Void();
11984 }
11985
11986 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11987 return SWIG_Python_InitShadowInstance(args);
11988 }
11989
11990 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11991 PyObject *resultobj = 0;
11992 wxTimer *arg1 = 0 ;
11993 wxTimerRunner *result = 0 ;
11994 void *argp1 = 0 ;
11995 int res1 = 0 ;
11996
11997 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11999 if (!SWIG_IsOK(res1)) {
12000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12001 }
12002 if (!argp1) {
12003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12004 }
12005 arg1 = reinterpret_cast< wxTimer * >(argp1);
12006 {
12007 if (!wxPyCheckForApp()) SWIG_fail;
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12014 return resultobj;
12015 fail:
12016 return NULL;
12017 }
12018
12019
12020 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12021 PyObject *resultobj = 0;
12022 wxTimer *arg1 = 0 ;
12023 int arg2 ;
12024 bool arg3 = (bool) false ;
12025 wxTimerRunner *result = 0 ;
12026 void *argp1 = 0 ;
12027 int res1 = 0 ;
12028 int val2 ;
12029 int ecode2 = 0 ;
12030 bool val3 ;
12031 int ecode3 = 0 ;
12032
12033 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12035 if (!SWIG_IsOK(res1)) {
12036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12037 }
12038 if (!argp1) {
12039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12040 }
12041 arg1 = reinterpret_cast< wxTimer * >(argp1);
12042 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12043 if (!SWIG_IsOK(ecode2)) {
12044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12045 }
12046 arg2 = static_cast< int >(val2);
12047 if (swig_obj[2]) {
12048 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12049 if (!SWIG_IsOK(ecode3)) {
12050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12051 }
12052 arg3 = static_cast< bool >(val3);
12053 }
12054 {
12055 if (!wxPyCheckForApp()) SWIG_fail;
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12058 wxPyEndAllowThreads(__tstate);
12059 if (PyErr_Occurred()) SWIG_fail;
12060 }
12061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12062 return resultobj;
12063 fail:
12064 return NULL;
12065 }
12066
12067
12068 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12069 int argc;
12070 PyObject *argv[4];
12071
12072 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12073 --argc;
12074 if (argc == 1) {
12075 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12076 }
12077 if ((argc >= 2) && (argc <= 3)) {
12078 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12079 }
12080
12081 fail:
12082 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12083 return NULL;
12084 }
12085
12086
12087 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12088 PyObject *resultobj = 0;
12089 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12090 void *argp1 = 0 ;
12091 int res1 = 0 ;
12092 PyObject *swig_obj[1] ;
12093
12094 if (!args) SWIG_fail;
12095 swig_obj[0] = args;
12096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12097 if (!SWIG_IsOK(res1)) {
12098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12099 }
12100 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12101 {
12102 PyThreadState* __tstate = wxPyBeginAllowThreads();
12103 delete arg1;
12104
12105 wxPyEndAllowThreads(__tstate);
12106 if (PyErr_Occurred()) SWIG_fail;
12107 }
12108 resultobj = SWIG_Py_Void();
12109 return resultobj;
12110 fail:
12111 return NULL;
12112 }
12113
12114
12115 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12116 PyObject *resultobj = 0;
12117 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12118 int arg2 ;
12119 bool arg3 = (bool) false ;
12120 void *argp1 = 0 ;
12121 int res1 = 0 ;
12122 int val2 ;
12123 int ecode2 = 0 ;
12124 bool val3 ;
12125 int ecode3 = 0 ;
12126 PyObject * obj0 = 0 ;
12127 PyObject * obj1 = 0 ;
12128 PyObject * obj2 = 0 ;
12129 char * kwnames[] = {
12130 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12131 };
12132
12133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12135 if (!SWIG_IsOK(res1)) {
12136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12137 }
12138 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12139 ecode2 = SWIG_AsVal_int(obj1, &val2);
12140 if (!SWIG_IsOK(ecode2)) {
12141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12142 }
12143 arg2 = static_cast< int >(val2);
12144 if (obj2) {
12145 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12146 if (!SWIG_IsOK(ecode3)) {
12147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12148 }
12149 arg3 = static_cast< bool >(val3);
12150 }
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 (arg1)->Start(arg2,arg3);
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 resultobj = SWIG_Py_Void();
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12165 PyObject *obj;
12166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12167 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12168 return SWIG_Py_Void();
12169 }
12170
12171 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 return SWIG_Python_InitShadowInstance(args);
12173 }
12174
12175 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12176 PyObject *resultobj = 0;
12177 wxLog *result = 0 ;
12178
12179 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12180 {
12181 PyThreadState* __tstate = wxPyBeginAllowThreads();
12182 result = (wxLog *)new wxLog();
12183 wxPyEndAllowThreads(__tstate);
12184 if (PyErr_Occurred()) SWIG_fail;
12185 }
12186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12187 return resultobj;
12188 fail:
12189 return NULL;
12190 }
12191
12192
12193 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12194 PyObject *resultobj = 0;
12195 wxLog *arg1 = (wxLog *) 0 ;
12196 void *argp1 = 0 ;
12197 int res1 = 0 ;
12198 PyObject *swig_obj[1] ;
12199
12200 if (!args) SWIG_fail;
12201 swig_obj[0] = args;
12202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12203 if (!SWIG_IsOK(res1)) {
12204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12205 }
12206 arg1 = reinterpret_cast< wxLog * >(argp1);
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 delete arg1;
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 resultobj = SWIG_Py_Void();
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12222 PyObject *resultobj = 0;
12223 bool result;
12224
12225 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12226 {
12227 PyThreadState* __tstate = wxPyBeginAllowThreads();
12228 result = (bool)wxLog::IsEnabled();
12229 wxPyEndAllowThreads(__tstate);
12230 if (PyErr_Occurred()) SWIG_fail;
12231 }
12232 {
12233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12234 }
12235 return resultobj;
12236 fail:
12237 return NULL;
12238 }
12239
12240
12241 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj = 0;
12243 bool arg1 = (bool) true ;
12244 bool result;
12245 bool val1 ;
12246 int ecode1 = 0 ;
12247 PyObject * obj0 = 0 ;
12248 char * kwnames[] = {
12249 (char *) "doIt", NULL
12250 };
12251
12252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12253 if (obj0) {
12254 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12255 if (!SWIG_IsOK(ecode1)) {
12256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12257 }
12258 arg1 = static_cast< bool >(val1);
12259 }
12260 {
12261 PyThreadState* __tstate = wxPyBeginAllowThreads();
12262 result = (bool)wxLog::EnableLogging(arg1);
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 {
12267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12268 }
12269 return resultobj;
12270 fail:
12271 return NULL;
12272 }
12273
12274
12275 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12276 PyObject *resultobj = 0;
12277 wxLogLevel arg1 ;
12278 wxChar *arg2 = (wxChar *) 0 ;
12279 time_t arg3 ;
12280 unsigned long val1 ;
12281 int ecode1 = 0 ;
12282 void *argp2 = 0 ;
12283 int res2 = 0 ;
12284 unsigned int val3 ;
12285 int ecode3 = 0 ;
12286 PyObject * obj0 = 0 ;
12287 PyObject * obj1 = 0 ;
12288 PyObject * obj2 = 0 ;
12289 char * kwnames[] = {
12290 (char *) "level",(char *) "szString",(char *) "t", NULL
12291 };
12292
12293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12294 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12295 if (!SWIG_IsOK(ecode1)) {
12296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12297 }
12298 arg1 = static_cast< wxLogLevel >(val1);
12299 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12300 if (!SWIG_IsOK(res2)) {
12301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12302 }
12303 arg2 = reinterpret_cast< wxChar * >(argp2);
12304 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12305 if (!SWIG_IsOK(ecode3)) {
12306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12307 }
12308 arg3 = static_cast< time_t >(val3);
12309 {
12310 PyThreadState* __tstate = wxPyBeginAllowThreads();
12311 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12312 wxPyEndAllowThreads(__tstate);
12313 if (PyErr_Occurred()) SWIG_fail;
12314 }
12315 resultobj = SWIG_Py_Void();
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12323 PyObject *resultobj = 0;
12324 wxLog *arg1 = (wxLog *) 0 ;
12325 void *argp1 = 0 ;
12326 int res1 = 0 ;
12327 PyObject *swig_obj[1] ;
12328
12329 if (!args) SWIG_fail;
12330 swig_obj[0] = args;
12331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12332 if (!SWIG_IsOK(res1)) {
12333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12334 }
12335 arg1 = reinterpret_cast< wxLog * >(argp1);
12336 {
12337 PyThreadState* __tstate = wxPyBeginAllowThreads();
12338 (arg1)->Flush();
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 resultobj = SWIG_Py_Void();
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12350 PyObject *resultobj = 0;
12351
12352 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12353 {
12354 PyThreadState* __tstate = wxPyBeginAllowThreads();
12355 wxLog::FlushActive();
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 resultobj = SWIG_Py_Void();
12360 return resultobj;
12361 fail:
12362 return NULL;
12363 }
12364
12365
12366 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12367 PyObject *resultobj = 0;
12368 wxLog *result = 0 ;
12369
12370 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 result = (wxLog *)wxLog::GetActiveTarget();
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12378 return resultobj;
12379 fail:
12380 return NULL;
12381 }
12382
12383
12384 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj = 0;
12386 wxLog *arg1 = (wxLog *) 0 ;
12387 wxLog *result = 0 ;
12388 int res1 = 0 ;
12389 PyObject * obj0 = 0 ;
12390 char * kwnames[] = {
12391 (char *) "pLogger", NULL
12392 };
12393
12394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12395 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12396 if (!SWIG_IsOK(res1)) {
12397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12398 }
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12406 return resultobj;
12407 fail:
12408 return NULL;
12409 }
12410
12411
12412 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12413 PyObject *resultobj = 0;
12414
12415 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 wxLog::Suspend();
12419 wxPyEndAllowThreads(__tstate);
12420 if (PyErr_Occurred()) SWIG_fail;
12421 }
12422 resultobj = SWIG_Py_Void();
12423 return resultobj;
12424 fail:
12425 return NULL;
12426 }
12427
12428
12429 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12430 PyObject *resultobj = 0;
12431
12432 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 wxLog::Resume();
12436 wxPyEndAllowThreads(__tstate);
12437 if (PyErr_Occurred()) SWIG_fail;
12438 }
12439 resultobj = SWIG_Py_Void();
12440 return resultobj;
12441 fail:
12442 return NULL;
12443 }
12444
12445
12446 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12447 PyObject *resultobj = 0;
12448 bool arg1 = (bool) true ;
12449 bool val1 ;
12450 int ecode1 = 0 ;
12451 PyObject * obj0 = 0 ;
12452 char * kwnames[] = {
12453 (char *) "bVerbose", NULL
12454 };
12455
12456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12457 if (obj0) {
12458 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12459 if (!SWIG_IsOK(ecode1)) {
12460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12461 }
12462 arg1 = static_cast< bool >(val1);
12463 }
12464 {
12465 PyThreadState* __tstate = wxPyBeginAllowThreads();
12466 wxLog::SetVerbose(arg1);
12467 wxPyEndAllowThreads(__tstate);
12468 if (PyErr_Occurred()) SWIG_fail;
12469 }
12470 resultobj = SWIG_Py_Void();
12471 return resultobj;
12472 fail:
12473 return NULL;
12474 }
12475
12476
12477 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12478 PyObject *resultobj = 0;
12479 wxLogLevel arg1 ;
12480 unsigned long val1 ;
12481 int ecode1 = 0 ;
12482 PyObject * obj0 = 0 ;
12483 char * kwnames[] = {
12484 (char *) "logLevel", NULL
12485 };
12486
12487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12488 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12489 if (!SWIG_IsOK(ecode1)) {
12490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12491 }
12492 arg1 = static_cast< wxLogLevel >(val1);
12493 {
12494 PyThreadState* __tstate = wxPyBeginAllowThreads();
12495 wxLog::SetLogLevel(arg1);
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 resultobj = SWIG_Py_Void();
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12507 PyObject *resultobj = 0;
12508
12509 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 wxLog::DontCreateOnDemand();
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 resultobj = SWIG_Py_Void();
12517 return resultobj;
12518 fail:
12519 return NULL;
12520 }
12521
12522
12523 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12524 PyObject *resultobj = 0;
12525 bool arg1 = (bool) true ;
12526 bool val1 ;
12527 int ecode1 = 0 ;
12528 PyObject * obj0 = 0 ;
12529 char * kwnames[] = {
12530 (char *) "bRepetCounting", NULL
12531 };
12532
12533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12534 if (obj0) {
12535 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12536 if (!SWIG_IsOK(ecode1)) {
12537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12538 }
12539 arg1 = static_cast< bool >(val1);
12540 }
12541 {
12542 PyThreadState* __tstate = wxPyBeginAllowThreads();
12543 wxLog::SetRepetitionCounting(arg1);
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 resultobj = SWIG_Py_Void();
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12555 PyObject *resultobj = 0;
12556 bool result;
12557
12558 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (bool)wxLog::GetRepetitionCounting();
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 {
12566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12567 }
12568 return resultobj;
12569 fail:
12570 return NULL;
12571 }
12572
12573
12574 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12575 PyObject *resultobj = 0;
12576 wxTraceMask arg1 ;
12577 unsigned long val1 ;
12578 int ecode1 = 0 ;
12579 PyObject * obj0 = 0 ;
12580 char * kwnames[] = {
12581 (char *) "ulMask", NULL
12582 };
12583
12584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12585 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12586 if (!SWIG_IsOK(ecode1)) {
12587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12588 }
12589 arg1 = static_cast< wxTraceMask >(val1);
12590 {
12591 PyThreadState* __tstate = wxPyBeginAllowThreads();
12592 wxLog::SetTraceMask(arg1);
12593 wxPyEndAllowThreads(__tstate);
12594 if (PyErr_Occurred()) SWIG_fail;
12595 }
12596 resultobj = SWIG_Py_Void();
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12604 PyObject *resultobj = 0;
12605 wxString *arg1 = 0 ;
12606 bool temp1 = false ;
12607 PyObject * obj0 = 0 ;
12608 char * kwnames[] = {
12609 (char *) "str", NULL
12610 };
12611
12612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12613 {
12614 arg1 = wxString_in_helper(obj0);
12615 if (arg1 == NULL) SWIG_fail;
12616 temp1 = true;
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 wxLog::AddTraceMask((wxString const &)*arg1);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 resultobj = SWIG_Py_Void();
12625 {
12626 if (temp1)
12627 delete arg1;
12628 }
12629 return resultobj;
12630 fail:
12631 {
12632 if (temp1)
12633 delete arg1;
12634 }
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj = 0;
12641 wxString *arg1 = 0 ;
12642 bool temp1 = false ;
12643 PyObject * obj0 = 0 ;
12644 char * kwnames[] = {
12645 (char *) "str", NULL
12646 };
12647
12648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12649 {
12650 arg1 = wxString_in_helper(obj0);
12651 if (arg1 == NULL) SWIG_fail;
12652 temp1 = true;
12653 }
12654 {
12655 PyThreadState* __tstate = wxPyBeginAllowThreads();
12656 wxLog::RemoveTraceMask((wxString const &)*arg1);
12657 wxPyEndAllowThreads(__tstate);
12658 if (PyErr_Occurred()) SWIG_fail;
12659 }
12660 resultobj = SWIG_Py_Void();
12661 {
12662 if (temp1)
12663 delete arg1;
12664 }
12665 return resultobj;
12666 fail:
12667 {
12668 if (temp1)
12669 delete arg1;
12670 }
12671 return NULL;
12672 }
12673
12674
12675 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12676 PyObject *resultobj = 0;
12677
12678 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 wxLog::ClearTraceMasks();
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 resultobj = SWIG_Py_Void();
12686 return resultobj;
12687 fail:
12688 return NULL;
12689 }
12690
12691
12692 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12693 PyObject *resultobj = 0;
12694 wxArrayString *result = 0 ;
12695
12696 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12697 {
12698 PyThreadState* __tstate = wxPyBeginAllowThreads();
12699 {
12700 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12701 result = (wxArrayString *) &_result_ref;
12702 }
12703 wxPyEndAllowThreads(__tstate);
12704 if (PyErr_Occurred()) SWIG_fail;
12705 }
12706 {
12707 resultobj = wxArrayString2PyList_helper(*result);
12708 }
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj = 0;
12717 wxChar *arg1 = (wxChar *) 0 ;
12718 void *argp1 = 0 ;
12719 int res1 = 0 ;
12720 PyObject * obj0 = 0 ;
12721 char * kwnames[] = {
12722 (char *) "ts", NULL
12723 };
12724
12725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12727 if (!SWIG_IsOK(res1)) {
12728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12729 }
12730 arg1 = reinterpret_cast< wxChar * >(argp1);
12731 {
12732 PyThreadState* __tstate = wxPyBeginAllowThreads();
12733 wxLog::SetTimestamp((wxChar const *)arg1);
12734 wxPyEndAllowThreads(__tstate);
12735 if (PyErr_Occurred()) SWIG_fail;
12736 }
12737 resultobj = SWIG_Py_Void();
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12745 PyObject *resultobj = 0;
12746 bool result;
12747
12748 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 result = (bool)wxLog::GetVerbose();
12752 wxPyEndAllowThreads(__tstate);
12753 if (PyErr_Occurred()) SWIG_fail;
12754 }
12755 {
12756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12757 }
12758 return resultobj;
12759 fail:
12760 return NULL;
12761 }
12762
12763
12764 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12765 PyObject *resultobj = 0;
12766 wxTraceMask result;
12767
12768 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12769 {
12770 PyThreadState* __tstate = wxPyBeginAllowThreads();
12771 result = (wxTraceMask)wxLog::GetTraceMask();
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12776 return resultobj;
12777 fail:
12778 return NULL;
12779 }
12780
12781
12782 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12783 PyObject *resultobj = 0;
12784 wxChar *arg1 = (wxChar *) 0 ;
12785 bool result;
12786 void *argp1 = 0 ;
12787 int res1 = 0 ;
12788 PyObject * obj0 = 0 ;
12789 char * kwnames[] = {
12790 (char *) "mask", NULL
12791 };
12792
12793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12795 if (!SWIG_IsOK(res1)) {
12796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12797 }
12798 arg1 = reinterpret_cast< wxChar * >(argp1);
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 {
12806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12807 }
12808 return resultobj;
12809 fail:
12810 return NULL;
12811 }
12812
12813
12814 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12815 PyObject *resultobj = 0;
12816 wxLogLevel result;
12817
12818 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12819 {
12820 PyThreadState* __tstate = wxPyBeginAllowThreads();
12821 result = (wxLogLevel)wxLog::GetLogLevel();
12822 wxPyEndAllowThreads(__tstate);
12823 if (PyErr_Occurred()) SWIG_fail;
12824 }
12825 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12833 PyObject *resultobj = 0;
12834 wxChar *result = 0 ;
12835
12836 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12837 {
12838 PyThreadState* __tstate = wxPyBeginAllowThreads();
12839 result = (wxChar *)wxLog::GetTimestamp();
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12844 return resultobj;
12845 fail:
12846 return NULL;
12847 }
12848
12849
12850 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12851 PyObject *resultobj = 0;
12852 wxString result;
12853
12854 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12855 {
12856 PyThreadState* __tstate = wxPyBeginAllowThreads();
12857 result = wxLog_TimeStamp();
12858 wxPyEndAllowThreads(__tstate);
12859 if (PyErr_Occurred()) SWIG_fail;
12860 }
12861 {
12862 #if wxUSE_UNICODE
12863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12864 #else
12865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12866 #endif
12867 }
12868 return resultobj;
12869 fail:
12870 return NULL;
12871 }
12872
12873
12874 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12875 PyObject *resultobj = 0;
12876 wxLog *arg1 = (wxLog *) 0 ;
12877 void *argp1 = 0 ;
12878 int res1 = 0 ;
12879 PyObject *swig_obj[1] ;
12880
12881 if (!args) SWIG_fail;
12882 swig_obj[0] = args;
12883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12884 if (!SWIG_IsOK(res1)) {
12885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12886 }
12887 arg1 = reinterpret_cast< wxLog * >(argp1);
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 wxLog_Destroy(arg1);
12891 wxPyEndAllowThreads(__tstate);
12892 if (PyErr_Occurred()) SWIG_fail;
12893 }
12894 resultobj = SWIG_Py_Void();
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12902 PyObject *obj;
12903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12904 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12905 return SWIG_Py_Void();
12906 }
12907
12908 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 return SWIG_Python_InitShadowInstance(args);
12910 }
12911
12912 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 PyObject *resultobj = 0;
12914 wxLogStderr *result = 0 ;
12915
12916 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12917 {
12918 PyThreadState* __tstate = wxPyBeginAllowThreads();
12919 result = (wxLogStderr *)new wxLogStderr();
12920 wxPyEndAllowThreads(__tstate);
12921 if (PyErr_Occurred()) SWIG_fail;
12922 }
12923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12924 return resultobj;
12925 fail:
12926 return NULL;
12927 }
12928
12929
12930 SWIGINTERN PyObject *LogStderr_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_wxLogStderr, SWIG_NewClientData(obj));
12934 return SWIG_Py_Void();
12935 }
12936
12937 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 return SWIG_Python_InitShadowInstance(args);
12939 }
12940
12941 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12942 PyObject *resultobj = 0;
12943 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12944 wxLogTextCtrl *result = 0 ;
12945 void *argp1 = 0 ;
12946 int res1 = 0 ;
12947 PyObject * obj0 = 0 ;
12948 char * kwnames[] = {
12949 (char *) "pTextCtrl", NULL
12950 };
12951
12952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12954 if (!SWIG_IsOK(res1)) {
12955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12956 }
12957 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12965 return resultobj;
12966 fail:
12967 return NULL;
12968 }
12969
12970
12971 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12972 PyObject *obj;
12973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12974 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12975 return SWIG_Py_Void();
12976 }
12977
12978 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12979 return SWIG_Python_InitShadowInstance(args);
12980 }
12981
12982 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12983 PyObject *resultobj = 0;
12984 wxLogGui *result = 0 ;
12985
12986 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12987 {
12988 PyThreadState* __tstate = wxPyBeginAllowThreads();
12989 result = (wxLogGui *)new wxLogGui();
12990 wxPyEndAllowThreads(__tstate);
12991 if (PyErr_Occurred()) SWIG_fail;
12992 }
12993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12994 return resultobj;
12995 fail:
12996 return NULL;
12997 }
12998
12999
13000 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13001 PyObject *obj;
13002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13003 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
13004 return SWIG_Py_Void();
13005 }
13006
13007 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 return SWIG_Python_InitShadowInstance(args);
13009 }
13010
13011 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13012 PyObject *resultobj = 0;
13013 wxFrame *arg1 = (wxFrame *) 0 ;
13014 wxString *arg2 = 0 ;
13015 bool arg3 = (bool) true ;
13016 bool arg4 = (bool) true ;
13017 wxLogWindow *result = 0 ;
13018 void *argp1 = 0 ;
13019 int res1 = 0 ;
13020 bool temp2 = false ;
13021 bool val3 ;
13022 int ecode3 = 0 ;
13023 bool val4 ;
13024 int ecode4 = 0 ;
13025 PyObject * obj0 = 0 ;
13026 PyObject * obj1 = 0 ;
13027 PyObject * obj2 = 0 ;
13028 PyObject * obj3 = 0 ;
13029 char * kwnames[] = {
13030 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13031 };
13032
13033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13035 if (!SWIG_IsOK(res1)) {
13036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13037 }
13038 arg1 = reinterpret_cast< wxFrame * >(argp1);
13039 {
13040 arg2 = wxString_in_helper(obj1);
13041 if (arg2 == NULL) SWIG_fail;
13042 temp2 = true;
13043 }
13044 if (obj2) {
13045 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13046 if (!SWIG_IsOK(ecode3)) {
13047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13048 }
13049 arg3 = static_cast< bool >(val3);
13050 }
13051 if (obj3) {
13052 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13053 if (!SWIG_IsOK(ecode4)) {
13054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13055 }
13056 arg4 = static_cast< bool >(val4);
13057 }
13058 {
13059 PyThreadState* __tstate = wxPyBeginAllowThreads();
13060 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13061 wxPyEndAllowThreads(__tstate);
13062 if (PyErr_Occurred()) SWIG_fail;
13063 }
13064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13065 {
13066 if (temp2)
13067 delete arg2;
13068 }
13069 return resultobj;
13070 fail:
13071 {
13072 if (temp2)
13073 delete arg2;
13074 }
13075 return NULL;
13076 }
13077
13078
13079 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13080 PyObject *resultobj = 0;
13081 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13082 bool arg2 = (bool) true ;
13083 void *argp1 = 0 ;
13084 int res1 = 0 ;
13085 bool val2 ;
13086 int ecode2 = 0 ;
13087 PyObject * obj0 = 0 ;
13088 PyObject * obj1 = 0 ;
13089 char * kwnames[] = {
13090 (char *) "self",(char *) "bShow", NULL
13091 };
13092
13093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13095 if (!SWIG_IsOK(res1)) {
13096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13097 }
13098 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13099 if (obj1) {
13100 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13101 if (!SWIG_IsOK(ecode2)) {
13102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13103 }
13104 arg2 = static_cast< bool >(val2);
13105 }
13106 {
13107 PyThreadState* __tstate = wxPyBeginAllowThreads();
13108 (arg1)->Show(arg2);
13109 wxPyEndAllowThreads(__tstate);
13110 if (PyErr_Occurred()) SWIG_fail;
13111 }
13112 resultobj = SWIG_Py_Void();
13113 return resultobj;
13114 fail:
13115 return NULL;
13116 }
13117
13118
13119 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13120 PyObject *resultobj = 0;
13121 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13122 wxFrame *result = 0 ;
13123 void *argp1 = 0 ;
13124 int res1 = 0 ;
13125 PyObject *swig_obj[1] ;
13126
13127 if (!args) SWIG_fail;
13128 swig_obj[0] = args;
13129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13130 if (!SWIG_IsOK(res1)) {
13131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13132 }
13133 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13137 wxPyEndAllowThreads(__tstate);
13138 if (PyErr_Occurred()) SWIG_fail;
13139 }
13140 {
13141 resultobj = wxPyMake_wxObject(result, (bool)0);
13142 }
13143 return resultobj;
13144 fail:
13145 return NULL;
13146 }
13147
13148
13149 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13150 PyObject *resultobj = 0;
13151 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13152 wxLog *result = 0 ;
13153 void *argp1 = 0 ;
13154 int res1 = 0 ;
13155 PyObject *swig_obj[1] ;
13156
13157 if (!args) SWIG_fail;
13158 swig_obj[0] = args;
13159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13162 }
13163 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13178 PyObject *resultobj = 0;
13179 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13180 bool result;
13181 void *argp1 = 0 ;
13182 int res1 = 0 ;
13183 PyObject *swig_obj[1] ;
13184
13185 if (!args) SWIG_fail;
13186 swig_obj[0] = args;
13187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13188 if (!SWIG_IsOK(res1)) {
13189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13190 }
13191 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13192 {
13193 PyThreadState* __tstate = wxPyBeginAllowThreads();
13194 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13195 wxPyEndAllowThreads(__tstate);
13196 if (PyErr_Occurred()) SWIG_fail;
13197 }
13198 {
13199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13200 }
13201 return resultobj;
13202 fail:
13203 return NULL;
13204 }
13205
13206
13207 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13208 PyObject *resultobj = 0;
13209 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13210 bool arg2 ;
13211 void *argp1 = 0 ;
13212 int res1 = 0 ;
13213 bool val2 ;
13214 int ecode2 = 0 ;
13215 PyObject * obj0 = 0 ;
13216 PyObject * obj1 = 0 ;
13217 char * kwnames[] = {
13218 (char *) "self",(char *) "bDoPass", NULL
13219 };
13220
13221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13223 if (!SWIG_IsOK(res1)) {
13224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13225 }
13226 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13227 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13228 if (!SWIG_IsOK(ecode2)) {
13229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13230 }
13231 arg2 = static_cast< bool >(val2);
13232 {
13233 PyThreadState* __tstate = wxPyBeginAllowThreads();
13234 (arg1)->PassMessages(arg2);
13235 wxPyEndAllowThreads(__tstate);
13236 if (PyErr_Occurred()) SWIG_fail;
13237 }
13238 resultobj = SWIG_Py_Void();
13239 return resultobj;
13240 fail:
13241 return NULL;
13242 }
13243
13244
13245 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13246 PyObject *obj;
13247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13248 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13249 return SWIG_Py_Void();
13250 }
13251
13252 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13253 return SWIG_Python_InitShadowInstance(args);
13254 }
13255
13256 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj = 0;
13258 wxLog *arg1 = (wxLog *) 0 ;
13259 wxLogChain *result = 0 ;
13260 void *argp1 = 0 ;
13261 int res1 = 0 ;
13262 PyObject * obj0 = 0 ;
13263 char * kwnames[] = {
13264 (char *) "logger", NULL
13265 };
13266
13267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13269 if (!SWIG_IsOK(res1)) {
13270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13271 }
13272 arg1 = reinterpret_cast< wxLog * >(argp1);
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 result = (wxLogChain *)new wxLogChain(arg1);
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13287 PyObject *resultobj = 0;
13288 wxLogChain *arg1 = (wxLogChain *) 0 ;
13289 wxLog *arg2 = (wxLog *) 0 ;
13290 void *argp1 = 0 ;
13291 int res1 = 0 ;
13292 void *argp2 = 0 ;
13293 int res2 = 0 ;
13294 PyObject * obj0 = 0 ;
13295 PyObject * obj1 = 0 ;
13296 char * kwnames[] = {
13297 (char *) "self",(char *) "logger", NULL
13298 };
13299
13300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13302 if (!SWIG_IsOK(res1)) {
13303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13304 }
13305 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13307 if (!SWIG_IsOK(res2)) {
13308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13309 }
13310 arg2 = reinterpret_cast< wxLog * >(argp2);
13311 {
13312 PyThreadState* __tstate = wxPyBeginAllowThreads();
13313 (arg1)->SetLog(arg2);
13314 wxPyEndAllowThreads(__tstate);
13315 if (PyErr_Occurred()) SWIG_fail;
13316 }
13317 resultobj = SWIG_Py_Void();
13318 return resultobj;
13319 fail:
13320 return NULL;
13321 }
13322
13323
13324 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13325 PyObject *resultobj = 0;
13326 wxLogChain *arg1 = (wxLogChain *) 0 ;
13327 bool arg2 ;
13328 void *argp1 = 0 ;
13329 int res1 = 0 ;
13330 bool val2 ;
13331 int ecode2 = 0 ;
13332 PyObject * obj0 = 0 ;
13333 PyObject * obj1 = 0 ;
13334 char * kwnames[] = {
13335 (char *) "self",(char *) "bDoPass", NULL
13336 };
13337
13338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13340 if (!SWIG_IsOK(res1)) {
13341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13342 }
13343 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13344 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13345 if (!SWIG_IsOK(ecode2)) {
13346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13347 }
13348 arg2 = static_cast< bool >(val2);
13349 {
13350 PyThreadState* __tstate = wxPyBeginAllowThreads();
13351 (arg1)->PassMessages(arg2);
13352 wxPyEndAllowThreads(__tstate);
13353 if (PyErr_Occurred()) SWIG_fail;
13354 }
13355 resultobj = SWIG_Py_Void();
13356 return resultobj;
13357 fail:
13358 return NULL;
13359 }
13360
13361
13362 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13363 PyObject *resultobj = 0;
13364 wxLogChain *arg1 = (wxLogChain *) 0 ;
13365 bool result;
13366 void *argp1 = 0 ;
13367 int res1 = 0 ;
13368 PyObject *swig_obj[1] ;
13369
13370 if (!args) SWIG_fail;
13371 swig_obj[0] = args;
13372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13373 if (!SWIG_IsOK(res1)) {
13374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13375 }
13376 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 result = (bool)(arg1)->IsPassingMessages();
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 {
13384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13385 }
13386 return resultobj;
13387 fail:
13388 return NULL;
13389 }
13390
13391
13392 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13393 PyObject *resultobj = 0;
13394 wxLogChain *arg1 = (wxLogChain *) 0 ;
13395 wxLog *result = 0 ;
13396 void *argp1 = 0 ;
13397 int res1 = 0 ;
13398 PyObject *swig_obj[1] ;
13399
13400 if (!args) SWIG_fail;
13401 swig_obj[0] = args;
13402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13403 if (!SWIG_IsOK(res1)) {
13404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13405 }
13406 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13407 {
13408 PyThreadState* __tstate = wxPyBeginAllowThreads();
13409 result = (wxLog *)(arg1)->GetOldLog();
13410 wxPyEndAllowThreads(__tstate);
13411 if (PyErr_Occurred()) SWIG_fail;
13412 }
13413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13414 return resultobj;
13415 fail:
13416 return NULL;
13417 }
13418
13419
13420 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13421 PyObject *obj;
13422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13423 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13424 return SWIG_Py_Void();
13425 }
13426
13427 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13428 return SWIG_Python_InitShadowInstance(args);
13429 }
13430
13431 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432 PyObject *resultobj = 0;
13433 wxLogBuffer *result = 0 ;
13434
13435 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (wxLogBuffer *)new wxLogBuffer();
13439 wxPyEndAllowThreads(__tstate);
13440 if (PyErr_Occurred()) SWIG_fail;
13441 }
13442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13443 return resultobj;
13444 fail:
13445 return NULL;
13446 }
13447
13448
13449 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13450 PyObject *resultobj = 0;
13451 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13452 wxString *result = 0 ;
13453 void *argp1 = 0 ;
13454 int res1 = 0 ;
13455 PyObject *swig_obj[1] ;
13456
13457 if (!args) SWIG_fail;
13458 swig_obj[0] = args;
13459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13460 if (!SWIG_IsOK(res1)) {
13461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13462 }
13463 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 {
13467 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13468 result = (wxString *) &_result_ref;
13469 }
13470 wxPyEndAllowThreads(__tstate);
13471 if (PyErr_Occurred()) SWIG_fail;
13472 }
13473 {
13474 #if wxUSE_UNICODE
13475 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13476 #else
13477 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13478 #endif
13479 }
13480 return resultobj;
13481 fail:
13482 return NULL;
13483 }
13484
13485
13486 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13487 PyObject *obj;
13488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13489 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13490 return SWIG_Py_Void();
13491 }
13492
13493 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13494 return SWIG_Python_InitShadowInstance(args);
13495 }
13496
13497 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13498 PyObject *resultobj = 0;
13499 unsigned long result;
13500
13501 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 result = (unsigned long)wxSysErrorCode();
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13509 return resultobj;
13510 fail:
13511 return NULL;
13512 }
13513
13514
13515 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13516 PyObject *resultobj = 0;
13517 unsigned long arg1 = (unsigned long) 0 ;
13518 wxString result;
13519 unsigned long val1 ;
13520 int ecode1 = 0 ;
13521 PyObject * obj0 = 0 ;
13522 char * kwnames[] = {
13523 (char *) "nErrCode", NULL
13524 };
13525
13526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13527 if (obj0) {
13528 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13529 if (!SWIG_IsOK(ecode1)) {
13530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13531 }
13532 arg1 = static_cast< unsigned long >(val1);
13533 }
13534 {
13535 PyThreadState* __tstate = wxPyBeginAllowThreads();
13536 result = wxSysErrorMsg(arg1);
13537 wxPyEndAllowThreads(__tstate);
13538 if (PyErr_Occurred()) SWIG_fail;
13539 }
13540 {
13541 #if wxUSE_UNICODE
13542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13543 #else
13544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13545 #endif
13546 }
13547 return resultobj;
13548 fail:
13549 return NULL;
13550 }
13551
13552
13553 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj = 0;
13555 wxString *arg1 = 0 ;
13556 bool temp1 = false ;
13557 PyObject * obj0 = 0 ;
13558 char * kwnames[] = {
13559 (char *) "msg", NULL
13560 };
13561
13562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13563 {
13564 arg1 = wxString_in_helper(obj0);
13565 if (arg1 == NULL) SWIG_fail;
13566 temp1 = true;
13567 }
13568 {
13569 PyThreadState* __tstate = wxPyBeginAllowThreads();
13570 wxPyLogFatalError((wxString const &)*arg1);
13571 wxPyEndAllowThreads(__tstate);
13572 if (PyErr_Occurred()) SWIG_fail;
13573 }
13574 resultobj = SWIG_Py_Void();
13575 {
13576 if (temp1)
13577 delete arg1;
13578 }
13579 return resultobj;
13580 fail:
13581 {
13582 if (temp1)
13583 delete arg1;
13584 }
13585 return NULL;
13586 }
13587
13588
13589 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13590 PyObject *resultobj = 0;
13591 wxString *arg1 = 0 ;
13592 bool temp1 = false ;
13593 PyObject * obj0 = 0 ;
13594 char * kwnames[] = {
13595 (char *) "msg", NULL
13596 };
13597
13598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13599 {
13600 arg1 = wxString_in_helper(obj0);
13601 if (arg1 == NULL) SWIG_fail;
13602 temp1 = true;
13603 }
13604 {
13605 PyThreadState* __tstate = wxPyBeginAllowThreads();
13606 wxPyLogError((wxString const &)*arg1);
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 resultobj = SWIG_Py_Void();
13611 {
13612 if (temp1)
13613 delete arg1;
13614 }
13615 return resultobj;
13616 fail:
13617 {
13618 if (temp1)
13619 delete arg1;
13620 }
13621 return NULL;
13622 }
13623
13624
13625 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj = 0;
13627 wxString *arg1 = 0 ;
13628 bool temp1 = false ;
13629 PyObject * obj0 = 0 ;
13630 char * kwnames[] = {
13631 (char *) "msg", NULL
13632 };
13633
13634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13635 {
13636 arg1 = wxString_in_helper(obj0);
13637 if (arg1 == NULL) SWIG_fail;
13638 temp1 = true;
13639 }
13640 {
13641 PyThreadState* __tstate = wxPyBeginAllowThreads();
13642 wxPyLogWarning((wxString const &)*arg1);
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 resultobj = SWIG_Py_Void();
13647 {
13648 if (temp1)
13649 delete arg1;
13650 }
13651 return resultobj;
13652 fail:
13653 {
13654 if (temp1)
13655 delete arg1;
13656 }
13657 return NULL;
13658 }
13659
13660
13661 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13662 PyObject *resultobj = 0;
13663 wxString *arg1 = 0 ;
13664 bool temp1 = false ;
13665 PyObject * obj0 = 0 ;
13666 char * kwnames[] = {
13667 (char *) "msg", NULL
13668 };
13669
13670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13671 {
13672 arg1 = wxString_in_helper(obj0);
13673 if (arg1 == NULL) SWIG_fail;
13674 temp1 = true;
13675 }
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 wxPyLogMessage((wxString const &)*arg1);
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_Py_Void();
13683 {
13684 if (temp1)
13685 delete arg1;
13686 }
13687 return resultobj;
13688 fail:
13689 {
13690 if (temp1)
13691 delete arg1;
13692 }
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxString *arg1 = 0 ;
13700 bool temp1 = false ;
13701 PyObject * obj0 = 0 ;
13702 char * kwnames[] = {
13703 (char *) "msg", NULL
13704 };
13705
13706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13707 {
13708 arg1 = wxString_in_helper(obj0);
13709 if (arg1 == NULL) SWIG_fail;
13710 temp1 = true;
13711 }
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 wxPyLogInfo((wxString const &)*arg1);
13715 wxPyEndAllowThreads(__tstate);
13716 if (PyErr_Occurred()) SWIG_fail;
13717 }
13718 resultobj = SWIG_Py_Void();
13719 {
13720 if (temp1)
13721 delete arg1;
13722 }
13723 return resultobj;
13724 fail:
13725 {
13726 if (temp1)
13727 delete arg1;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj = 0;
13735 wxString *arg1 = 0 ;
13736 bool temp1 = false ;
13737 PyObject * obj0 = 0 ;
13738 char * kwnames[] = {
13739 (char *) "msg", NULL
13740 };
13741
13742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13743 {
13744 arg1 = wxString_in_helper(obj0);
13745 if (arg1 == NULL) SWIG_fail;
13746 temp1 = true;
13747 }
13748 {
13749 PyThreadState* __tstate = wxPyBeginAllowThreads();
13750 wxPyLogDebug((wxString const &)*arg1);
13751 wxPyEndAllowThreads(__tstate);
13752 if (PyErr_Occurred()) SWIG_fail;
13753 }
13754 resultobj = SWIG_Py_Void();
13755 {
13756 if (temp1)
13757 delete arg1;
13758 }
13759 return resultobj;
13760 fail:
13761 {
13762 if (temp1)
13763 delete arg1;
13764 }
13765 return NULL;
13766 }
13767
13768
13769 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj = 0;
13771 wxString *arg1 = 0 ;
13772 bool temp1 = false ;
13773 PyObject * obj0 = 0 ;
13774 char * kwnames[] = {
13775 (char *) "msg", NULL
13776 };
13777
13778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13779 {
13780 arg1 = wxString_in_helper(obj0);
13781 if (arg1 == NULL) SWIG_fail;
13782 temp1 = true;
13783 }
13784 {
13785 PyThreadState* __tstate = wxPyBeginAllowThreads();
13786 wxPyLogVerbose((wxString const &)*arg1);
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 resultobj = SWIG_Py_Void();
13791 {
13792 if (temp1)
13793 delete arg1;
13794 }
13795 return resultobj;
13796 fail:
13797 {
13798 if (temp1)
13799 delete arg1;
13800 }
13801 return NULL;
13802 }
13803
13804
13805 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13806 PyObject *resultobj = 0;
13807 wxString *arg1 = 0 ;
13808 bool temp1 = false ;
13809 PyObject * obj0 = 0 ;
13810 char * kwnames[] = {
13811 (char *) "msg", NULL
13812 };
13813
13814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13815 {
13816 arg1 = wxString_in_helper(obj0);
13817 if (arg1 == NULL) SWIG_fail;
13818 temp1 = true;
13819 }
13820 {
13821 PyThreadState* __tstate = wxPyBeginAllowThreads();
13822 wxPyLogStatus((wxString const &)*arg1);
13823 wxPyEndAllowThreads(__tstate);
13824 if (PyErr_Occurred()) SWIG_fail;
13825 }
13826 resultobj = SWIG_Py_Void();
13827 {
13828 if (temp1)
13829 delete arg1;
13830 }
13831 return resultobj;
13832 fail:
13833 {
13834 if (temp1)
13835 delete arg1;
13836 }
13837 return NULL;
13838 }
13839
13840
13841 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13842 PyObject *resultobj = 0;
13843 wxFrame *arg1 = (wxFrame *) 0 ;
13844 wxString *arg2 = 0 ;
13845 void *argp1 = 0 ;
13846 int res1 = 0 ;
13847 bool temp2 = false ;
13848 PyObject * obj0 = 0 ;
13849 PyObject * obj1 = 0 ;
13850 char * kwnames[] = {
13851 (char *) "pFrame",(char *) "msg", NULL
13852 };
13853
13854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13856 if (!SWIG_IsOK(res1)) {
13857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13858 }
13859 arg1 = reinterpret_cast< wxFrame * >(argp1);
13860 {
13861 arg2 = wxString_in_helper(obj1);
13862 if (arg2 == NULL) SWIG_fail;
13863 temp2 = true;
13864 }
13865 {
13866 PyThreadState* __tstate = wxPyBeginAllowThreads();
13867 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13868 wxPyEndAllowThreads(__tstate);
13869 if (PyErr_Occurred()) SWIG_fail;
13870 }
13871 resultobj = SWIG_Py_Void();
13872 {
13873 if (temp2)
13874 delete arg2;
13875 }
13876 return resultobj;
13877 fail:
13878 {
13879 if (temp2)
13880 delete arg2;
13881 }
13882 return NULL;
13883 }
13884
13885
13886 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj = 0;
13888 wxString *arg1 = 0 ;
13889 bool temp1 = false ;
13890 PyObject * obj0 = 0 ;
13891 char * kwnames[] = {
13892 (char *) "msg", NULL
13893 };
13894
13895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13896 {
13897 arg1 = wxString_in_helper(obj0);
13898 if (arg1 == NULL) SWIG_fail;
13899 temp1 = true;
13900 }
13901 {
13902 PyThreadState* __tstate = wxPyBeginAllowThreads();
13903 wxPyLogSysError((wxString const &)*arg1);
13904 wxPyEndAllowThreads(__tstate);
13905 if (PyErr_Occurred()) SWIG_fail;
13906 }
13907 resultobj = SWIG_Py_Void();
13908 {
13909 if (temp1)
13910 delete arg1;
13911 }
13912 return resultobj;
13913 fail:
13914 {
13915 if (temp1)
13916 delete arg1;
13917 }
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj = 0;
13924 unsigned long arg1 ;
13925 wxString *arg2 = 0 ;
13926 unsigned long val1 ;
13927 int ecode1 = 0 ;
13928 bool temp2 = false ;
13929 PyObject * obj0 = 0 ;
13930 PyObject * obj1 = 0 ;
13931 char * kwnames[] = {
13932 (char *) "level",(char *) "msg", NULL
13933 };
13934
13935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13936 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13937 if (!SWIG_IsOK(ecode1)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13939 }
13940 arg1 = static_cast< unsigned long >(val1);
13941 {
13942 arg2 = wxString_in_helper(obj1);
13943 if (arg2 == NULL) SWIG_fail;
13944 temp2 = true;
13945 }
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_Py_Void();
13953 {
13954 if (temp2)
13955 delete arg2;
13956 }
13957 return resultobj;
13958 fail:
13959 {
13960 if (temp2)
13961 delete arg2;
13962 }
13963 return NULL;
13964 }
13965
13966
13967 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13968 PyObject *resultobj = 0;
13969 unsigned long arg1 ;
13970 wxString *arg2 = 0 ;
13971 unsigned long val1 ;
13972 int ecode1 = 0 ;
13973 bool temp2 = false ;
13974
13975 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13976 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13977 if (!SWIG_IsOK(ecode1)) {
13978 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13979 }
13980 arg1 = static_cast< unsigned long >(val1);
13981 {
13982 arg2 = wxString_in_helper(swig_obj[1]);
13983 if (arg2 == NULL) SWIG_fail;
13984 temp2 = true;
13985 }
13986 {
13987 PyThreadState* __tstate = wxPyBeginAllowThreads();
13988 wxPyLogTrace(arg1,(wxString const &)*arg2);
13989 wxPyEndAllowThreads(__tstate);
13990 if (PyErr_Occurred()) SWIG_fail;
13991 }
13992 resultobj = SWIG_Py_Void();
13993 {
13994 if (temp2)
13995 delete arg2;
13996 }
13997 return resultobj;
13998 fail:
13999 {
14000 if (temp2)
14001 delete arg2;
14002 }
14003 return NULL;
14004 }
14005
14006
14007 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14008 PyObject *resultobj = 0;
14009 wxString *arg1 = 0 ;
14010 wxString *arg2 = 0 ;
14011 bool temp1 = false ;
14012 bool temp2 = false ;
14013
14014 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14015 {
14016 arg1 = wxString_in_helper(swig_obj[0]);
14017 if (arg1 == NULL) SWIG_fail;
14018 temp1 = true;
14019 }
14020 {
14021 arg2 = wxString_in_helper(swig_obj[1]);
14022 if (arg2 == NULL) SWIG_fail;
14023 temp2 = true;
14024 }
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14028 wxPyEndAllowThreads(__tstate);
14029 if (PyErr_Occurred()) SWIG_fail;
14030 }
14031 resultobj = SWIG_Py_Void();
14032 {
14033 if (temp1)
14034 delete arg1;
14035 }
14036 {
14037 if (temp2)
14038 delete arg2;
14039 }
14040 return resultobj;
14041 fail:
14042 {
14043 if (temp1)
14044 delete arg1;
14045 }
14046 {
14047 if (temp2)
14048 delete arg2;
14049 }
14050 return NULL;
14051 }
14052
14053
14054 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14055 int argc;
14056 PyObject *argv[3];
14057
14058 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14059 --argc;
14060 if (argc == 2) {
14061 int _v = 0;
14062 {
14063 {
14064 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14065 }
14066 }
14067 if (!_v) goto check_1;
14068 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14069 }
14070 check_1:
14071
14072 if (argc == 2) {
14073 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14074 }
14075
14076 fail:
14077 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14078 return NULL;
14079 }
14080
14081
14082 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14083 PyObject *resultobj = 0;
14084 wxString *arg1 = 0 ;
14085 wxString *arg2 = 0 ;
14086 bool temp1 = false ;
14087 bool temp2 = false ;
14088 PyObject * obj0 = 0 ;
14089 PyObject * obj1 = 0 ;
14090 char * kwnames[] = {
14091 (char *) "title",(char *) "text", NULL
14092 };
14093
14094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14095 {
14096 arg1 = wxString_in_helper(obj0);
14097 if (arg1 == NULL) SWIG_fail;
14098 temp1 = true;
14099 }
14100 {
14101 arg2 = wxString_in_helper(obj1);
14102 if (arg2 == NULL) SWIG_fail;
14103 temp2 = true;
14104 }
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 resultobj = SWIG_Py_Void();
14112 {
14113 if (temp1)
14114 delete arg1;
14115 }
14116 {
14117 if (temp2)
14118 delete arg2;
14119 }
14120 return resultobj;
14121 fail:
14122 {
14123 if (temp1)
14124 delete arg1;
14125 }
14126 {
14127 if (temp2)
14128 delete arg2;
14129 }
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14135 PyObject *resultobj = 0;
14136 wxLogNull *result = 0 ;
14137
14138 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14139 {
14140 PyThreadState* __tstate = wxPyBeginAllowThreads();
14141 result = (wxLogNull *)new wxLogNull();
14142 wxPyEndAllowThreads(__tstate);
14143 if (PyErr_Occurred()) SWIG_fail;
14144 }
14145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14153 PyObject *resultobj = 0;
14154 wxLogNull *arg1 = (wxLogNull *) 0 ;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 PyObject *swig_obj[1] ;
14158
14159 if (!args) SWIG_fail;
14160 swig_obj[0] = args;
14161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14164 }
14165 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 delete arg1;
14169
14170 wxPyEndAllowThreads(__tstate);
14171 if (PyErr_Occurred()) SWIG_fail;
14172 }
14173 resultobj = SWIG_Py_Void();
14174 return resultobj;
14175 fail:
14176 return NULL;
14177 }
14178
14179
14180 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14181 PyObject *obj;
14182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14183 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14184 return SWIG_Py_Void();
14185 }
14186
14187 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14188 return SWIG_Python_InitShadowInstance(args);
14189 }
14190
14191 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14192 PyObject *resultobj = 0;
14193 wxPyLog *result = 0 ;
14194
14195 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14196 {
14197 PyThreadState* __tstate = wxPyBeginAllowThreads();
14198 result = (wxPyLog *)new wxPyLog();
14199 wxPyEndAllowThreads(__tstate);
14200 if (PyErr_Occurred()) SWIG_fail;
14201 }
14202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14203 return resultobj;
14204 fail:
14205 return NULL;
14206 }
14207
14208
14209 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14210 PyObject *resultobj = 0;
14211 wxPyLog *arg1 = (wxPyLog *) 0 ;
14212 PyObject *arg2 = (PyObject *) 0 ;
14213 PyObject *arg3 = (PyObject *) 0 ;
14214 void *argp1 = 0 ;
14215 int res1 = 0 ;
14216 PyObject * obj0 = 0 ;
14217 PyObject * obj1 = 0 ;
14218 PyObject * obj2 = 0 ;
14219 char * kwnames[] = {
14220 (char *) "self",(char *) "self",(char *) "_class", NULL
14221 };
14222
14223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14225 if (!SWIG_IsOK(res1)) {
14226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14227 }
14228 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14229 arg2 = obj1;
14230 arg3 = obj2;
14231 {
14232 PyThreadState* __tstate = wxPyBeginAllowThreads();
14233 (arg1)->_setCallbackInfo(arg2,arg3);
14234 wxPyEndAllowThreads(__tstate);
14235 if (PyErr_Occurred()) SWIG_fail;
14236 }
14237 resultobj = SWIG_Py_Void();
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14245 PyObject *obj;
14246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14247 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14248 return SWIG_Py_Void();
14249 }
14250
14251 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14252 return SWIG_Python_InitShadowInstance(args);
14253 }
14254
14255 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj = 0;
14257 int arg1 ;
14258 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14259 int arg3 = (int) wxKILL_NOCHILDREN ;
14260 wxKillError result;
14261 int val1 ;
14262 int ecode1 = 0 ;
14263 int val2 ;
14264 int ecode2 = 0 ;
14265 int val3 ;
14266 int ecode3 = 0 ;
14267 PyObject * obj0 = 0 ;
14268 PyObject * obj1 = 0 ;
14269 PyObject * obj2 = 0 ;
14270 char * kwnames[] = {
14271 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14272 };
14273
14274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14275 ecode1 = SWIG_AsVal_int(obj0, &val1);
14276 if (!SWIG_IsOK(ecode1)) {
14277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14278 }
14279 arg1 = static_cast< int >(val1);
14280 if (obj1) {
14281 ecode2 = SWIG_AsVal_int(obj1, &val2);
14282 if (!SWIG_IsOK(ecode2)) {
14283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14284 }
14285 arg2 = static_cast< wxSignal >(val2);
14286 }
14287 if (obj2) {
14288 ecode3 = SWIG_AsVal_int(obj2, &val3);
14289 if (!SWIG_IsOK(ecode3)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14291 }
14292 arg3 = static_cast< int >(val3);
14293 }
14294 {
14295 PyThreadState* __tstate = wxPyBeginAllowThreads();
14296 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14297 wxPyEndAllowThreads(__tstate);
14298 if (PyErr_Occurred()) SWIG_fail;
14299 }
14300 resultobj = SWIG_From_int(static_cast< int >(result));
14301 return resultobj;
14302 fail:
14303 return NULL;
14304 }
14305
14306
14307 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14308 PyObject *resultobj = 0;
14309 int arg1 ;
14310 bool result;
14311 int val1 ;
14312 int ecode1 = 0 ;
14313 PyObject * obj0 = 0 ;
14314 char * kwnames[] = {
14315 (char *) "pid", NULL
14316 };
14317
14318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14319 ecode1 = SWIG_AsVal_int(obj0, &val1);
14320 if (!SWIG_IsOK(ecode1)) {
14321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14322 }
14323 arg1 = static_cast< int >(val1);
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (bool)wxPyProcess::Exists(arg1);
14327 wxPyEndAllowThreads(__tstate);
14328 if (PyErr_Occurred()) SWIG_fail;
14329 }
14330 {
14331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14332 }
14333 return resultobj;
14334 fail:
14335 return NULL;
14336 }
14337
14338
14339 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14340 PyObject *resultobj = 0;
14341 wxString *arg1 = 0 ;
14342 int arg2 = (int) wxEXEC_ASYNC ;
14343 wxPyProcess *result = 0 ;
14344 bool temp1 = false ;
14345 int val2 ;
14346 int ecode2 = 0 ;
14347 PyObject * obj0 = 0 ;
14348 PyObject * obj1 = 0 ;
14349 char * kwnames[] = {
14350 (char *) "cmd",(char *) "flags", NULL
14351 };
14352
14353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14354 {
14355 arg1 = wxString_in_helper(obj0);
14356 if (arg1 == NULL) SWIG_fail;
14357 temp1 = true;
14358 }
14359 if (obj1) {
14360 ecode2 = SWIG_AsVal_int(obj1, &val2);
14361 if (!SWIG_IsOK(ecode2)) {
14362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14363 }
14364 arg2 = static_cast< int >(val2);
14365 }
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14369 wxPyEndAllowThreads(__tstate);
14370 if (PyErr_Occurred()) SWIG_fail;
14371 }
14372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14373 {
14374 if (temp1)
14375 delete arg1;
14376 }
14377 return resultobj;
14378 fail:
14379 {
14380 if (temp1)
14381 delete arg1;
14382 }
14383 return NULL;
14384 }
14385
14386
14387 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj = 0;
14389 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14390 int arg2 = (int) -1 ;
14391 wxPyProcess *result = 0 ;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 int val2 ;
14395 int ecode2 = 0 ;
14396 PyObject * obj0 = 0 ;
14397 PyObject * obj1 = 0 ;
14398 char * kwnames[] = {
14399 (char *) "parent",(char *) "id", NULL
14400 };
14401
14402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14403 if (obj0) {
14404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14405 if (!SWIG_IsOK(res1)) {
14406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14407 }
14408 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14409 }
14410 if (obj1) {
14411 ecode2 = SWIG_AsVal_int(obj1, &val2);
14412 if (!SWIG_IsOK(ecode2)) {
14413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14414 }
14415 arg2 = static_cast< int >(val2);
14416 }
14417 {
14418 PyThreadState* __tstate = wxPyBeginAllowThreads();
14419 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14420 wxPyEndAllowThreads(__tstate);
14421 if (PyErr_Occurred()) SWIG_fail;
14422 }
14423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14424 return resultobj;
14425 fail:
14426 return NULL;
14427 }
14428
14429
14430 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14431 PyObject *resultobj = 0;
14432 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14433 void *argp1 = 0 ;
14434 int res1 = 0 ;
14435 PyObject *swig_obj[1] ;
14436
14437 if (!args) SWIG_fail;
14438 swig_obj[0] = args;
14439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14440 if (!SWIG_IsOK(res1)) {
14441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14442 }
14443 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14444 {
14445 PyThreadState* __tstate = wxPyBeginAllowThreads();
14446 delete arg1;
14447
14448 wxPyEndAllowThreads(__tstate);
14449 if (PyErr_Occurred()) SWIG_fail;
14450 }
14451 resultobj = SWIG_Py_Void();
14452 return resultobj;
14453 fail:
14454 return NULL;
14455 }
14456
14457
14458 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = 0;
14460 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14461 PyObject *arg2 = (PyObject *) 0 ;
14462 PyObject *arg3 = (PyObject *) 0 ;
14463 void *argp1 = 0 ;
14464 int res1 = 0 ;
14465 PyObject * obj0 = 0 ;
14466 PyObject * obj1 = 0 ;
14467 PyObject * obj2 = 0 ;
14468 char * kwnames[] = {
14469 (char *) "self",(char *) "self",(char *) "_class", NULL
14470 };
14471
14472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14474 if (!SWIG_IsOK(res1)) {
14475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14476 }
14477 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14478 arg2 = obj1;
14479 arg3 = obj2;
14480 {
14481 PyThreadState* __tstate = wxPyBeginAllowThreads();
14482 (arg1)->_setCallbackInfo(arg2,arg3);
14483 wxPyEndAllowThreads(__tstate);
14484 if (PyErr_Occurred()) SWIG_fail;
14485 }
14486 resultobj = SWIG_Py_Void();
14487 return resultobj;
14488 fail:
14489 return NULL;
14490 }
14491
14492
14493 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14494 PyObject *resultobj = 0;
14495 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14496 long result;
14497 void *argp1 = 0 ;
14498 int res1 = 0 ;
14499 PyObject *swig_obj[1] ;
14500
14501 if (!args) SWIG_fail;
14502 swig_obj[0] = args;
14503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14504 if (!SWIG_IsOK(res1)) {
14505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14506 }
14507 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 result = (long)((wxPyProcess const *)arg1)->GetPid();
14511 wxPyEndAllowThreads(__tstate);
14512 if (PyErr_Occurred()) SWIG_fail;
14513 }
14514 resultobj = SWIG_From_long(static_cast< long >(result));
14515 return resultobj;
14516 fail:
14517 return NULL;
14518 }
14519
14520
14521 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14522 PyObject *resultobj = 0;
14523 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14524 int arg2 ;
14525 int arg3 ;
14526 void *argp1 = 0 ;
14527 int res1 = 0 ;
14528 int val2 ;
14529 int ecode2 = 0 ;
14530 int val3 ;
14531 int ecode3 = 0 ;
14532 PyObject * obj0 = 0 ;
14533 PyObject * obj1 = 0 ;
14534 PyObject * obj2 = 0 ;
14535 char * kwnames[] = {
14536 (char *) "self",(char *) "pid",(char *) "status", NULL
14537 };
14538
14539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14541 if (!SWIG_IsOK(res1)) {
14542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14543 }
14544 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14545 ecode2 = SWIG_AsVal_int(obj1, &val2);
14546 if (!SWIG_IsOK(ecode2)) {
14547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14548 }
14549 arg2 = static_cast< int >(val2);
14550 ecode3 = SWIG_AsVal_int(obj2, &val3);
14551 if (!SWIG_IsOK(ecode3)) {
14552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14553 }
14554 arg3 = static_cast< int >(val3);
14555 {
14556 PyThreadState* __tstate = wxPyBeginAllowThreads();
14557 (arg1)->OnTerminate(arg2,arg3);
14558 wxPyEndAllowThreads(__tstate);
14559 if (PyErr_Occurred()) SWIG_fail;
14560 }
14561 resultobj = SWIG_Py_Void();
14562 return resultobj;
14563 fail:
14564 return NULL;
14565 }
14566
14567
14568 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14569 PyObject *resultobj = 0;
14570 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14571 void *argp1 = 0 ;
14572 int res1 = 0 ;
14573 PyObject *swig_obj[1] ;
14574
14575 if (!args) SWIG_fail;
14576 swig_obj[0] = args;
14577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14578 if (!SWIG_IsOK(res1)) {
14579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14580 }
14581 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 (arg1)->Redirect();
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 resultobj = SWIG_Py_Void();
14589 return resultobj;
14590 fail:
14591 return NULL;
14592 }
14593
14594
14595 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14596 PyObject *resultobj = 0;
14597 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14598 bool result;
14599 void *argp1 = 0 ;
14600 int res1 = 0 ;
14601 PyObject *swig_obj[1] ;
14602
14603 if (!args) SWIG_fail;
14604 swig_obj[0] = args;
14605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14606 if (!SWIG_IsOK(res1)) {
14607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14608 }
14609 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14610 {
14611 PyThreadState* __tstate = wxPyBeginAllowThreads();
14612 result = (bool)(arg1)->IsRedirected();
14613 wxPyEndAllowThreads(__tstate);
14614 if (PyErr_Occurred()) SWIG_fail;
14615 }
14616 {
14617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14618 }
14619 return resultobj;
14620 fail:
14621 return NULL;
14622 }
14623
14624
14625 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14626 PyObject *resultobj = 0;
14627 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14628 void *argp1 = 0 ;
14629 int res1 = 0 ;
14630 PyObject *swig_obj[1] ;
14631
14632 if (!args) SWIG_fail;
14633 swig_obj[0] = args;
14634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14635 if (!SWIG_IsOK(res1)) {
14636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14637 }
14638 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14639 {
14640 PyThreadState* __tstate = wxPyBeginAllowThreads();
14641 (arg1)->Detach();
14642 wxPyEndAllowThreads(__tstate);
14643 if (PyErr_Occurred()) SWIG_fail;
14644 }
14645 resultobj = SWIG_Py_Void();
14646 return resultobj;
14647 fail:
14648 return NULL;
14649 }
14650
14651
14652 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14653 PyObject *resultobj = 0;
14654 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14655 wxInputStream *result = 0 ;
14656 void *argp1 = 0 ;
14657 int res1 = 0 ;
14658 PyObject *swig_obj[1] ;
14659
14660 if (!args) SWIG_fail;
14661 swig_obj[0] = args;
14662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14663 if (!SWIG_IsOK(res1)) {
14664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14665 }
14666 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14667 {
14668 PyThreadState* __tstate = wxPyBeginAllowThreads();
14669 result = (wxInputStream *)(arg1)->GetInputStream();
14670 wxPyEndAllowThreads(__tstate);
14671 if (PyErr_Occurred()) SWIG_fail;
14672 }
14673 {
14674 wxPyInputStream * _ptr = NULL;
14675
14676 if (result) {
14677 _ptr = new wxPyInputStream(result);
14678 }
14679 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14680 }
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14688 PyObject *resultobj = 0;
14689 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14690 wxInputStream *result = 0 ;
14691 void *argp1 = 0 ;
14692 int res1 = 0 ;
14693 PyObject *swig_obj[1] ;
14694
14695 if (!args) SWIG_fail;
14696 swig_obj[0] = args;
14697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14698 if (!SWIG_IsOK(res1)) {
14699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14700 }
14701 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 result = (wxInputStream *)(arg1)->GetErrorStream();
14705 wxPyEndAllowThreads(__tstate);
14706 if (PyErr_Occurred()) SWIG_fail;
14707 }
14708 {
14709 wxPyInputStream * _ptr = NULL;
14710
14711 if (result) {
14712 _ptr = new wxPyInputStream(result);
14713 }
14714 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14715 }
14716 return resultobj;
14717 fail:
14718 return NULL;
14719 }
14720
14721
14722 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14723 PyObject *resultobj = 0;
14724 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14725 wxOutputStream *result = 0 ;
14726 void *argp1 = 0 ;
14727 int res1 = 0 ;
14728 PyObject *swig_obj[1] ;
14729
14730 if (!args) SWIG_fail;
14731 swig_obj[0] = args;
14732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14733 if (!SWIG_IsOK(res1)) {
14734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14735 }
14736 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (wxOutputStream *)(arg1)->GetOutputStream();
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14744 return resultobj;
14745 fail:
14746 return NULL;
14747 }
14748
14749
14750 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14751 PyObject *resultobj = 0;
14752 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14753 void *argp1 = 0 ;
14754 int res1 = 0 ;
14755 PyObject *swig_obj[1] ;
14756
14757 if (!args) SWIG_fail;
14758 swig_obj[0] = args;
14759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14760 if (!SWIG_IsOK(res1)) {
14761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14762 }
14763 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14764 {
14765 PyThreadState* __tstate = wxPyBeginAllowThreads();
14766 (arg1)->CloseOutput();
14767 wxPyEndAllowThreads(__tstate);
14768 if (PyErr_Occurred()) SWIG_fail;
14769 }
14770 resultobj = SWIG_Py_Void();
14771 return resultobj;
14772 fail:
14773 return NULL;
14774 }
14775
14776
14777 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14778 PyObject *resultobj = 0;
14779 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14780 bool result;
14781 void *argp1 = 0 ;
14782 int res1 = 0 ;
14783 PyObject *swig_obj[1] ;
14784
14785 if (!args) SWIG_fail;
14786 swig_obj[0] = args;
14787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14788 if (!SWIG_IsOK(res1)) {
14789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14790 }
14791 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14792 {
14793 PyThreadState* __tstate = wxPyBeginAllowThreads();
14794 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14795 wxPyEndAllowThreads(__tstate);
14796 if (PyErr_Occurred()) SWIG_fail;
14797 }
14798 {
14799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14800 }
14801 return resultobj;
14802 fail:
14803 return NULL;
14804 }
14805
14806
14807 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14808 PyObject *resultobj = 0;
14809 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14810 bool result;
14811 void *argp1 = 0 ;
14812 int res1 = 0 ;
14813 PyObject *swig_obj[1] ;
14814
14815 if (!args) SWIG_fail;
14816 swig_obj[0] = args;
14817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14818 if (!SWIG_IsOK(res1)) {
14819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14820 }
14821 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14822 {
14823 PyThreadState* __tstate = wxPyBeginAllowThreads();
14824 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14825 wxPyEndAllowThreads(__tstate);
14826 if (PyErr_Occurred()) SWIG_fail;
14827 }
14828 {
14829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14830 }
14831 return resultobj;
14832 fail:
14833 return NULL;
14834 }
14835
14836
14837 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14838 PyObject *resultobj = 0;
14839 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14840 bool result;
14841 void *argp1 = 0 ;
14842 int res1 = 0 ;
14843 PyObject *swig_obj[1] ;
14844
14845 if (!args) SWIG_fail;
14846 swig_obj[0] = args;
14847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14848 if (!SWIG_IsOK(res1)) {
14849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14850 }
14851 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14852 {
14853 PyThreadState* __tstate = wxPyBeginAllowThreads();
14854 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14855 wxPyEndAllowThreads(__tstate);
14856 if (PyErr_Occurred()) SWIG_fail;
14857 }
14858 {
14859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14860 }
14861 return resultobj;
14862 fail:
14863 return NULL;
14864 }
14865
14866
14867 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14868 PyObject *obj;
14869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14870 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14871 return SWIG_Py_Void();
14872 }
14873
14874 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14875 return SWIG_Python_InitShadowInstance(args);
14876 }
14877
14878 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj = 0;
14880 int arg1 = (int) 0 ;
14881 int arg2 = (int) 0 ;
14882 int arg3 = (int) 0 ;
14883 wxProcessEvent *result = 0 ;
14884 int val1 ;
14885 int ecode1 = 0 ;
14886 int val2 ;
14887 int ecode2 = 0 ;
14888 int val3 ;
14889 int ecode3 = 0 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 PyObject * obj2 = 0 ;
14893 char * kwnames[] = {
14894 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14895 };
14896
14897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14898 if (obj0) {
14899 ecode1 = SWIG_AsVal_int(obj0, &val1);
14900 if (!SWIG_IsOK(ecode1)) {
14901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14902 }
14903 arg1 = static_cast< int >(val1);
14904 }
14905 if (obj1) {
14906 ecode2 = SWIG_AsVal_int(obj1, &val2);
14907 if (!SWIG_IsOK(ecode2)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14909 }
14910 arg2 = static_cast< int >(val2);
14911 }
14912 if (obj2) {
14913 ecode3 = SWIG_AsVal_int(obj2, &val3);
14914 if (!SWIG_IsOK(ecode3)) {
14915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14916 }
14917 arg3 = static_cast< int >(val3);
14918 }
14919 {
14920 PyThreadState* __tstate = wxPyBeginAllowThreads();
14921 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14933 PyObject *resultobj = 0;
14934 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14935 int result;
14936 void *argp1 = 0 ;
14937 int res1 = 0 ;
14938 PyObject *swig_obj[1] ;
14939
14940 if (!args) SWIG_fail;
14941 swig_obj[0] = args;
14942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14943 if (!SWIG_IsOK(res1)) {
14944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14945 }
14946 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14947 {
14948 PyThreadState* __tstate = wxPyBeginAllowThreads();
14949 result = (int)(arg1)->GetPid();
14950 wxPyEndAllowThreads(__tstate);
14951 if (PyErr_Occurred()) SWIG_fail;
14952 }
14953 resultobj = SWIG_From_int(static_cast< int >(result));
14954 return resultobj;
14955 fail:
14956 return NULL;
14957 }
14958
14959
14960 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14961 PyObject *resultobj = 0;
14962 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14963 int result;
14964 void *argp1 = 0 ;
14965 int res1 = 0 ;
14966 PyObject *swig_obj[1] ;
14967
14968 if (!args) SWIG_fail;
14969 swig_obj[0] = args;
14970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14971 if (!SWIG_IsOK(res1)) {
14972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14973 }
14974 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (int)(arg1)->GetExitCode();
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 resultobj = SWIG_From_int(static_cast< int >(result));
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14989 PyObject *resultobj = 0;
14990 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14991 int arg2 ;
14992 void *argp1 = 0 ;
14993 int res1 = 0 ;
14994 int val2 ;
14995 int ecode2 = 0 ;
14996 PyObject *swig_obj[2] ;
14997
14998 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15000 if (!SWIG_IsOK(res1)) {
15001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15002 }
15003 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15004 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15005 if (!SWIG_IsOK(ecode2)) {
15006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
15007 }
15008 arg2 = static_cast< int >(val2);
15009 if (arg1) (arg1)->m_pid = arg2;
15010
15011 resultobj = SWIG_Py_Void();
15012 return resultobj;
15013 fail:
15014 return NULL;
15015 }
15016
15017
15018 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15019 PyObject *resultobj = 0;
15020 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15021 int result;
15022 void *argp1 = 0 ;
15023 int res1 = 0 ;
15024 PyObject *swig_obj[1] ;
15025
15026 if (!args) SWIG_fail;
15027 swig_obj[0] = args;
15028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15029 if (!SWIG_IsOK(res1)) {
15030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15031 }
15032 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15033 result = (int) ((arg1)->m_pid);
15034 resultobj = SWIG_From_int(static_cast< int >(result));
15035 return resultobj;
15036 fail:
15037 return NULL;
15038 }
15039
15040
15041 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15042 PyObject *resultobj = 0;
15043 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15044 int arg2 ;
15045 void *argp1 = 0 ;
15046 int res1 = 0 ;
15047 int val2 ;
15048 int ecode2 = 0 ;
15049 PyObject *swig_obj[2] ;
15050
15051 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15053 if (!SWIG_IsOK(res1)) {
15054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15055 }
15056 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15057 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15058 if (!SWIG_IsOK(ecode2)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15060 }
15061 arg2 = static_cast< int >(val2);
15062 if (arg1) (arg1)->m_exitcode = arg2;
15063
15064 resultobj = SWIG_Py_Void();
15065 return resultobj;
15066 fail:
15067 return NULL;
15068 }
15069
15070
15071 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15072 PyObject *resultobj = 0;
15073 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15074 int result;
15075 void *argp1 = 0 ;
15076 int res1 = 0 ;
15077 PyObject *swig_obj[1] ;
15078
15079 if (!args) SWIG_fail;
15080 swig_obj[0] = args;
15081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15082 if (!SWIG_IsOK(res1)) {
15083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15084 }
15085 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15086 result = (int) ((arg1)->m_exitcode);
15087 resultobj = SWIG_From_int(static_cast< int >(result));
15088 return resultobj;
15089 fail:
15090 return NULL;
15091 }
15092
15093
15094 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15095 PyObject *obj;
15096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15097 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15098 return SWIG_Py_Void();
15099 }
15100
15101 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15102 return SWIG_Python_InitShadowInstance(args);
15103 }
15104
15105 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15106 PyObject *resultobj = 0;
15107 wxString *arg1 = 0 ;
15108 int arg2 = (int) wxEXEC_ASYNC ;
15109 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15110 long result;
15111 bool temp1 = false ;
15112 int val2 ;
15113 int ecode2 = 0 ;
15114 void *argp3 = 0 ;
15115 int res3 = 0 ;
15116 PyObject * obj0 = 0 ;
15117 PyObject * obj1 = 0 ;
15118 PyObject * obj2 = 0 ;
15119 char * kwnames[] = {
15120 (char *) "command",(char *) "flags",(char *) "process", NULL
15121 };
15122
15123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15124 {
15125 arg1 = wxString_in_helper(obj0);
15126 if (arg1 == NULL) SWIG_fail;
15127 temp1 = true;
15128 }
15129 if (obj1) {
15130 ecode2 = SWIG_AsVal_int(obj1, &val2);
15131 if (!SWIG_IsOK(ecode2)) {
15132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15133 }
15134 arg2 = static_cast< int >(val2);
15135 }
15136 if (obj2) {
15137 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15138 if (!SWIG_IsOK(res3)) {
15139 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15140 }
15141 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15142 }
15143 {
15144 if (!wxPyCheckForApp()) SWIG_fail;
15145 PyThreadState* __tstate = wxPyBeginAllowThreads();
15146 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15147 wxPyEndAllowThreads(__tstate);
15148 if (PyErr_Occurred()) SWIG_fail;
15149 }
15150 resultobj = SWIG_From_long(static_cast< long >(result));
15151 {
15152 if (temp1)
15153 delete arg1;
15154 }
15155 return resultobj;
15156 fail:
15157 {
15158 if (temp1)
15159 delete arg1;
15160 }
15161 return NULL;
15162 }
15163
15164
15165 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15166 PyObject *resultobj = 0;
15167 long arg1 ;
15168 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15169 wxKillError *arg3 = (wxKillError *) 0 ;
15170 int arg4 = (int) wxKILL_NOCHILDREN ;
15171 int result;
15172 long val1 ;
15173 int ecode1 = 0 ;
15174 int val2 ;
15175 int ecode2 = 0 ;
15176 wxKillError temp3 ;
15177 int val4 ;
15178 int ecode4 = 0 ;
15179 PyObject * obj0 = 0 ;
15180 PyObject * obj1 = 0 ;
15181 PyObject * obj2 = 0 ;
15182 char * kwnames[] = {
15183 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15184 };
15185
15186 {
15187 arg3 = &temp3;
15188 }
15189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15190 ecode1 = SWIG_AsVal_long(obj0, &val1);
15191 if (!SWIG_IsOK(ecode1)) {
15192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15193 }
15194 arg1 = static_cast< long >(val1);
15195 if (obj1) {
15196 ecode2 = SWIG_AsVal_int(obj1, &val2);
15197 if (!SWIG_IsOK(ecode2)) {
15198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15199 }
15200 arg2 = static_cast< wxSignal >(val2);
15201 }
15202 if (obj2) {
15203 ecode4 = SWIG_AsVal_int(obj2, &val4);
15204 if (!SWIG_IsOK(ecode4)) {
15205 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15206 }
15207 arg4 = static_cast< int >(val4);
15208 }
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 result = (int)wxKill(arg1,arg2,arg3,arg4);
15212 wxPyEndAllowThreads(__tstate);
15213 if (PyErr_Occurred()) SWIG_fail;
15214 }
15215 resultobj = SWIG_From_int(static_cast< int >(result));
15216 {
15217 PyObject* o;
15218 o = PyInt_FromLong((long) (*arg3));
15219
15220
15221
15222 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15223
15224 }
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15232 PyObject *resultobj = 0;
15233 int arg1 = (int) wxJOYSTICK1 ;
15234 wxJoystick *result = 0 ;
15235 int val1 ;
15236 int ecode1 = 0 ;
15237 PyObject * obj0 = 0 ;
15238 char * kwnames[] = {
15239 (char *) "joystick", NULL
15240 };
15241
15242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15243 if (obj0) {
15244 ecode1 = SWIG_AsVal_int(obj0, &val1);
15245 if (!SWIG_IsOK(ecode1)) {
15246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15247 }
15248 arg1 = static_cast< int >(val1);
15249 }
15250 {
15251 if (!wxPyCheckForApp()) SWIG_fail;
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 result = (wxJoystick *)new wxJoystick(arg1);
15254 wxPyEndAllowThreads(__tstate);
15255 if (PyErr_Occurred()) SWIG_fail;
15256 }
15257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15258 return resultobj;
15259 fail:
15260 return NULL;
15261 }
15262
15263
15264 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15265 PyObject *resultobj = 0;
15266 wxJoystick *arg1 = (wxJoystick *) 0 ;
15267 void *argp1 = 0 ;
15268 int res1 = 0 ;
15269 PyObject *swig_obj[1] ;
15270
15271 if (!args) SWIG_fail;
15272 swig_obj[0] = args;
15273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15274 if (!SWIG_IsOK(res1)) {
15275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15276 }
15277 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15278 {
15279 PyThreadState* __tstate = wxPyBeginAllowThreads();
15280 delete arg1;
15281
15282 wxPyEndAllowThreads(__tstate);
15283 if (PyErr_Occurred()) SWIG_fail;
15284 }
15285 resultobj = SWIG_Py_Void();
15286 return resultobj;
15287 fail:
15288 return NULL;
15289 }
15290
15291
15292 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15293 PyObject *resultobj = 0;
15294 wxJoystick *arg1 = (wxJoystick *) 0 ;
15295 wxPoint result;
15296 void *argp1 = 0 ;
15297 int res1 = 0 ;
15298 PyObject *swig_obj[1] ;
15299
15300 if (!args) SWIG_fail;
15301 swig_obj[0] = args;
15302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15303 if (!SWIG_IsOK(res1)) {
15304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15305 }
15306 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = (arg1)->GetPosition();
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15314 return resultobj;
15315 fail:
15316 return NULL;
15317 }
15318
15319
15320 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15321 PyObject *resultobj = 0;
15322 wxJoystick *arg1 = (wxJoystick *) 0 ;
15323 int result;
15324 void *argp1 = 0 ;
15325 int res1 = 0 ;
15326 PyObject *swig_obj[1] ;
15327
15328 if (!args) SWIG_fail;
15329 swig_obj[0] = args;
15330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15331 if (!SWIG_IsOK(res1)) {
15332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15333 }
15334 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (int)(arg1)->GetZPosition();
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 resultobj = SWIG_From_int(static_cast< int >(result));
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15349 PyObject *resultobj = 0;
15350 wxJoystick *arg1 = (wxJoystick *) 0 ;
15351 int result;
15352 void *argp1 = 0 ;
15353 int res1 = 0 ;
15354 PyObject *swig_obj[1] ;
15355
15356 if (!args) SWIG_fail;
15357 swig_obj[0] = args;
15358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15359 if (!SWIG_IsOK(res1)) {
15360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15361 }
15362 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15363 {
15364 PyThreadState* __tstate = wxPyBeginAllowThreads();
15365 result = (int)(arg1)->GetButtonState();
15366 wxPyEndAllowThreads(__tstate);
15367 if (PyErr_Occurred()) SWIG_fail;
15368 }
15369 resultobj = SWIG_From_int(static_cast< int >(result));
15370 return resultobj;
15371 fail:
15372 return NULL;
15373 }
15374
15375
15376 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15377 PyObject *resultobj = 0;
15378 wxJoystick *arg1 = (wxJoystick *) 0 ;
15379 int result;
15380 void *argp1 = 0 ;
15381 int res1 = 0 ;
15382 PyObject *swig_obj[1] ;
15383
15384 if (!args) SWIG_fail;
15385 swig_obj[0] = args;
15386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15387 if (!SWIG_IsOK(res1)) {
15388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15389 }
15390 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15391 {
15392 PyThreadState* __tstate = wxPyBeginAllowThreads();
15393 result = (int)(arg1)->GetPOVPosition();
15394 wxPyEndAllowThreads(__tstate);
15395 if (PyErr_Occurred()) SWIG_fail;
15396 }
15397 resultobj = SWIG_From_int(static_cast< int >(result));
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15405 PyObject *resultobj = 0;
15406 wxJoystick *arg1 = (wxJoystick *) 0 ;
15407 int result;
15408 void *argp1 = 0 ;
15409 int res1 = 0 ;
15410 PyObject *swig_obj[1] ;
15411
15412 if (!args) SWIG_fail;
15413 swig_obj[0] = args;
15414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15415 if (!SWIG_IsOK(res1)) {
15416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15417 }
15418 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15419 {
15420 PyThreadState* __tstate = wxPyBeginAllowThreads();
15421 result = (int)(arg1)->GetPOVCTSPosition();
15422 wxPyEndAllowThreads(__tstate);
15423 if (PyErr_Occurred()) SWIG_fail;
15424 }
15425 resultobj = SWIG_From_int(static_cast< int >(result));
15426 return resultobj;
15427 fail:
15428 return NULL;
15429 }
15430
15431
15432 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15433 PyObject *resultobj = 0;
15434 wxJoystick *arg1 = (wxJoystick *) 0 ;
15435 int result;
15436 void *argp1 = 0 ;
15437 int res1 = 0 ;
15438 PyObject *swig_obj[1] ;
15439
15440 if (!args) SWIG_fail;
15441 swig_obj[0] = args;
15442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15443 if (!SWIG_IsOK(res1)) {
15444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15445 }
15446 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15447 {
15448 PyThreadState* __tstate = wxPyBeginAllowThreads();
15449 result = (int)(arg1)->GetRudderPosition();
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_From_int(static_cast< int >(result));
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15461 PyObject *resultobj = 0;
15462 wxJoystick *arg1 = (wxJoystick *) 0 ;
15463 int result;
15464 void *argp1 = 0 ;
15465 int res1 = 0 ;
15466 PyObject *swig_obj[1] ;
15467
15468 if (!args) SWIG_fail;
15469 swig_obj[0] = args;
15470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15471 if (!SWIG_IsOK(res1)) {
15472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15473 }
15474 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15475 {
15476 PyThreadState* __tstate = wxPyBeginAllowThreads();
15477 result = (int)(arg1)->GetUPosition();
15478 wxPyEndAllowThreads(__tstate);
15479 if (PyErr_Occurred()) SWIG_fail;
15480 }
15481 resultobj = SWIG_From_int(static_cast< int >(result));
15482 return resultobj;
15483 fail:
15484 return NULL;
15485 }
15486
15487
15488 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15489 PyObject *resultobj = 0;
15490 wxJoystick *arg1 = (wxJoystick *) 0 ;
15491 int result;
15492 void *argp1 = 0 ;
15493 int res1 = 0 ;
15494 PyObject *swig_obj[1] ;
15495
15496 if (!args) SWIG_fail;
15497 swig_obj[0] = args;
15498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15499 if (!SWIG_IsOK(res1)) {
15500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15501 }
15502 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15503 {
15504 PyThreadState* __tstate = wxPyBeginAllowThreads();
15505 result = (int)(arg1)->GetVPosition();
15506 wxPyEndAllowThreads(__tstate);
15507 if (PyErr_Occurred()) SWIG_fail;
15508 }
15509 resultobj = SWIG_From_int(static_cast< int >(result));
15510 return resultobj;
15511 fail:
15512 return NULL;
15513 }
15514
15515
15516 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15517 PyObject *resultobj = 0;
15518 wxJoystick *arg1 = (wxJoystick *) 0 ;
15519 int result;
15520 void *argp1 = 0 ;
15521 int res1 = 0 ;
15522 PyObject *swig_obj[1] ;
15523
15524 if (!args) SWIG_fail;
15525 swig_obj[0] = args;
15526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15527 if (!SWIG_IsOK(res1)) {
15528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15529 }
15530 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15531 {
15532 PyThreadState* __tstate = wxPyBeginAllowThreads();
15533 result = (int)(arg1)->GetMovementThreshold();
15534 wxPyEndAllowThreads(__tstate);
15535 if (PyErr_Occurred()) SWIG_fail;
15536 }
15537 resultobj = SWIG_From_int(static_cast< int >(result));
15538 return resultobj;
15539 fail:
15540 return NULL;
15541 }
15542
15543
15544 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15545 PyObject *resultobj = 0;
15546 wxJoystick *arg1 = (wxJoystick *) 0 ;
15547 int arg2 ;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 int val2 ;
15551 int ecode2 = 0 ;
15552 PyObject * obj0 = 0 ;
15553 PyObject * obj1 = 0 ;
15554 char * kwnames[] = {
15555 (char *) "self",(char *) "threshold", NULL
15556 };
15557
15558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15560 if (!SWIG_IsOK(res1)) {
15561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15562 }
15563 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15564 ecode2 = SWIG_AsVal_int(obj1, &val2);
15565 if (!SWIG_IsOK(ecode2)) {
15566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15567 }
15568 arg2 = static_cast< int >(val2);
15569 {
15570 PyThreadState* __tstate = wxPyBeginAllowThreads();
15571 (arg1)->SetMovementThreshold(arg2);
15572 wxPyEndAllowThreads(__tstate);
15573 if (PyErr_Occurred()) SWIG_fail;
15574 }
15575 resultobj = SWIG_Py_Void();
15576 return resultobj;
15577 fail:
15578 return NULL;
15579 }
15580
15581
15582 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15583 PyObject *resultobj = 0;
15584 wxJoystick *arg1 = (wxJoystick *) 0 ;
15585 bool result;
15586 void *argp1 = 0 ;
15587 int res1 = 0 ;
15588 PyObject *swig_obj[1] ;
15589
15590 if (!args) SWIG_fail;
15591 swig_obj[0] = args;
15592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15593 if (!SWIG_IsOK(res1)) {
15594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15595 }
15596 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15597 {
15598 PyThreadState* __tstate = wxPyBeginAllowThreads();
15599 result = (bool)(arg1)->IsOk();
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 {
15604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15605 }
15606 return resultobj;
15607 fail:
15608 return NULL;
15609 }
15610
15611
15612 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15613 PyObject *resultobj = 0;
15614 wxJoystick *arg1 = (wxJoystick *) 0 ;
15615 int result;
15616 void *argp1 = 0 ;
15617 int res1 = 0 ;
15618 PyObject *swig_obj[1] ;
15619
15620 if (!args) SWIG_fail;
15621 swig_obj[0] = args;
15622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15623 if (!SWIG_IsOK(res1)) {
15624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15625 }
15626 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15627 {
15628 PyThreadState* __tstate = wxPyBeginAllowThreads();
15629 result = (int)(arg1)->GetNumberJoysticks();
15630 wxPyEndAllowThreads(__tstate);
15631 if (PyErr_Occurred()) SWIG_fail;
15632 }
15633 resultobj = SWIG_From_int(static_cast< int >(result));
15634 return resultobj;
15635 fail:
15636 return NULL;
15637 }
15638
15639
15640 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15641 PyObject *resultobj = 0;
15642 wxJoystick *arg1 = (wxJoystick *) 0 ;
15643 int result;
15644 void *argp1 = 0 ;
15645 int res1 = 0 ;
15646 PyObject *swig_obj[1] ;
15647
15648 if (!args) SWIG_fail;
15649 swig_obj[0] = args;
15650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15651 if (!SWIG_IsOK(res1)) {
15652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15653 }
15654 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15655 {
15656 PyThreadState* __tstate = wxPyBeginAllowThreads();
15657 result = (int)(arg1)->GetManufacturerId();
15658 wxPyEndAllowThreads(__tstate);
15659 if (PyErr_Occurred()) SWIG_fail;
15660 }
15661 resultobj = SWIG_From_int(static_cast< int >(result));
15662 return resultobj;
15663 fail:
15664 return NULL;
15665 }
15666
15667
15668 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15669 PyObject *resultobj = 0;
15670 wxJoystick *arg1 = (wxJoystick *) 0 ;
15671 int result;
15672 void *argp1 = 0 ;
15673 int res1 = 0 ;
15674 PyObject *swig_obj[1] ;
15675
15676 if (!args) SWIG_fail;
15677 swig_obj[0] = args;
15678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15679 if (!SWIG_IsOK(res1)) {
15680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15681 }
15682 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15683 {
15684 PyThreadState* __tstate = wxPyBeginAllowThreads();
15685 result = (int)(arg1)->GetProductId();
15686 wxPyEndAllowThreads(__tstate);
15687 if (PyErr_Occurred()) SWIG_fail;
15688 }
15689 resultobj = SWIG_From_int(static_cast< int >(result));
15690 return resultobj;
15691 fail:
15692 return NULL;
15693 }
15694
15695
15696 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15697 PyObject *resultobj = 0;
15698 wxJoystick *arg1 = (wxJoystick *) 0 ;
15699 wxString result;
15700 void *argp1 = 0 ;
15701 int res1 = 0 ;
15702 PyObject *swig_obj[1] ;
15703
15704 if (!args) SWIG_fail;
15705 swig_obj[0] = args;
15706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15707 if (!SWIG_IsOK(res1)) {
15708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15709 }
15710 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15711 {
15712 PyThreadState* __tstate = wxPyBeginAllowThreads();
15713 result = (arg1)->GetProductName();
15714 wxPyEndAllowThreads(__tstate);
15715 if (PyErr_Occurred()) SWIG_fail;
15716 }
15717 {
15718 #if wxUSE_UNICODE
15719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15720 #else
15721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15722 #endif
15723 }
15724 return resultobj;
15725 fail:
15726 return NULL;
15727 }
15728
15729
15730 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15731 PyObject *resultobj = 0;
15732 wxJoystick *arg1 = (wxJoystick *) 0 ;
15733 int result;
15734 void *argp1 = 0 ;
15735 int res1 = 0 ;
15736 PyObject *swig_obj[1] ;
15737
15738 if (!args) SWIG_fail;
15739 swig_obj[0] = args;
15740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15741 if (!SWIG_IsOK(res1)) {
15742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15743 }
15744 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15745 {
15746 PyThreadState* __tstate = wxPyBeginAllowThreads();
15747 result = (int)(arg1)->GetXMin();
15748 wxPyEndAllowThreads(__tstate);
15749 if (PyErr_Occurred()) SWIG_fail;
15750 }
15751 resultobj = SWIG_From_int(static_cast< int >(result));
15752 return resultobj;
15753 fail:
15754 return NULL;
15755 }
15756
15757
15758 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15759 PyObject *resultobj = 0;
15760 wxJoystick *arg1 = (wxJoystick *) 0 ;
15761 int result;
15762 void *argp1 = 0 ;
15763 int res1 = 0 ;
15764 PyObject *swig_obj[1] ;
15765
15766 if (!args) SWIG_fail;
15767 swig_obj[0] = args;
15768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15769 if (!SWIG_IsOK(res1)) {
15770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15771 }
15772 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15773 {
15774 PyThreadState* __tstate = wxPyBeginAllowThreads();
15775 result = (int)(arg1)->GetYMin();
15776 wxPyEndAllowThreads(__tstate);
15777 if (PyErr_Occurred()) SWIG_fail;
15778 }
15779 resultobj = SWIG_From_int(static_cast< int >(result));
15780 return resultobj;
15781 fail:
15782 return NULL;
15783 }
15784
15785
15786 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15787 PyObject *resultobj = 0;
15788 wxJoystick *arg1 = (wxJoystick *) 0 ;
15789 int result;
15790 void *argp1 = 0 ;
15791 int res1 = 0 ;
15792 PyObject *swig_obj[1] ;
15793
15794 if (!args) SWIG_fail;
15795 swig_obj[0] = args;
15796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15797 if (!SWIG_IsOK(res1)) {
15798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15799 }
15800 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 result = (int)(arg1)->GetZMin();
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 resultobj = SWIG_From_int(static_cast< int >(result));
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15815 PyObject *resultobj = 0;
15816 wxJoystick *arg1 = (wxJoystick *) 0 ;
15817 int result;
15818 void *argp1 = 0 ;
15819 int res1 = 0 ;
15820 PyObject *swig_obj[1] ;
15821
15822 if (!args) SWIG_fail;
15823 swig_obj[0] = args;
15824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15825 if (!SWIG_IsOK(res1)) {
15826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15827 }
15828 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15829 {
15830 PyThreadState* __tstate = wxPyBeginAllowThreads();
15831 result = (int)(arg1)->GetXMax();
15832 wxPyEndAllowThreads(__tstate);
15833 if (PyErr_Occurred()) SWIG_fail;
15834 }
15835 resultobj = SWIG_From_int(static_cast< int >(result));
15836 return resultobj;
15837 fail:
15838 return NULL;
15839 }
15840
15841
15842 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15843 PyObject *resultobj = 0;
15844 wxJoystick *arg1 = (wxJoystick *) 0 ;
15845 int result;
15846 void *argp1 = 0 ;
15847 int res1 = 0 ;
15848 PyObject *swig_obj[1] ;
15849
15850 if (!args) SWIG_fail;
15851 swig_obj[0] = args;
15852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15853 if (!SWIG_IsOK(res1)) {
15854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15855 }
15856 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15857 {
15858 PyThreadState* __tstate = wxPyBeginAllowThreads();
15859 result = (int)(arg1)->GetYMax();
15860 wxPyEndAllowThreads(__tstate);
15861 if (PyErr_Occurred()) SWIG_fail;
15862 }
15863 resultobj = SWIG_From_int(static_cast< int >(result));
15864 return resultobj;
15865 fail:
15866 return NULL;
15867 }
15868
15869
15870 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15871 PyObject *resultobj = 0;
15872 wxJoystick *arg1 = (wxJoystick *) 0 ;
15873 int result;
15874 void *argp1 = 0 ;
15875 int res1 = 0 ;
15876 PyObject *swig_obj[1] ;
15877
15878 if (!args) SWIG_fail;
15879 swig_obj[0] = args;
15880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15881 if (!SWIG_IsOK(res1)) {
15882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15883 }
15884 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15885 {
15886 PyThreadState* __tstate = wxPyBeginAllowThreads();
15887 result = (int)(arg1)->GetZMax();
15888 wxPyEndAllowThreads(__tstate);
15889 if (PyErr_Occurred()) SWIG_fail;
15890 }
15891 resultobj = SWIG_From_int(static_cast< int >(result));
15892 return resultobj;
15893 fail:
15894 return NULL;
15895 }
15896
15897
15898 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15899 PyObject *resultobj = 0;
15900 wxJoystick *arg1 = (wxJoystick *) 0 ;
15901 int result;
15902 void *argp1 = 0 ;
15903 int res1 = 0 ;
15904 PyObject *swig_obj[1] ;
15905
15906 if (!args) SWIG_fail;
15907 swig_obj[0] = args;
15908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15909 if (!SWIG_IsOK(res1)) {
15910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15911 }
15912 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15913 {
15914 PyThreadState* __tstate = wxPyBeginAllowThreads();
15915 result = (int)(arg1)->GetNumberButtons();
15916 wxPyEndAllowThreads(__tstate);
15917 if (PyErr_Occurred()) SWIG_fail;
15918 }
15919 resultobj = SWIG_From_int(static_cast< int >(result));
15920 return resultobj;
15921 fail:
15922 return NULL;
15923 }
15924
15925
15926 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15927 PyObject *resultobj = 0;
15928 wxJoystick *arg1 = (wxJoystick *) 0 ;
15929 int result;
15930 void *argp1 = 0 ;
15931 int res1 = 0 ;
15932 PyObject *swig_obj[1] ;
15933
15934 if (!args) SWIG_fail;
15935 swig_obj[0] = args;
15936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15937 if (!SWIG_IsOK(res1)) {
15938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15939 }
15940 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15941 {
15942 PyThreadState* __tstate = wxPyBeginAllowThreads();
15943 result = (int)(arg1)->GetNumberAxes();
15944 wxPyEndAllowThreads(__tstate);
15945 if (PyErr_Occurred()) SWIG_fail;
15946 }
15947 resultobj = SWIG_From_int(static_cast< int >(result));
15948 return resultobj;
15949 fail:
15950 return NULL;
15951 }
15952
15953
15954 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15955 PyObject *resultobj = 0;
15956 wxJoystick *arg1 = (wxJoystick *) 0 ;
15957 int result;
15958 void *argp1 = 0 ;
15959 int res1 = 0 ;
15960 PyObject *swig_obj[1] ;
15961
15962 if (!args) SWIG_fail;
15963 swig_obj[0] = args;
15964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15965 if (!SWIG_IsOK(res1)) {
15966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15967 }
15968 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15969 {
15970 PyThreadState* __tstate = wxPyBeginAllowThreads();
15971 result = (int)(arg1)->GetMaxButtons();
15972 wxPyEndAllowThreads(__tstate);
15973 if (PyErr_Occurred()) SWIG_fail;
15974 }
15975 resultobj = SWIG_From_int(static_cast< int >(result));
15976 return resultobj;
15977 fail:
15978 return NULL;
15979 }
15980
15981
15982 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15983 PyObject *resultobj = 0;
15984 wxJoystick *arg1 = (wxJoystick *) 0 ;
15985 int result;
15986 void *argp1 = 0 ;
15987 int res1 = 0 ;
15988 PyObject *swig_obj[1] ;
15989
15990 if (!args) SWIG_fail;
15991 swig_obj[0] = args;
15992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15993 if (!SWIG_IsOK(res1)) {
15994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15995 }
15996 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 result = (int)(arg1)->GetMaxAxes();
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 resultobj = SWIG_From_int(static_cast< int >(result));
16004 return resultobj;
16005 fail:
16006 return NULL;
16007 }
16008
16009
16010 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16011 PyObject *resultobj = 0;
16012 wxJoystick *arg1 = (wxJoystick *) 0 ;
16013 int result;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 PyObject *swig_obj[1] ;
16017
16018 if (!args) SWIG_fail;
16019 swig_obj[0] = args;
16020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16021 if (!SWIG_IsOK(res1)) {
16022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16023 }
16024 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16025 {
16026 PyThreadState* __tstate = wxPyBeginAllowThreads();
16027 result = (int)(arg1)->GetPollingMin();
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 resultobj = SWIG_From_int(static_cast< int >(result));
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16039 PyObject *resultobj = 0;
16040 wxJoystick *arg1 = (wxJoystick *) 0 ;
16041 int result;
16042 void *argp1 = 0 ;
16043 int res1 = 0 ;
16044 PyObject *swig_obj[1] ;
16045
16046 if (!args) SWIG_fail;
16047 swig_obj[0] = args;
16048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16049 if (!SWIG_IsOK(res1)) {
16050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16051 }
16052 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16053 {
16054 PyThreadState* __tstate = wxPyBeginAllowThreads();
16055 result = (int)(arg1)->GetPollingMax();
16056 wxPyEndAllowThreads(__tstate);
16057 if (PyErr_Occurred()) SWIG_fail;
16058 }
16059 resultobj = SWIG_From_int(static_cast< int >(result));
16060 return resultobj;
16061 fail:
16062 return NULL;
16063 }
16064
16065
16066 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16067 PyObject *resultobj = 0;
16068 wxJoystick *arg1 = (wxJoystick *) 0 ;
16069 int result;
16070 void *argp1 = 0 ;
16071 int res1 = 0 ;
16072 PyObject *swig_obj[1] ;
16073
16074 if (!args) SWIG_fail;
16075 swig_obj[0] = args;
16076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16077 if (!SWIG_IsOK(res1)) {
16078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16079 }
16080 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 result = (int)(arg1)->GetRudderMin();
16084 wxPyEndAllowThreads(__tstate);
16085 if (PyErr_Occurred()) SWIG_fail;
16086 }
16087 resultobj = SWIG_From_int(static_cast< int >(result));
16088 return resultobj;
16089 fail:
16090 return NULL;
16091 }
16092
16093
16094 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16095 PyObject *resultobj = 0;
16096 wxJoystick *arg1 = (wxJoystick *) 0 ;
16097 int result;
16098 void *argp1 = 0 ;
16099 int res1 = 0 ;
16100 PyObject *swig_obj[1] ;
16101
16102 if (!args) SWIG_fail;
16103 swig_obj[0] = args;
16104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16105 if (!SWIG_IsOK(res1)) {
16106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16107 }
16108 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 result = (int)(arg1)->GetRudderMax();
16112 wxPyEndAllowThreads(__tstate);
16113 if (PyErr_Occurred()) SWIG_fail;
16114 }
16115 resultobj = SWIG_From_int(static_cast< int >(result));
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16123 PyObject *resultobj = 0;
16124 wxJoystick *arg1 = (wxJoystick *) 0 ;
16125 int result;
16126 void *argp1 = 0 ;
16127 int res1 = 0 ;
16128 PyObject *swig_obj[1] ;
16129
16130 if (!args) SWIG_fail;
16131 swig_obj[0] = args;
16132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16133 if (!SWIG_IsOK(res1)) {
16134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16135 }
16136 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16137 {
16138 PyThreadState* __tstate = wxPyBeginAllowThreads();
16139 result = (int)(arg1)->GetUMin();
16140 wxPyEndAllowThreads(__tstate);
16141 if (PyErr_Occurred()) SWIG_fail;
16142 }
16143 resultobj = SWIG_From_int(static_cast< int >(result));
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16151 PyObject *resultobj = 0;
16152 wxJoystick *arg1 = (wxJoystick *) 0 ;
16153 int result;
16154 void *argp1 = 0 ;
16155 int res1 = 0 ;
16156 PyObject *swig_obj[1] ;
16157
16158 if (!args) SWIG_fail;
16159 swig_obj[0] = args;
16160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16161 if (!SWIG_IsOK(res1)) {
16162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16163 }
16164 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16165 {
16166 PyThreadState* __tstate = wxPyBeginAllowThreads();
16167 result = (int)(arg1)->GetUMax();
16168 wxPyEndAllowThreads(__tstate);
16169 if (PyErr_Occurred()) SWIG_fail;
16170 }
16171 resultobj = SWIG_From_int(static_cast< int >(result));
16172 return resultobj;
16173 fail:
16174 return NULL;
16175 }
16176
16177
16178 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16179 PyObject *resultobj = 0;
16180 wxJoystick *arg1 = (wxJoystick *) 0 ;
16181 int result;
16182 void *argp1 = 0 ;
16183 int res1 = 0 ;
16184 PyObject *swig_obj[1] ;
16185
16186 if (!args) SWIG_fail;
16187 swig_obj[0] = args;
16188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16189 if (!SWIG_IsOK(res1)) {
16190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16191 }
16192 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 result = (int)(arg1)->GetVMin();
16196 wxPyEndAllowThreads(__tstate);
16197 if (PyErr_Occurred()) SWIG_fail;
16198 }
16199 resultobj = SWIG_From_int(static_cast< int >(result));
16200 return resultobj;
16201 fail:
16202 return NULL;
16203 }
16204
16205
16206 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16207 PyObject *resultobj = 0;
16208 wxJoystick *arg1 = (wxJoystick *) 0 ;
16209 int result;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 PyObject *swig_obj[1] ;
16213
16214 if (!args) SWIG_fail;
16215 swig_obj[0] = args;
16216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16217 if (!SWIG_IsOK(res1)) {
16218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16219 }
16220 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16221 {
16222 PyThreadState* __tstate = wxPyBeginAllowThreads();
16223 result = (int)(arg1)->GetVMax();
16224 wxPyEndAllowThreads(__tstate);
16225 if (PyErr_Occurred()) SWIG_fail;
16226 }
16227 resultobj = SWIG_From_int(static_cast< int >(result));
16228 return resultobj;
16229 fail:
16230 return NULL;
16231 }
16232
16233
16234 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16235 PyObject *resultobj = 0;
16236 wxJoystick *arg1 = (wxJoystick *) 0 ;
16237 bool result;
16238 void *argp1 = 0 ;
16239 int res1 = 0 ;
16240 PyObject *swig_obj[1] ;
16241
16242 if (!args) SWIG_fail;
16243 swig_obj[0] = args;
16244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16245 if (!SWIG_IsOK(res1)) {
16246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16247 }
16248 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16249 {
16250 PyThreadState* __tstate = wxPyBeginAllowThreads();
16251 result = (bool)(arg1)->HasRudder();
16252 wxPyEndAllowThreads(__tstate);
16253 if (PyErr_Occurred()) SWIG_fail;
16254 }
16255 {
16256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16257 }
16258 return resultobj;
16259 fail:
16260 return NULL;
16261 }
16262
16263
16264 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16265 PyObject *resultobj = 0;
16266 wxJoystick *arg1 = (wxJoystick *) 0 ;
16267 bool result;
16268 void *argp1 = 0 ;
16269 int res1 = 0 ;
16270 PyObject *swig_obj[1] ;
16271
16272 if (!args) SWIG_fail;
16273 swig_obj[0] = args;
16274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16275 if (!SWIG_IsOK(res1)) {
16276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16277 }
16278 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 result = (bool)(arg1)->HasZ();
16282 wxPyEndAllowThreads(__tstate);
16283 if (PyErr_Occurred()) SWIG_fail;
16284 }
16285 {
16286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16287 }
16288 return resultobj;
16289 fail:
16290 return NULL;
16291 }
16292
16293
16294 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16295 PyObject *resultobj = 0;
16296 wxJoystick *arg1 = (wxJoystick *) 0 ;
16297 bool result;
16298 void *argp1 = 0 ;
16299 int res1 = 0 ;
16300 PyObject *swig_obj[1] ;
16301
16302 if (!args) SWIG_fail;
16303 swig_obj[0] = args;
16304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16305 if (!SWIG_IsOK(res1)) {
16306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16307 }
16308 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16309 {
16310 PyThreadState* __tstate = wxPyBeginAllowThreads();
16311 result = (bool)(arg1)->HasU();
16312 wxPyEndAllowThreads(__tstate);
16313 if (PyErr_Occurred()) SWIG_fail;
16314 }
16315 {
16316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16317 }
16318 return resultobj;
16319 fail:
16320 return NULL;
16321 }
16322
16323
16324 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16325 PyObject *resultobj = 0;
16326 wxJoystick *arg1 = (wxJoystick *) 0 ;
16327 bool result;
16328 void *argp1 = 0 ;
16329 int res1 = 0 ;
16330 PyObject *swig_obj[1] ;
16331
16332 if (!args) SWIG_fail;
16333 swig_obj[0] = args;
16334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16335 if (!SWIG_IsOK(res1)) {
16336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16337 }
16338 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16339 {
16340 PyThreadState* __tstate = wxPyBeginAllowThreads();
16341 result = (bool)(arg1)->HasV();
16342 wxPyEndAllowThreads(__tstate);
16343 if (PyErr_Occurred()) SWIG_fail;
16344 }
16345 {
16346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16347 }
16348 return resultobj;
16349 fail:
16350 return NULL;
16351 }
16352
16353
16354 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16355 PyObject *resultobj = 0;
16356 wxJoystick *arg1 = (wxJoystick *) 0 ;
16357 bool result;
16358 void *argp1 = 0 ;
16359 int res1 = 0 ;
16360 PyObject *swig_obj[1] ;
16361
16362 if (!args) SWIG_fail;
16363 swig_obj[0] = args;
16364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16365 if (!SWIG_IsOK(res1)) {
16366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16367 }
16368 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16369 {
16370 PyThreadState* __tstate = wxPyBeginAllowThreads();
16371 result = (bool)(arg1)->HasPOV();
16372 wxPyEndAllowThreads(__tstate);
16373 if (PyErr_Occurred()) SWIG_fail;
16374 }
16375 {
16376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16377 }
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16385 PyObject *resultobj = 0;
16386 wxJoystick *arg1 = (wxJoystick *) 0 ;
16387 bool result;
16388 void *argp1 = 0 ;
16389 int res1 = 0 ;
16390 PyObject *swig_obj[1] ;
16391
16392 if (!args) SWIG_fail;
16393 swig_obj[0] = args;
16394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16395 if (!SWIG_IsOK(res1)) {
16396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16397 }
16398 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16399 {
16400 PyThreadState* __tstate = wxPyBeginAllowThreads();
16401 result = (bool)(arg1)->HasPOV4Dir();
16402 wxPyEndAllowThreads(__tstate);
16403 if (PyErr_Occurred()) SWIG_fail;
16404 }
16405 {
16406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16407 }
16408 return resultobj;
16409 fail:
16410 return NULL;
16411 }
16412
16413
16414 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16415 PyObject *resultobj = 0;
16416 wxJoystick *arg1 = (wxJoystick *) 0 ;
16417 bool result;
16418 void *argp1 = 0 ;
16419 int res1 = 0 ;
16420 PyObject *swig_obj[1] ;
16421
16422 if (!args) SWIG_fail;
16423 swig_obj[0] = args;
16424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16425 if (!SWIG_IsOK(res1)) {
16426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16427 }
16428 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16429 {
16430 PyThreadState* __tstate = wxPyBeginAllowThreads();
16431 result = (bool)(arg1)->HasPOVCTS();
16432 wxPyEndAllowThreads(__tstate);
16433 if (PyErr_Occurred()) SWIG_fail;
16434 }
16435 {
16436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16437 }
16438 return resultobj;
16439 fail:
16440 return NULL;
16441 }
16442
16443
16444 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj = 0;
16446 wxJoystick *arg1 = (wxJoystick *) 0 ;
16447 wxWindow *arg2 = (wxWindow *) 0 ;
16448 int arg3 = (int) 0 ;
16449 bool result;
16450 void *argp1 = 0 ;
16451 int res1 = 0 ;
16452 void *argp2 = 0 ;
16453 int res2 = 0 ;
16454 int val3 ;
16455 int ecode3 = 0 ;
16456 PyObject * obj0 = 0 ;
16457 PyObject * obj1 = 0 ;
16458 PyObject * obj2 = 0 ;
16459 char * kwnames[] = {
16460 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16461 };
16462
16463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16465 if (!SWIG_IsOK(res1)) {
16466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16467 }
16468 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16470 if (!SWIG_IsOK(res2)) {
16471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16472 }
16473 arg2 = reinterpret_cast< wxWindow * >(argp2);
16474 if (obj2) {
16475 ecode3 = SWIG_AsVal_int(obj2, &val3);
16476 if (!SWIG_IsOK(ecode3)) {
16477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16478 }
16479 arg3 = static_cast< int >(val3);
16480 }
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 result = (bool)(arg1)->SetCapture(arg2,arg3);
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 {
16488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16489 }
16490 return resultobj;
16491 fail:
16492 return NULL;
16493 }
16494
16495
16496 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16497 PyObject *resultobj = 0;
16498 wxJoystick *arg1 = (wxJoystick *) 0 ;
16499 bool result;
16500 void *argp1 = 0 ;
16501 int res1 = 0 ;
16502 PyObject *swig_obj[1] ;
16503
16504 if (!args) SWIG_fail;
16505 swig_obj[0] = args;
16506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16507 if (!SWIG_IsOK(res1)) {
16508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16509 }
16510 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16511 {
16512 PyThreadState* __tstate = wxPyBeginAllowThreads();
16513 result = (bool)(arg1)->ReleaseCapture();
16514 wxPyEndAllowThreads(__tstate);
16515 if (PyErr_Occurred()) SWIG_fail;
16516 }
16517 {
16518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16519 }
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16527 PyObject *obj;
16528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16529 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16530 return SWIG_Py_Void();
16531 }
16532
16533 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16534 return SWIG_Python_InitShadowInstance(args);
16535 }
16536
16537 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16538 PyObject *resultobj = 0;
16539 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16540 int arg2 = (int) 0 ;
16541 int arg3 = (int) wxJOYSTICK1 ;
16542 int arg4 = (int) 0 ;
16543 wxJoystickEvent *result = 0 ;
16544 int val1 ;
16545 int ecode1 = 0 ;
16546 int val2 ;
16547 int ecode2 = 0 ;
16548 int val3 ;
16549 int ecode3 = 0 ;
16550 int val4 ;
16551 int ecode4 = 0 ;
16552 PyObject * obj0 = 0 ;
16553 PyObject * obj1 = 0 ;
16554 PyObject * obj2 = 0 ;
16555 PyObject * obj3 = 0 ;
16556 char * kwnames[] = {
16557 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16558 };
16559
16560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16561 if (obj0) {
16562 ecode1 = SWIG_AsVal_int(obj0, &val1);
16563 if (!SWIG_IsOK(ecode1)) {
16564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16565 }
16566 arg1 = static_cast< wxEventType >(val1);
16567 }
16568 if (obj1) {
16569 ecode2 = SWIG_AsVal_int(obj1, &val2);
16570 if (!SWIG_IsOK(ecode2)) {
16571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16572 }
16573 arg2 = static_cast< int >(val2);
16574 }
16575 if (obj2) {
16576 ecode3 = SWIG_AsVal_int(obj2, &val3);
16577 if (!SWIG_IsOK(ecode3)) {
16578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16579 }
16580 arg3 = static_cast< int >(val3);
16581 }
16582 if (obj3) {
16583 ecode4 = SWIG_AsVal_int(obj3, &val4);
16584 if (!SWIG_IsOK(ecode4)) {
16585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16586 }
16587 arg4 = static_cast< int >(val4);
16588 }
16589 {
16590 PyThreadState* __tstate = wxPyBeginAllowThreads();
16591 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16592 wxPyEndAllowThreads(__tstate);
16593 if (PyErr_Occurred()) SWIG_fail;
16594 }
16595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16596 return resultobj;
16597 fail:
16598 return NULL;
16599 }
16600
16601
16602 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16603 PyObject *resultobj = 0;
16604 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16605 wxPoint result;
16606 void *argp1 = 0 ;
16607 int res1 = 0 ;
16608 PyObject *swig_obj[1] ;
16609
16610 if (!args) SWIG_fail;
16611 swig_obj[0] = args;
16612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16613 if (!SWIG_IsOK(res1)) {
16614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16615 }
16616 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16617 {
16618 PyThreadState* __tstate = wxPyBeginAllowThreads();
16619 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16620 wxPyEndAllowThreads(__tstate);
16621 if (PyErr_Occurred()) SWIG_fail;
16622 }
16623 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16624 return resultobj;
16625 fail:
16626 return NULL;
16627 }
16628
16629
16630 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16631 PyObject *resultobj = 0;
16632 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16633 int result;
16634 void *argp1 = 0 ;
16635 int res1 = 0 ;
16636 PyObject *swig_obj[1] ;
16637
16638 if (!args) SWIG_fail;
16639 swig_obj[0] = args;
16640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16641 if (!SWIG_IsOK(res1)) {
16642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16643 }
16644 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 resultobj = SWIG_From_int(static_cast< int >(result));
16652 return resultobj;
16653 fail:
16654 return NULL;
16655 }
16656
16657
16658 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16659 PyObject *resultobj = 0;
16660 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16661 int result;
16662 void *argp1 = 0 ;
16663 int res1 = 0 ;
16664 PyObject *swig_obj[1] ;
16665
16666 if (!args) SWIG_fail;
16667 swig_obj[0] = args;
16668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16669 if (!SWIG_IsOK(res1)) {
16670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16671 }
16672 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16676 wxPyEndAllowThreads(__tstate);
16677 if (PyErr_Occurred()) SWIG_fail;
16678 }
16679 resultobj = SWIG_From_int(static_cast< int >(result));
16680 return resultobj;
16681 fail:
16682 return NULL;
16683 }
16684
16685
16686 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16687 PyObject *resultobj = 0;
16688 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16689 int result;
16690 void *argp1 = 0 ;
16691 int res1 = 0 ;
16692 PyObject *swig_obj[1] ;
16693
16694 if (!args) SWIG_fail;
16695 swig_obj[0] = args;
16696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16697 if (!SWIG_IsOK(res1)) {
16698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16699 }
16700 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16704 wxPyEndAllowThreads(__tstate);
16705 if (PyErr_Occurred()) SWIG_fail;
16706 }
16707 resultobj = SWIG_From_int(static_cast< int >(result));
16708 return resultobj;
16709 fail:
16710 return NULL;
16711 }
16712
16713
16714 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16715 PyObject *resultobj = 0;
16716 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16717 int result;
16718 void *argp1 = 0 ;
16719 int res1 = 0 ;
16720 PyObject *swig_obj[1] ;
16721
16722 if (!args) SWIG_fail;
16723 swig_obj[0] = args;
16724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16725 if (!SWIG_IsOK(res1)) {
16726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16727 }
16728 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16732 wxPyEndAllowThreads(__tstate);
16733 if (PyErr_Occurred()) SWIG_fail;
16734 }
16735 resultobj = SWIG_From_int(static_cast< int >(result));
16736 return resultobj;
16737 fail:
16738 return NULL;
16739 }
16740
16741
16742 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16743 PyObject *resultobj = 0;
16744 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16745 int arg2 ;
16746 void *argp1 = 0 ;
16747 int res1 = 0 ;
16748 int val2 ;
16749 int ecode2 = 0 ;
16750 PyObject * obj0 = 0 ;
16751 PyObject * obj1 = 0 ;
16752 char * kwnames[] = {
16753 (char *) "self",(char *) "stick", NULL
16754 };
16755
16756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16760 }
16761 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16762 ecode2 = SWIG_AsVal_int(obj1, &val2);
16763 if (!SWIG_IsOK(ecode2)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16765 }
16766 arg2 = static_cast< int >(val2);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 (arg1)->SetJoystick(arg2);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_Py_Void();
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16783 int arg2 ;
16784 void *argp1 = 0 ;
16785 int res1 = 0 ;
16786 int val2 ;
16787 int ecode2 = 0 ;
16788 PyObject * obj0 = 0 ;
16789 PyObject * obj1 = 0 ;
16790 char * kwnames[] = {
16791 (char *) "self",(char *) "state", NULL
16792 };
16793
16794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16796 if (!SWIG_IsOK(res1)) {
16797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16798 }
16799 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16800 ecode2 = SWIG_AsVal_int(obj1, &val2);
16801 if (!SWIG_IsOK(ecode2)) {
16802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16803 }
16804 arg2 = static_cast< int >(val2);
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 (arg1)->SetButtonState(arg2);
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 resultobj = SWIG_Py_Void();
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16821 int arg2 ;
16822 void *argp1 = 0 ;
16823 int res1 = 0 ;
16824 int val2 ;
16825 int ecode2 = 0 ;
16826 PyObject * obj0 = 0 ;
16827 PyObject * obj1 = 0 ;
16828 char * kwnames[] = {
16829 (char *) "self",(char *) "change", NULL
16830 };
16831
16832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16834 if (!SWIG_IsOK(res1)) {
16835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16836 }
16837 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16838 ecode2 = SWIG_AsVal_int(obj1, &val2);
16839 if (!SWIG_IsOK(ecode2)) {
16840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16841 }
16842 arg2 = static_cast< int >(val2);
16843 {
16844 PyThreadState* __tstate = wxPyBeginAllowThreads();
16845 (arg1)->SetButtonChange(arg2);
16846 wxPyEndAllowThreads(__tstate);
16847 if (PyErr_Occurred()) SWIG_fail;
16848 }
16849 resultobj = SWIG_Py_Void();
16850 return resultobj;
16851 fail:
16852 return NULL;
16853 }
16854
16855
16856 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16857 PyObject *resultobj = 0;
16858 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16859 wxPoint *arg2 = 0 ;
16860 void *argp1 = 0 ;
16861 int res1 = 0 ;
16862 wxPoint temp2 ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 char * kwnames[] = {
16866 (char *) "self",(char *) "pos", NULL
16867 };
16868
16869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16871 if (!SWIG_IsOK(res1)) {
16872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16873 }
16874 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16875 {
16876 arg2 = &temp2;
16877 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16878 }
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 (arg1)->SetPosition((wxPoint const &)*arg2);
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 resultobj = SWIG_Py_Void();
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj = 0;
16894 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16895 int arg2 ;
16896 void *argp1 = 0 ;
16897 int res1 = 0 ;
16898 int val2 ;
16899 int ecode2 = 0 ;
16900 PyObject * obj0 = 0 ;
16901 PyObject * obj1 = 0 ;
16902 char * kwnames[] = {
16903 (char *) "self",(char *) "zPos", NULL
16904 };
16905
16906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16908 if (!SWIG_IsOK(res1)) {
16909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16910 }
16911 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16912 ecode2 = SWIG_AsVal_int(obj1, &val2);
16913 if (!SWIG_IsOK(ecode2)) {
16914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16915 }
16916 arg2 = static_cast< int >(val2);
16917 {
16918 PyThreadState* __tstate = wxPyBeginAllowThreads();
16919 (arg1)->SetZPosition(arg2);
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 resultobj = SWIG_Py_Void();
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16931 PyObject *resultobj = 0;
16932 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16933 bool result;
16934 void *argp1 = 0 ;
16935 int res1 = 0 ;
16936 PyObject *swig_obj[1] ;
16937
16938 if (!args) SWIG_fail;
16939 swig_obj[0] = args;
16940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16941 if (!SWIG_IsOK(res1)) {
16942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16943 }
16944 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16945 {
16946 PyThreadState* __tstate = wxPyBeginAllowThreads();
16947 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16948 wxPyEndAllowThreads(__tstate);
16949 if (PyErr_Occurred()) SWIG_fail;
16950 }
16951 {
16952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16953 }
16954 return resultobj;
16955 fail:
16956 return NULL;
16957 }
16958
16959
16960 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16961 PyObject *resultobj = 0;
16962 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16963 bool result;
16964 void *argp1 = 0 ;
16965 int res1 = 0 ;
16966 PyObject *swig_obj[1] ;
16967
16968 if (!args) SWIG_fail;
16969 swig_obj[0] = args;
16970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16971 if (!SWIG_IsOK(res1)) {
16972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16973 }
16974 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16975 {
16976 PyThreadState* __tstate = wxPyBeginAllowThreads();
16977 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16978 wxPyEndAllowThreads(__tstate);
16979 if (PyErr_Occurred()) SWIG_fail;
16980 }
16981 {
16982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16983 }
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16991 PyObject *resultobj = 0;
16992 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16993 bool result;
16994 void *argp1 = 0 ;
16995 int res1 = 0 ;
16996 PyObject *swig_obj[1] ;
16997
16998 if (!args) SWIG_fail;
16999 swig_obj[0] = args;
17000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17001 if (!SWIG_IsOK(res1)) {
17002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17003 }
17004 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17005 {
17006 PyThreadState* __tstate = wxPyBeginAllowThreads();
17007 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
17008 wxPyEndAllowThreads(__tstate);
17009 if (PyErr_Occurred()) SWIG_fail;
17010 }
17011 {
17012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17013 }
17014 return resultobj;
17015 fail:
17016 return NULL;
17017 }
17018
17019
17020 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17021 PyObject *resultobj = 0;
17022 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17023 int arg2 = (int) wxJOY_BUTTON_ANY ;
17024 bool result;
17025 void *argp1 = 0 ;
17026 int res1 = 0 ;
17027 int val2 ;
17028 int ecode2 = 0 ;
17029 PyObject * obj0 = 0 ;
17030 PyObject * obj1 = 0 ;
17031 char * kwnames[] = {
17032 (char *) "self",(char *) "but", NULL
17033 };
17034
17035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17037 if (!SWIG_IsOK(res1)) {
17038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17039 }
17040 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17041 if (obj1) {
17042 ecode2 = SWIG_AsVal_int(obj1, &val2);
17043 if (!SWIG_IsOK(ecode2)) {
17044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17045 }
17046 arg2 = static_cast< int >(val2);
17047 }
17048 {
17049 PyThreadState* __tstate = wxPyBeginAllowThreads();
17050 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17051 wxPyEndAllowThreads(__tstate);
17052 if (PyErr_Occurred()) SWIG_fail;
17053 }
17054 {
17055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17056 }
17057 return resultobj;
17058 fail:
17059 return NULL;
17060 }
17061
17062
17063 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17064 PyObject *resultobj = 0;
17065 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17066 int arg2 = (int) wxJOY_BUTTON_ANY ;
17067 bool result;
17068 void *argp1 = 0 ;
17069 int res1 = 0 ;
17070 int val2 ;
17071 int ecode2 = 0 ;
17072 PyObject * obj0 = 0 ;
17073 PyObject * obj1 = 0 ;
17074 char * kwnames[] = {
17075 (char *) "self",(char *) "but", NULL
17076 };
17077
17078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17080 if (!SWIG_IsOK(res1)) {
17081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17082 }
17083 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17084 if (obj1) {
17085 ecode2 = SWIG_AsVal_int(obj1, &val2);
17086 if (!SWIG_IsOK(ecode2)) {
17087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17088 }
17089 arg2 = static_cast< int >(val2);
17090 }
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 {
17098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17099 }
17100 return resultobj;
17101 fail:
17102 return NULL;
17103 }
17104
17105
17106 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17107 PyObject *resultobj = 0;
17108 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17109 int arg2 = (int) wxJOY_BUTTON_ANY ;
17110 bool result;
17111 void *argp1 = 0 ;
17112 int res1 = 0 ;
17113 int val2 ;
17114 int ecode2 = 0 ;
17115 PyObject * obj0 = 0 ;
17116 PyObject * obj1 = 0 ;
17117 char * kwnames[] = {
17118 (char *) "self",(char *) "but", NULL
17119 };
17120
17121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17123 if (!SWIG_IsOK(res1)) {
17124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17125 }
17126 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17127 if (obj1) {
17128 ecode2 = SWIG_AsVal_int(obj1, &val2);
17129 if (!SWIG_IsOK(ecode2)) {
17130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17131 }
17132 arg2 = static_cast< int >(val2);
17133 }
17134 {
17135 PyThreadState* __tstate = wxPyBeginAllowThreads();
17136 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17137 wxPyEndAllowThreads(__tstate);
17138 if (PyErr_Occurred()) SWIG_fail;
17139 }
17140 {
17141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17142 }
17143 return resultobj;
17144 fail:
17145 return NULL;
17146 }
17147
17148
17149 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17150 PyObject *obj;
17151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17152 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17153 return SWIG_Py_Void();
17154 }
17155
17156 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17157 return SWIG_Python_InitShadowInstance(args);
17158 }
17159
17160 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj = 0;
17162 wxString const &arg1_defvalue = wxPyEmptyString ;
17163 wxString *arg1 = (wxString *) &arg1_defvalue ;
17164 wxSound *result = 0 ;
17165 bool temp1 = false ;
17166 PyObject * obj0 = 0 ;
17167 char * kwnames[] = {
17168 (char *) "fileName", NULL
17169 };
17170
17171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17172 if (obj0) {
17173 {
17174 arg1 = wxString_in_helper(obj0);
17175 if (arg1 == NULL) SWIG_fail;
17176 temp1 = true;
17177 }
17178 }
17179 {
17180 if (!wxPyCheckForApp()) SWIG_fail;
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17187 {
17188 if (temp1)
17189 delete arg1;
17190 }
17191 return resultobj;
17192 fail:
17193 {
17194 if (temp1)
17195 delete arg1;
17196 }
17197 return NULL;
17198 }
17199
17200
17201 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17202 PyObject *resultobj = 0;
17203 PyObject *arg1 = (PyObject *) 0 ;
17204 wxSound *result = 0 ;
17205 PyObject * obj0 = 0 ;
17206 char * kwnames[] = {
17207 (char *) "data", NULL
17208 };
17209
17210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17211 arg1 = obj0;
17212 {
17213 if (!wxPyCheckForApp()) SWIG_fail;
17214 PyThreadState* __tstate = wxPyBeginAllowThreads();
17215 result = (wxSound *)new_wxSound(arg1);
17216 wxPyEndAllowThreads(__tstate);
17217 if (PyErr_Occurred()) SWIG_fail;
17218 }
17219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17227 PyObject *resultobj = 0;
17228 wxSound *arg1 = (wxSound *) 0 ;
17229 void *argp1 = 0 ;
17230 int res1 = 0 ;
17231 PyObject *swig_obj[1] ;
17232
17233 if (!args) SWIG_fail;
17234 swig_obj[0] = args;
17235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17236 if (!SWIG_IsOK(res1)) {
17237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17238 }
17239 arg1 = reinterpret_cast< wxSound * >(argp1);
17240 {
17241 PyThreadState* __tstate = wxPyBeginAllowThreads();
17242 delete arg1;
17243
17244 wxPyEndAllowThreads(__tstate);
17245 if (PyErr_Occurred()) SWIG_fail;
17246 }
17247 resultobj = SWIG_Py_Void();
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj = 0;
17256 wxSound *arg1 = (wxSound *) 0 ;
17257 wxString *arg2 = 0 ;
17258 bool result;
17259 void *argp1 = 0 ;
17260 int res1 = 0 ;
17261 bool temp2 = false ;
17262 PyObject * obj0 = 0 ;
17263 PyObject * obj1 = 0 ;
17264 char * kwnames[] = {
17265 (char *) "self",(char *) "fileName", NULL
17266 };
17267
17268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17270 if (!SWIG_IsOK(res1)) {
17271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17272 }
17273 arg1 = reinterpret_cast< wxSound * >(argp1);
17274 {
17275 arg2 = wxString_in_helper(obj1);
17276 if (arg2 == NULL) SWIG_fail;
17277 temp2 = true;
17278 }
17279 {
17280 PyThreadState* __tstate = wxPyBeginAllowThreads();
17281 result = (bool)(arg1)->Create((wxString const &)*arg2);
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 {
17286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17287 }
17288 {
17289 if (temp2)
17290 delete arg2;
17291 }
17292 return resultobj;
17293 fail:
17294 {
17295 if (temp2)
17296 delete arg2;
17297 }
17298 return NULL;
17299 }
17300
17301
17302 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17303 PyObject *resultobj = 0;
17304 wxSound *arg1 = (wxSound *) 0 ;
17305 PyObject *arg2 = (PyObject *) 0 ;
17306 bool result;
17307 void *argp1 = 0 ;
17308 int res1 = 0 ;
17309 PyObject * obj0 = 0 ;
17310 PyObject * obj1 = 0 ;
17311 char * kwnames[] = {
17312 (char *) "self",(char *) "data", NULL
17313 };
17314
17315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17317 if (!SWIG_IsOK(res1)) {
17318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17319 }
17320 arg1 = reinterpret_cast< wxSound * >(argp1);
17321 arg2 = obj1;
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (bool)wxSound_CreateFromData(arg1,arg2);
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 {
17329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17330 }
17331 return resultobj;
17332 fail:
17333 return NULL;
17334 }
17335
17336
17337 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17338 PyObject *resultobj = 0;
17339 wxSound *arg1 = (wxSound *) 0 ;
17340 bool result;
17341 void *argp1 = 0 ;
17342 int res1 = 0 ;
17343 PyObject *swig_obj[1] ;
17344
17345 if (!args) SWIG_fail;
17346 swig_obj[0] = args;
17347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17348 if (!SWIG_IsOK(res1)) {
17349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17350 }
17351 arg1 = reinterpret_cast< wxSound * >(argp1);
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (bool)(arg1)->IsOk();
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 {
17359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17360 }
17361 return resultobj;
17362 fail:
17363 return NULL;
17364 }
17365
17366
17367 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17368 PyObject *resultobj = 0;
17369 wxSound *arg1 = (wxSound *) 0 ;
17370 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17371 bool result;
17372 void *argp1 = 0 ;
17373 int res1 = 0 ;
17374 unsigned int val2 ;
17375 int ecode2 = 0 ;
17376 PyObject * obj0 = 0 ;
17377 PyObject * obj1 = 0 ;
17378 char * kwnames[] = {
17379 (char *) "self",(char *) "flags", NULL
17380 };
17381
17382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17384 if (!SWIG_IsOK(res1)) {
17385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17386 }
17387 arg1 = reinterpret_cast< wxSound * >(argp1);
17388 if (obj1) {
17389 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17390 if (!SWIG_IsOK(ecode2)) {
17391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17392 }
17393 arg2 = static_cast< unsigned int >(val2);
17394 }
17395 {
17396 if (!wxPyCheckForApp()) SWIG_fail;
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 result = (bool)((wxSound const *)arg1)->Play(arg2);
17399 wxPyEndAllowThreads(__tstate);
17400 if (PyErr_Occurred()) SWIG_fail;
17401 }
17402 {
17403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17404 }
17405 return resultobj;
17406 fail:
17407 return NULL;
17408 }
17409
17410
17411 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17412 PyObject *resultobj = 0;
17413 wxString *arg1 = 0 ;
17414 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17415 bool result;
17416 bool temp1 = false ;
17417 unsigned int val2 ;
17418 int ecode2 = 0 ;
17419 PyObject * obj0 = 0 ;
17420 PyObject * obj1 = 0 ;
17421 char * kwnames[] = {
17422 (char *) "filename",(char *) "flags", NULL
17423 };
17424
17425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17426 {
17427 arg1 = wxString_in_helper(obj0);
17428 if (arg1 == NULL) SWIG_fail;
17429 temp1 = true;
17430 }
17431 if (obj1) {
17432 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17433 if (!SWIG_IsOK(ecode2)) {
17434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17435 }
17436 arg2 = static_cast< unsigned int >(val2);
17437 }
17438 {
17439 if (!wxPyCheckForApp()) SWIG_fail;
17440 PyThreadState* __tstate = wxPyBeginAllowThreads();
17441 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17442 wxPyEndAllowThreads(__tstate);
17443 if (PyErr_Occurred()) SWIG_fail;
17444 }
17445 {
17446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17447 }
17448 {
17449 if (temp1)
17450 delete arg1;
17451 }
17452 return resultobj;
17453 fail:
17454 {
17455 if (temp1)
17456 delete arg1;
17457 }
17458 return NULL;
17459 }
17460
17461
17462 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *resultobj = 0;
17464
17465 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17466 {
17467 if (!wxPyCheckForApp()) SWIG_fail;
17468 PyThreadState* __tstate = wxPyBeginAllowThreads();
17469 wxSound::Stop();
17470 wxPyEndAllowThreads(__tstate);
17471 if (PyErr_Occurred()) SWIG_fail;
17472 }
17473 resultobj = SWIG_Py_Void();
17474 return resultobj;
17475 fail:
17476 return NULL;
17477 }
17478
17479
17480 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17481 PyObject *obj;
17482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17483 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17484 return SWIG_Py_Void();
17485 }
17486
17487 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17488 return SWIG_Python_InitShadowInstance(args);
17489 }
17490
17491 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17492 PyObject *resultobj = 0;
17493 wxString *arg1 = 0 ;
17494 wxString *arg2 = 0 ;
17495 wxString *arg3 = 0 ;
17496 wxString *arg4 = 0 ;
17497 wxFileTypeInfo *result = 0 ;
17498 bool temp1 = false ;
17499 bool temp2 = false ;
17500 bool temp3 = false ;
17501 bool temp4 = false ;
17502 PyObject * obj0 = 0 ;
17503 PyObject * obj1 = 0 ;
17504 PyObject * obj2 = 0 ;
17505 PyObject * obj3 = 0 ;
17506 char * kwnames[] = {
17507 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17508 };
17509
17510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17511 {
17512 arg1 = wxString_in_helper(obj0);
17513 if (arg1 == NULL) SWIG_fail;
17514 temp1 = true;
17515 }
17516 {
17517 arg2 = wxString_in_helper(obj1);
17518 if (arg2 == NULL) SWIG_fail;
17519 temp2 = true;
17520 }
17521 {
17522 arg3 = wxString_in_helper(obj2);
17523 if (arg3 == NULL) SWIG_fail;
17524 temp3 = true;
17525 }
17526 {
17527 arg4 = wxString_in_helper(obj3);
17528 if (arg4 == NULL) SWIG_fail;
17529 temp4 = true;
17530 }
17531 {
17532 PyThreadState* __tstate = wxPyBeginAllowThreads();
17533 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17534 wxPyEndAllowThreads(__tstate);
17535 if (PyErr_Occurred()) SWIG_fail;
17536 }
17537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17538 {
17539 if (temp1)
17540 delete arg1;
17541 }
17542 {
17543 if (temp2)
17544 delete arg2;
17545 }
17546 {
17547 if (temp3)
17548 delete arg3;
17549 }
17550 {
17551 if (temp4)
17552 delete arg4;
17553 }
17554 return resultobj;
17555 fail:
17556 {
17557 if (temp1)
17558 delete arg1;
17559 }
17560 {
17561 if (temp2)
17562 delete arg2;
17563 }
17564 {
17565 if (temp3)
17566 delete arg3;
17567 }
17568 {
17569 if (temp4)
17570 delete arg4;
17571 }
17572 return NULL;
17573 }
17574
17575
17576 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17577 PyObject *resultobj = 0;
17578 wxArrayString *arg1 = 0 ;
17579 wxFileTypeInfo *result = 0 ;
17580 bool temp1 = false ;
17581 PyObject * obj0 = 0 ;
17582 char * kwnames[] = {
17583 (char *) "sArray", NULL
17584 };
17585
17586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17587 {
17588 if (! PySequence_Check(obj0)) {
17589 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17590 SWIG_fail;
17591 }
17592 arg1 = new wxArrayString;
17593 temp1 = true;
17594 int i, len=PySequence_Length(obj0);
17595 for (i=0; i<len; i++) {
17596 PyObject* item = PySequence_GetItem(obj0, i);
17597 wxString* s = wxString_in_helper(item);
17598 if (PyErr_Occurred()) SWIG_fail;
17599 arg1->Add(*s);
17600 delete s;
17601 Py_DECREF(item);
17602 }
17603 }
17604 {
17605 PyThreadState* __tstate = wxPyBeginAllowThreads();
17606 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17607 wxPyEndAllowThreads(__tstate);
17608 if (PyErr_Occurred()) SWIG_fail;
17609 }
17610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17611 {
17612 if (temp1) delete arg1;
17613 }
17614 return resultobj;
17615 fail:
17616 {
17617 if (temp1) delete arg1;
17618 }
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17624 PyObject *resultobj = 0;
17625 wxFileTypeInfo *result = 0 ;
17626
17627 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17628 {
17629 PyThreadState* __tstate = wxPyBeginAllowThreads();
17630 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17631 wxPyEndAllowThreads(__tstate);
17632 if (PyErr_Occurred()) SWIG_fail;
17633 }
17634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17635 return resultobj;
17636 fail:
17637 return NULL;
17638 }
17639
17640
17641 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17642 PyObject *resultobj = 0;
17643 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17644 bool result;
17645 void *argp1 = 0 ;
17646 int res1 = 0 ;
17647 PyObject *swig_obj[1] ;
17648
17649 if (!args) SWIG_fail;
17650 swig_obj[0] = args;
17651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17652 if (!SWIG_IsOK(res1)) {
17653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17654 }
17655 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17656 {
17657 PyThreadState* __tstate = wxPyBeginAllowThreads();
17658 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17659 wxPyEndAllowThreads(__tstate);
17660 if (PyErr_Occurred()) SWIG_fail;
17661 }
17662 {
17663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17664 }
17665 return resultobj;
17666 fail:
17667 return NULL;
17668 }
17669
17670
17671 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17672 PyObject *resultobj = 0;
17673 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17674 wxString *arg2 = 0 ;
17675 int arg3 = (int) 0 ;
17676 void *argp1 = 0 ;
17677 int res1 = 0 ;
17678 bool temp2 = false ;
17679 int val3 ;
17680 int ecode3 = 0 ;
17681 PyObject * obj0 = 0 ;
17682 PyObject * obj1 = 0 ;
17683 PyObject * obj2 = 0 ;
17684 char * kwnames[] = {
17685 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17686 };
17687
17688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17690 if (!SWIG_IsOK(res1)) {
17691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17692 }
17693 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17694 {
17695 arg2 = wxString_in_helper(obj1);
17696 if (arg2 == NULL) SWIG_fail;
17697 temp2 = true;
17698 }
17699 if (obj2) {
17700 ecode3 = SWIG_AsVal_int(obj2, &val3);
17701 if (!SWIG_IsOK(ecode3)) {
17702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17703 }
17704 arg3 = static_cast< int >(val3);
17705 }
17706 {
17707 PyThreadState* __tstate = wxPyBeginAllowThreads();
17708 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 resultobj = SWIG_Py_Void();
17713 {
17714 if (temp2)
17715 delete arg2;
17716 }
17717 return resultobj;
17718 fail:
17719 {
17720 if (temp2)
17721 delete arg2;
17722 }
17723 return NULL;
17724 }
17725
17726
17727 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17728 PyObject *resultobj = 0;
17729 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17730 wxString *arg2 = 0 ;
17731 void *argp1 = 0 ;
17732 int res1 = 0 ;
17733 bool temp2 = false ;
17734 PyObject * obj0 = 0 ;
17735 PyObject * obj1 = 0 ;
17736 char * kwnames[] = {
17737 (char *) "self",(char *) "shortDesc", NULL
17738 };
17739
17740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17742 if (!SWIG_IsOK(res1)) {
17743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17744 }
17745 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17746 {
17747 arg2 = wxString_in_helper(obj1);
17748 if (arg2 == NULL) SWIG_fail;
17749 temp2 = true;
17750 }
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 (arg1)->SetShortDesc((wxString const &)*arg2);
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 resultobj = SWIG_Py_Void();
17758 {
17759 if (temp2)
17760 delete arg2;
17761 }
17762 return resultobj;
17763 fail:
17764 {
17765 if (temp2)
17766 delete arg2;
17767 }
17768 return NULL;
17769 }
17770
17771
17772 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17773 PyObject *resultobj = 0;
17774 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17775 wxString *result = 0 ;
17776 void *argp1 = 0 ;
17777 int res1 = 0 ;
17778 PyObject *swig_obj[1] ;
17779
17780 if (!args) SWIG_fail;
17781 swig_obj[0] = args;
17782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17783 if (!SWIG_IsOK(res1)) {
17784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17785 }
17786 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17787 {
17788 PyThreadState* __tstate = wxPyBeginAllowThreads();
17789 {
17790 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17791 result = (wxString *) &_result_ref;
17792 }
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 {
17797 #if wxUSE_UNICODE
17798 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17799 #else
17800 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17801 #endif
17802 }
17803 return resultobj;
17804 fail:
17805 return NULL;
17806 }
17807
17808
17809 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17810 PyObject *resultobj = 0;
17811 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17812 wxString *result = 0 ;
17813 void *argp1 = 0 ;
17814 int res1 = 0 ;
17815 PyObject *swig_obj[1] ;
17816
17817 if (!args) SWIG_fail;
17818 swig_obj[0] = args;
17819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17820 if (!SWIG_IsOK(res1)) {
17821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17822 }
17823 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17824 {
17825 PyThreadState* __tstate = wxPyBeginAllowThreads();
17826 {
17827 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17828 result = (wxString *) &_result_ref;
17829 }
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 {
17834 #if wxUSE_UNICODE
17835 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17836 #else
17837 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17838 #endif
17839 }
17840 return resultobj;
17841 fail:
17842 return NULL;
17843 }
17844
17845
17846 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17847 PyObject *resultobj = 0;
17848 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17849 wxString *result = 0 ;
17850 void *argp1 = 0 ;
17851 int res1 = 0 ;
17852 PyObject *swig_obj[1] ;
17853
17854 if (!args) SWIG_fail;
17855 swig_obj[0] = args;
17856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17857 if (!SWIG_IsOK(res1)) {
17858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17859 }
17860 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 {
17864 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17865 result = (wxString *) &_result_ref;
17866 }
17867 wxPyEndAllowThreads(__tstate);
17868 if (PyErr_Occurred()) SWIG_fail;
17869 }
17870 {
17871 #if wxUSE_UNICODE
17872 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17873 #else
17874 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17875 #endif
17876 }
17877 return resultobj;
17878 fail:
17879 return NULL;
17880 }
17881
17882
17883 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17884 PyObject *resultobj = 0;
17885 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17886 wxString *result = 0 ;
17887 void *argp1 = 0 ;
17888 int res1 = 0 ;
17889 PyObject *swig_obj[1] ;
17890
17891 if (!args) SWIG_fail;
17892 swig_obj[0] = args;
17893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17894 if (!SWIG_IsOK(res1)) {
17895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17896 }
17897 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17898 {
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 {
17901 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17902 result = (wxString *) &_result_ref;
17903 }
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 {
17908 #if wxUSE_UNICODE
17909 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17910 #else
17911 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17912 #endif
17913 }
17914 return resultobj;
17915 fail:
17916 return NULL;
17917 }
17918
17919
17920 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17921 PyObject *resultobj = 0;
17922 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17923 wxString *result = 0 ;
17924 void *argp1 = 0 ;
17925 int res1 = 0 ;
17926 PyObject *swig_obj[1] ;
17927
17928 if (!args) SWIG_fail;
17929 swig_obj[0] = args;
17930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17931 if (!SWIG_IsOK(res1)) {
17932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17933 }
17934 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17935 {
17936 PyThreadState* __tstate = wxPyBeginAllowThreads();
17937 {
17938 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17939 result = (wxString *) &_result_ref;
17940 }
17941 wxPyEndAllowThreads(__tstate);
17942 if (PyErr_Occurred()) SWIG_fail;
17943 }
17944 {
17945 #if wxUSE_UNICODE
17946 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17947 #else
17948 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17949 #endif
17950 }
17951 return resultobj;
17952 fail:
17953 return NULL;
17954 }
17955
17956
17957 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17958 PyObject *resultobj = 0;
17959 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17960 wxArrayString *result = 0 ;
17961 void *argp1 = 0 ;
17962 int res1 = 0 ;
17963 PyObject *swig_obj[1] ;
17964
17965 if (!args) SWIG_fail;
17966 swig_obj[0] = args;
17967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17968 if (!SWIG_IsOK(res1)) {
17969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17970 }
17971 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 {
17975 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17976 result = (wxArrayString *) &_result_ref;
17977 }
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 {
17982 resultobj = wxArrayString2PyList_helper(*result);
17983 }
17984 return resultobj;
17985 fail:
17986 return NULL;
17987 }
17988
17989
17990 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17991 PyObject *resultobj = 0;
17992 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17993 size_t result;
17994 void *argp1 = 0 ;
17995 int res1 = 0 ;
17996 PyObject *swig_obj[1] ;
17997
17998 if (!args) SWIG_fail;
17999 swig_obj[0] = args;
18000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18001 if (!SWIG_IsOK(res1)) {
18002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18003 }
18004 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18012 return resultobj;
18013 fail:
18014 return NULL;
18015 }
18016
18017
18018 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18019 PyObject *resultobj = 0;
18020 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18021 wxString *result = 0 ;
18022 void *argp1 = 0 ;
18023 int res1 = 0 ;
18024 PyObject *swig_obj[1] ;
18025
18026 if (!args) SWIG_fail;
18027 swig_obj[0] = args;
18028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18029 if (!SWIG_IsOK(res1)) {
18030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18031 }
18032 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18033 {
18034 PyThreadState* __tstate = wxPyBeginAllowThreads();
18035 {
18036 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18037 result = (wxString *) &_result_ref;
18038 }
18039 wxPyEndAllowThreads(__tstate);
18040 if (PyErr_Occurred()) SWIG_fail;
18041 }
18042 {
18043 #if wxUSE_UNICODE
18044 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18045 #else
18046 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18047 #endif
18048 }
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18056 PyObject *resultobj = 0;
18057 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18058 int result;
18059 void *argp1 = 0 ;
18060 int res1 = 0 ;
18061 PyObject *swig_obj[1] ;
18062
18063 if (!args) SWIG_fail;
18064 swig_obj[0] = args;
18065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18066 if (!SWIG_IsOK(res1)) {
18067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18068 }
18069 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18070 {
18071 PyThreadState* __tstate = wxPyBeginAllowThreads();
18072 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18073 wxPyEndAllowThreads(__tstate);
18074 if (PyErr_Occurred()) SWIG_fail;
18075 }
18076 resultobj = SWIG_From_int(static_cast< int >(result));
18077 return resultobj;
18078 fail:
18079 return NULL;
18080 }
18081
18082
18083 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18084 PyObject *obj;
18085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18086 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18087 return SWIG_Py_Void();
18088 }
18089
18090 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18091 return SWIG_Python_InitShadowInstance(args);
18092 }
18093
18094 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18095 PyObject *resultobj = 0;
18096 wxFileTypeInfo *arg1 = 0 ;
18097 wxFileType *result = 0 ;
18098 void *argp1 = 0 ;
18099 int res1 = 0 ;
18100 PyObject * obj0 = 0 ;
18101 char * kwnames[] = {
18102 (char *) "ftInfo", NULL
18103 };
18104
18105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18106 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18107 if (!SWIG_IsOK(res1)) {
18108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18109 }
18110 if (!argp1) {
18111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18112 }
18113 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18128 PyObject *resultobj = 0;
18129 wxFileType *arg1 = (wxFileType *) 0 ;
18130 void *argp1 = 0 ;
18131 int res1 = 0 ;
18132 PyObject *swig_obj[1] ;
18133
18134 if (!args) SWIG_fail;
18135 swig_obj[0] = args;
18136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18137 if (!SWIG_IsOK(res1)) {
18138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18139 }
18140 arg1 = reinterpret_cast< wxFileType * >(argp1);
18141 {
18142 PyThreadState* __tstate = wxPyBeginAllowThreads();
18143 delete arg1;
18144
18145 wxPyEndAllowThreads(__tstate);
18146 if (PyErr_Occurred()) SWIG_fail;
18147 }
18148 resultobj = SWIG_Py_Void();
18149 return resultobj;
18150 fail:
18151 return NULL;
18152 }
18153
18154
18155 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18156 PyObject *resultobj = 0;
18157 wxFileType *arg1 = (wxFileType *) 0 ;
18158 PyObject *result = 0 ;
18159 void *argp1 = 0 ;
18160 int res1 = 0 ;
18161 PyObject *swig_obj[1] ;
18162
18163 if (!args) SWIG_fail;
18164 swig_obj[0] = args;
18165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18166 if (!SWIG_IsOK(res1)) {
18167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18168 }
18169 arg1 = reinterpret_cast< wxFileType * >(argp1);
18170 {
18171 PyThreadState* __tstate = wxPyBeginAllowThreads();
18172 result = (PyObject *)wxFileType_GetMimeType(arg1);
18173 wxPyEndAllowThreads(__tstate);
18174 if (PyErr_Occurred()) SWIG_fail;
18175 }
18176 resultobj = result;
18177 return resultobj;
18178 fail:
18179 return NULL;
18180 }
18181
18182
18183 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18184 PyObject *resultobj = 0;
18185 wxFileType *arg1 = (wxFileType *) 0 ;
18186 PyObject *result = 0 ;
18187 void *argp1 = 0 ;
18188 int res1 = 0 ;
18189 PyObject *swig_obj[1] ;
18190
18191 if (!args) SWIG_fail;
18192 swig_obj[0] = args;
18193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18194 if (!SWIG_IsOK(res1)) {
18195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18196 }
18197 arg1 = reinterpret_cast< wxFileType * >(argp1);
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 resultobj = result;
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18212 PyObject *resultobj = 0;
18213 wxFileType *arg1 = (wxFileType *) 0 ;
18214 PyObject *result = 0 ;
18215 void *argp1 = 0 ;
18216 int res1 = 0 ;
18217 PyObject *swig_obj[1] ;
18218
18219 if (!args) SWIG_fail;
18220 swig_obj[0] = args;
18221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18222 if (!SWIG_IsOK(res1)) {
18223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18224 }
18225 arg1 = reinterpret_cast< wxFileType * >(argp1);
18226 {
18227 PyThreadState* __tstate = wxPyBeginAllowThreads();
18228 result = (PyObject *)wxFileType_GetExtensions(arg1);
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 resultobj = result;
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18240 PyObject *resultobj = 0;
18241 wxFileType *arg1 = (wxFileType *) 0 ;
18242 wxIcon *result = 0 ;
18243 void *argp1 = 0 ;
18244 int res1 = 0 ;
18245 PyObject *swig_obj[1] ;
18246
18247 if (!args) SWIG_fail;
18248 swig_obj[0] = args;
18249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18250 if (!SWIG_IsOK(res1)) {
18251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18252 }
18253 arg1 = reinterpret_cast< wxFileType * >(argp1);
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 result = (wxIcon *)wxFileType_GetIcon(arg1);
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *resultobj = 0;
18269 wxFileType *arg1 = (wxFileType *) 0 ;
18270 PyObject *result = 0 ;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 PyObject *swig_obj[1] ;
18274
18275 if (!args) SWIG_fail;
18276 swig_obj[0] = args;
18277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18278 if (!SWIG_IsOK(res1)) {
18279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18280 }
18281 arg1 = reinterpret_cast< wxFileType * >(argp1);
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 resultobj = result;
18289 return resultobj;
18290 fail:
18291 return NULL;
18292 }
18293
18294
18295 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18296 PyObject *resultobj = 0;
18297 wxFileType *arg1 = (wxFileType *) 0 ;
18298 PyObject *result = 0 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 PyObject *swig_obj[1] ;
18302
18303 if (!args) SWIG_fail;
18304 swig_obj[0] = args;
18305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18306 if (!SWIG_IsOK(res1)) {
18307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18308 }
18309 arg1 = reinterpret_cast< wxFileType * >(argp1);
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 result = (PyObject *)wxFileType_GetDescription(arg1);
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 resultobj = result;
18317 return resultobj;
18318 fail:
18319 return NULL;
18320 }
18321
18322
18323 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18324 PyObject *resultobj = 0;
18325 wxFileType *arg1 = (wxFileType *) 0 ;
18326 wxString *arg2 = 0 ;
18327 wxString const &arg3_defvalue = wxPyEmptyString ;
18328 wxString *arg3 = (wxString *) &arg3_defvalue ;
18329 PyObject *result = 0 ;
18330 void *argp1 = 0 ;
18331 int res1 = 0 ;
18332 bool temp2 = false ;
18333 bool temp3 = false ;
18334 PyObject * obj0 = 0 ;
18335 PyObject * obj1 = 0 ;
18336 PyObject * obj2 = 0 ;
18337 char * kwnames[] = {
18338 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18339 };
18340
18341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18343 if (!SWIG_IsOK(res1)) {
18344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18345 }
18346 arg1 = reinterpret_cast< wxFileType * >(argp1);
18347 {
18348 arg2 = wxString_in_helper(obj1);
18349 if (arg2 == NULL) SWIG_fail;
18350 temp2 = true;
18351 }
18352 if (obj2) {
18353 {
18354 arg3 = wxString_in_helper(obj2);
18355 if (arg3 == NULL) SWIG_fail;
18356 temp3 = true;
18357 }
18358 }
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18362 wxPyEndAllowThreads(__tstate);
18363 if (PyErr_Occurred()) SWIG_fail;
18364 }
18365 resultobj = result;
18366 {
18367 if (temp2)
18368 delete arg2;
18369 }
18370 {
18371 if (temp3)
18372 delete arg3;
18373 }
18374 return resultobj;
18375 fail:
18376 {
18377 if (temp2)
18378 delete arg2;
18379 }
18380 {
18381 if (temp3)
18382 delete arg3;
18383 }
18384 return NULL;
18385 }
18386
18387
18388 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18389 PyObject *resultobj = 0;
18390 wxFileType *arg1 = (wxFileType *) 0 ;
18391 wxString *arg2 = 0 ;
18392 wxString const &arg3_defvalue = wxPyEmptyString ;
18393 wxString *arg3 = (wxString *) &arg3_defvalue ;
18394 PyObject *result = 0 ;
18395 void *argp1 = 0 ;
18396 int res1 = 0 ;
18397 bool temp2 = false ;
18398 bool temp3 = false ;
18399 PyObject * obj0 = 0 ;
18400 PyObject * obj1 = 0 ;
18401 PyObject * obj2 = 0 ;
18402 char * kwnames[] = {
18403 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18404 };
18405
18406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18408 if (!SWIG_IsOK(res1)) {
18409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18410 }
18411 arg1 = reinterpret_cast< wxFileType * >(argp1);
18412 {
18413 arg2 = wxString_in_helper(obj1);
18414 if (arg2 == NULL) SWIG_fail;
18415 temp2 = true;
18416 }
18417 if (obj2) {
18418 {
18419 arg3 = wxString_in_helper(obj2);
18420 if (arg3 == NULL) SWIG_fail;
18421 temp3 = true;
18422 }
18423 }
18424 {
18425 PyThreadState* __tstate = wxPyBeginAllowThreads();
18426 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18427 wxPyEndAllowThreads(__tstate);
18428 if (PyErr_Occurred()) SWIG_fail;
18429 }
18430 resultobj = result;
18431 {
18432 if (temp2)
18433 delete arg2;
18434 }
18435 {
18436 if (temp3)
18437 delete arg3;
18438 }
18439 return resultobj;
18440 fail:
18441 {
18442 if (temp2)
18443 delete arg2;
18444 }
18445 {
18446 if (temp3)
18447 delete arg3;
18448 }
18449 return NULL;
18450 }
18451
18452
18453 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18454 PyObject *resultobj = 0;
18455 wxFileType *arg1 = (wxFileType *) 0 ;
18456 wxString *arg2 = 0 ;
18457 wxString const &arg3_defvalue = wxPyEmptyString ;
18458 wxString *arg3 = (wxString *) &arg3_defvalue ;
18459 PyObject *result = 0 ;
18460 void *argp1 = 0 ;
18461 int res1 = 0 ;
18462 bool temp2 = false ;
18463 bool temp3 = false ;
18464 PyObject * obj0 = 0 ;
18465 PyObject * obj1 = 0 ;
18466 PyObject * obj2 = 0 ;
18467 char * kwnames[] = {
18468 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18469 };
18470
18471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18473 if (!SWIG_IsOK(res1)) {
18474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18475 }
18476 arg1 = reinterpret_cast< wxFileType * >(argp1);
18477 {
18478 arg2 = wxString_in_helper(obj1);
18479 if (arg2 == NULL) SWIG_fail;
18480 temp2 = true;
18481 }
18482 if (obj2) {
18483 {
18484 arg3 = wxString_in_helper(obj2);
18485 if (arg3 == NULL) SWIG_fail;
18486 temp3 = true;
18487 }
18488 }
18489 {
18490 PyThreadState* __tstate = wxPyBeginAllowThreads();
18491 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18492 wxPyEndAllowThreads(__tstate);
18493 if (PyErr_Occurred()) SWIG_fail;
18494 }
18495 resultobj = result;
18496 {
18497 if (temp2)
18498 delete arg2;
18499 }
18500 {
18501 if (temp3)
18502 delete arg3;
18503 }
18504 return resultobj;
18505 fail:
18506 {
18507 if (temp2)
18508 delete arg2;
18509 }
18510 {
18511 if (temp3)
18512 delete arg3;
18513 }
18514 return NULL;
18515 }
18516
18517
18518 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18519 PyObject *resultobj = 0;
18520 wxFileType *arg1 = (wxFileType *) 0 ;
18521 wxString *arg2 = 0 ;
18522 wxString *arg3 = 0 ;
18523 bool arg4 = (bool) true ;
18524 bool result;
18525 void *argp1 = 0 ;
18526 int res1 = 0 ;
18527 bool temp2 = false ;
18528 bool temp3 = false ;
18529 bool val4 ;
18530 int ecode4 = 0 ;
18531 PyObject * obj0 = 0 ;
18532 PyObject * obj1 = 0 ;
18533 PyObject * obj2 = 0 ;
18534 PyObject * obj3 = 0 ;
18535 char * kwnames[] = {
18536 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18537 };
18538
18539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18541 if (!SWIG_IsOK(res1)) {
18542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18543 }
18544 arg1 = reinterpret_cast< wxFileType * >(argp1);
18545 {
18546 arg2 = wxString_in_helper(obj1);
18547 if (arg2 == NULL) SWIG_fail;
18548 temp2 = true;
18549 }
18550 {
18551 arg3 = wxString_in_helper(obj2);
18552 if (arg3 == NULL) SWIG_fail;
18553 temp3 = true;
18554 }
18555 if (obj3) {
18556 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18557 if (!SWIG_IsOK(ecode4)) {
18558 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18559 }
18560 arg4 = static_cast< bool >(val4);
18561 }
18562 {
18563 PyThreadState* __tstate = wxPyBeginAllowThreads();
18564 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18565 wxPyEndAllowThreads(__tstate);
18566 if (PyErr_Occurred()) SWIG_fail;
18567 }
18568 {
18569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18570 }
18571 {
18572 if (temp2)
18573 delete arg2;
18574 }
18575 {
18576 if (temp3)
18577 delete arg3;
18578 }
18579 return resultobj;
18580 fail:
18581 {
18582 if (temp2)
18583 delete arg2;
18584 }
18585 {
18586 if (temp3)
18587 delete arg3;
18588 }
18589 return NULL;
18590 }
18591
18592
18593 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18594 PyObject *resultobj = 0;
18595 wxFileType *arg1 = (wxFileType *) 0 ;
18596 wxString const &arg2_defvalue = wxPyEmptyString ;
18597 wxString *arg2 = (wxString *) &arg2_defvalue ;
18598 int arg3 = (int) 0 ;
18599 bool result;
18600 void *argp1 = 0 ;
18601 int res1 = 0 ;
18602 bool temp2 = false ;
18603 int val3 ;
18604 int ecode3 = 0 ;
18605 PyObject * obj0 = 0 ;
18606 PyObject * obj1 = 0 ;
18607 PyObject * obj2 = 0 ;
18608 char * kwnames[] = {
18609 (char *) "self",(char *) "cmd",(char *) "index", NULL
18610 };
18611
18612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18614 if (!SWIG_IsOK(res1)) {
18615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18616 }
18617 arg1 = reinterpret_cast< wxFileType * >(argp1);
18618 if (obj1) {
18619 {
18620 arg2 = wxString_in_helper(obj1);
18621 if (arg2 == NULL) SWIG_fail;
18622 temp2 = true;
18623 }
18624 }
18625 if (obj2) {
18626 ecode3 = SWIG_AsVal_int(obj2, &val3);
18627 if (!SWIG_IsOK(ecode3)) {
18628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18629 }
18630 arg3 = static_cast< int >(val3);
18631 }
18632 {
18633 PyThreadState* __tstate = wxPyBeginAllowThreads();
18634 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18635 wxPyEndAllowThreads(__tstate);
18636 if (PyErr_Occurred()) SWIG_fail;
18637 }
18638 {
18639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18640 }
18641 {
18642 if (temp2)
18643 delete arg2;
18644 }
18645 return resultobj;
18646 fail:
18647 {
18648 if (temp2)
18649 delete arg2;
18650 }
18651 return NULL;
18652 }
18653
18654
18655 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18656 PyObject *resultobj = 0;
18657 wxFileType *arg1 = (wxFileType *) 0 ;
18658 bool result;
18659 void *argp1 = 0 ;
18660 int res1 = 0 ;
18661 PyObject *swig_obj[1] ;
18662
18663 if (!args) SWIG_fail;
18664 swig_obj[0] = args;
18665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18666 if (!SWIG_IsOK(res1)) {
18667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18668 }
18669 arg1 = reinterpret_cast< wxFileType * >(argp1);
18670 {
18671 PyThreadState* __tstate = wxPyBeginAllowThreads();
18672 result = (bool)(arg1)->Unassociate();
18673 wxPyEndAllowThreads(__tstate);
18674 if (PyErr_Occurred()) SWIG_fail;
18675 }
18676 {
18677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18678 }
18679 return resultobj;
18680 fail:
18681 return NULL;
18682 }
18683
18684
18685 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18686 PyObject *resultobj = 0;
18687 wxString *arg1 = 0 ;
18688 wxString *arg2 = 0 ;
18689 wxString const &arg3_defvalue = wxPyEmptyString ;
18690 wxString *arg3 = (wxString *) &arg3_defvalue ;
18691 wxString result;
18692 bool temp1 = false ;
18693 bool temp2 = false ;
18694 bool temp3 = false ;
18695 PyObject * obj0 = 0 ;
18696 PyObject * obj1 = 0 ;
18697 PyObject * obj2 = 0 ;
18698 char * kwnames[] = {
18699 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18700 };
18701
18702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18703 {
18704 arg1 = wxString_in_helper(obj0);
18705 if (arg1 == NULL) SWIG_fail;
18706 temp1 = true;
18707 }
18708 {
18709 arg2 = wxString_in_helper(obj1);
18710 if (arg2 == NULL) SWIG_fail;
18711 temp2 = true;
18712 }
18713 if (obj2) {
18714 {
18715 arg3 = wxString_in_helper(obj2);
18716 if (arg3 == NULL) SWIG_fail;
18717 temp3 = true;
18718 }
18719 }
18720 {
18721 PyThreadState* __tstate = wxPyBeginAllowThreads();
18722 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18723 wxPyEndAllowThreads(__tstate);
18724 if (PyErr_Occurred()) SWIG_fail;
18725 }
18726 {
18727 #if wxUSE_UNICODE
18728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18729 #else
18730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18731 #endif
18732 }
18733 {
18734 if (temp1)
18735 delete arg1;
18736 }
18737 {
18738 if (temp2)
18739 delete arg2;
18740 }
18741 {
18742 if (temp3)
18743 delete arg3;
18744 }
18745 return resultobj;
18746 fail:
18747 {
18748 if (temp1)
18749 delete arg1;
18750 }
18751 {
18752 if (temp2)
18753 delete arg2;
18754 }
18755 {
18756 if (temp3)
18757 delete arg3;
18758 }
18759 return NULL;
18760 }
18761
18762
18763 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18764 PyObject *obj;
18765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18766 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18767 return SWIG_Py_Void();
18768 }
18769
18770 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771 return SWIG_Python_InitShadowInstance(args);
18772 }
18773
18774 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18775 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18776 return 1;
18777 }
18778
18779
18780 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18781 PyObject *pyobj = 0;
18782
18783 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18784 return pyobj;
18785 }
18786
18787
18788 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18789 PyObject *resultobj = 0;
18790 wxString *arg1 = 0 ;
18791 wxString *arg2 = 0 ;
18792 bool result;
18793 bool temp1 = false ;
18794 bool temp2 = false ;
18795 PyObject * obj0 = 0 ;
18796 PyObject * obj1 = 0 ;
18797 char * kwnames[] = {
18798 (char *) "mimeType",(char *) "wildcard", NULL
18799 };
18800
18801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18802 {
18803 arg1 = wxString_in_helper(obj0);
18804 if (arg1 == NULL) SWIG_fail;
18805 temp1 = true;
18806 }
18807 {
18808 arg2 = wxString_in_helper(obj1);
18809 if (arg2 == NULL) SWIG_fail;
18810 temp2 = true;
18811 }
18812 {
18813 PyThreadState* __tstate = wxPyBeginAllowThreads();
18814 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18815 wxPyEndAllowThreads(__tstate);
18816 if (PyErr_Occurred()) SWIG_fail;
18817 }
18818 {
18819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18820 }
18821 {
18822 if (temp1)
18823 delete arg1;
18824 }
18825 {
18826 if (temp2)
18827 delete arg2;
18828 }
18829 return resultobj;
18830 fail:
18831 {
18832 if (temp1)
18833 delete arg1;
18834 }
18835 {
18836 if (temp2)
18837 delete arg2;
18838 }
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18844 PyObject *resultobj = 0;
18845 wxMimeTypesManager *result = 0 ;
18846
18847 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18848 {
18849 PyThreadState* __tstate = wxPyBeginAllowThreads();
18850 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18851 wxPyEndAllowThreads(__tstate);
18852 if (PyErr_Occurred()) SWIG_fail;
18853 }
18854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18855 return resultobj;
18856 fail:
18857 return NULL;
18858 }
18859
18860
18861 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18862 PyObject *resultobj = 0;
18863 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18864 int arg2 = (int) wxMAILCAP_ALL ;
18865 wxString const &arg3_defvalue = wxPyEmptyString ;
18866 wxString *arg3 = (wxString *) &arg3_defvalue ;
18867 void *argp1 = 0 ;
18868 int res1 = 0 ;
18869 int val2 ;
18870 int ecode2 = 0 ;
18871 bool temp3 = false ;
18872 PyObject * obj0 = 0 ;
18873 PyObject * obj1 = 0 ;
18874 PyObject * obj2 = 0 ;
18875 char * kwnames[] = {
18876 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18877 };
18878
18879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18881 if (!SWIG_IsOK(res1)) {
18882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18883 }
18884 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18885 if (obj1) {
18886 ecode2 = SWIG_AsVal_int(obj1, &val2);
18887 if (!SWIG_IsOK(ecode2)) {
18888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18889 }
18890 arg2 = static_cast< int >(val2);
18891 }
18892 if (obj2) {
18893 {
18894 arg3 = wxString_in_helper(obj2);
18895 if (arg3 == NULL) SWIG_fail;
18896 temp3 = true;
18897 }
18898 }
18899 {
18900 PyThreadState* __tstate = wxPyBeginAllowThreads();
18901 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18902 wxPyEndAllowThreads(__tstate);
18903 if (PyErr_Occurred()) SWIG_fail;
18904 }
18905 resultobj = SWIG_Py_Void();
18906 {
18907 if (temp3)
18908 delete arg3;
18909 }
18910 return resultobj;
18911 fail:
18912 {
18913 if (temp3)
18914 delete arg3;
18915 }
18916 return NULL;
18917 }
18918
18919
18920 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18921 PyObject *resultobj = 0;
18922 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18923 void *argp1 = 0 ;
18924 int res1 = 0 ;
18925 PyObject *swig_obj[1] ;
18926
18927 if (!args) SWIG_fail;
18928 swig_obj[0] = args;
18929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18930 if (!SWIG_IsOK(res1)) {
18931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18932 }
18933 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 (arg1)->ClearData();
18937 wxPyEndAllowThreads(__tstate);
18938 if (PyErr_Occurred()) SWIG_fail;
18939 }
18940 resultobj = SWIG_Py_Void();
18941 return resultobj;
18942 fail:
18943 return NULL;
18944 }
18945
18946
18947 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18948 PyObject *resultobj = 0;
18949 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18950 wxString *arg2 = 0 ;
18951 wxFileType *result = 0 ;
18952 void *argp1 = 0 ;
18953 int res1 = 0 ;
18954 bool temp2 = false ;
18955 PyObject * obj0 = 0 ;
18956 PyObject * obj1 = 0 ;
18957 char * kwnames[] = {
18958 (char *) "self",(char *) "ext", NULL
18959 };
18960
18961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18963 if (!SWIG_IsOK(res1)) {
18964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18965 }
18966 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18967 {
18968 arg2 = wxString_in_helper(obj1);
18969 if (arg2 == NULL) SWIG_fail;
18970 temp2 = true;
18971 }
18972 {
18973 PyThreadState* __tstate = wxPyBeginAllowThreads();
18974 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18975 wxPyEndAllowThreads(__tstate);
18976 if (PyErr_Occurred()) SWIG_fail;
18977 }
18978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18979 {
18980 if (temp2)
18981 delete arg2;
18982 }
18983 return resultobj;
18984 fail:
18985 {
18986 if (temp2)
18987 delete arg2;
18988 }
18989 return NULL;
18990 }
18991
18992
18993 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj = 0;
18995 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18996 wxString *arg2 = 0 ;
18997 wxFileType *result = 0 ;
18998 void *argp1 = 0 ;
18999 int res1 = 0 ;
19000 bool temp2 = false ;
19001 PyObject * obj0 = 0 ;
19002 PyObject * obj1 = 0 ;
19003 char * kwnames[] = {
19004 (char *) "self",(char *) "mimeType", NULL
19005 };
19006
19007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
19008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19009 if (!SWIG_IsOK(res1)) {
19010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19011 }
19012 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19013 {
19014 arg2 = wxString_in_helper(obj1);
19015 if (arg2 == NULL) SWIG_fail;
19016 temp2 = true;
19017 }
19018 {
19019 PyThreadState* __tstate = wxPyBeginAllowThreads();
19020 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19021 wxPyEndAllowThreads(__tstate);
19022 if (PyErr_Occurred()) SWIG_fail;
19023 }
19024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19025 {
19026 if (temp2)
19027 delete arg2;
19028 }
19029 return resultobj;
19030 fail:
19031 {
19032 if (temp2)
19033 delete arg2;
19034 }
19035 return NULL;
19036 }
19037
19038
19039 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19040 PyObject *resultobj = 0;
19041 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19042 wxString *arg2 = 0 ;
19043 bool arg3 = (bool) false ;
19044 bool result;
19045 void *argp1 = 0 ;
19046 int res1 = 0 ;
19047 bool temp2 = false ;
19048 bool val3 ;
19049 int ecode3 = 0 ;
19050 PyObject * obj0 = 0 ;
19051 PyObject * obj1 = 0 ;
19052 PyObject * obj2 = 0 ;
19053 char * kwnames[] = {
19054 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19055 };
19056
19057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19059 if (!SWIG_IsOK(res1)) {
19060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19061 }
19062 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19063 {
19064 arg2 = wxString_in_helper(obj1);
19065 if (arg2 == NULL) SWIG_fail;
19066 temp2 = true;
19067 }
19068 if (obj2) {
19069 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19070 if (!SWIG_IsOK(ecode3)) {
19071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19072 }
19073 arg3 = static_cast< bool >(val3);
19074 }
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 {
19082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19083 }
19084 {
19085 if (temp2)
19086 delete arg2;
19087 }
19088 return resultobj;
19089 fail:
19090 {
19091 if (temp2)
19092 delete arg2;
19093 }
19094 return NULL;
19095 }
19096
19097
19098 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj = 0;
19100 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19101 wxString *arg2 = 0 ;
19102 bool result;
19103 void *argp1 = 0 ;
19104 int res1 = 0 ;
19105 bool temp2 = false ;
19106 PyObject * obj0 = 0 ;
19107 PyObject * obj1 = 0 ;
19108 char * kwnames[] = {
19109 (char *) "self",(char *) "filename", NULL
19110 };
19111
19112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19114 if (!SWIG_IsOK(res1)) {
19115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19116 }
19117 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19118 {
19119 arg2 = wxString_in_helper(obj1);
19120 if (arg2 == NULL) SWIG_fail;
19121 temp2 = true;
19122 }
19123 {
19124 PyThreadState* __tstate = wxPyBeginAllowThreads();
19125 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 {
19130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19131 }
19132 {
19133 if (temp2)
19134 delete arg2;
19135 }
19136 return resultobj;
19137 fail:
19138 {
19139 if (temp2)
19140 delete arg2;
19141 }
19142 return NULL;
19143 }
19144
19145
19146 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19147 PyObject *resultobj = 0;
19148 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19149 PyObject *result = 0 ;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 PyObject *swig_obj[1] ;
19153
19154 if (!args) SWIG_fail;
19155 swig_obj[0] = args;
19156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19157 if (!SWIG_IsOK(res1)) {
19158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19159 }
19160 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19161 {
19162 PyThreadState* __tstate = wxPyBeginAllowThreads();
19163 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 resultobj = result;
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19175 PyObject *resultobj = 0;
19176 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19177 wxFileTypeInfo *arg2 = 0 ;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 void *argp2 = 0 ;
19181 int res2 = 0 ;
19182 PyObject * obj0 = 0 ;
19183 PyObject * obj1 = 0 ;
19184 char * kwnames[] = {
19185 (char *) "self",(char *) "ft", NULL
19186 };
19187
19188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19190 if (!SWIG_IsOK(res1)) {
19191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19192 }
19193 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19194 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19195 if (!SWIG_IsOK(res2)) {
19196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19197 }
19198 if (!argp2) {
19199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19200 }
19201 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19202 {
19203 PyThreadState* __tstate = wxPyBeginAllowThreads();
19204 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19205 wxPyEndAllowThreads(__tstate);
19206 if (PyErr_Occurred()) SWIG_fail;
19207 }
19208 resultobj = SWIG_Py_Void();
19209 return resultobj;
19210 fail:
19211 return NULL;
19212 }
19213
19214
19215 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj = 0;
19217 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19218 wxFileTypeInfo *arg2 = 0 ;
19219 wxFileType *result = 0 ;
19220 void *argp1 = 0 ;
19221 int res1 = 0 ;
19222 void *argp2 = 0 ;
19223 int res2 = 0 ;
19224 PyObject * obj0 = 0 ;
19225 PyObject * obj1 = 0 ;
19226 char * kwnames[] = {
19227 (char *) "self",(char *) "ftInfo", NULL
19228 };
19229
19230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19232 if (!SWIG_IsOK(res1)) {
19233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19234 }
19235 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19237 if (!SWIG_IsOK(res2)) {
19238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19239 }
19240 if (!argp2) {
19241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19242 }
19243 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj = 0;
19259 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19260 wxFileType *arg2 = (wxFileType *) 0 ;
19261 bool result;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 void *argp2 = 0 ;
19265 int res2 = 0 ;
19266 PyObject * obj0 = 0 ;
19267 PyObject * obj1 = 0 ;
19268 char * kwnames[] = {
19269 (char *) "self",(char *) "ft", NULL
19270 };
19271
19272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19276 }
19277 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19279 if (!SWIG_IsOK(res2)) {
19280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19281 }
19282 arg2 = reinterpret_cast< wxFileType * >(argp2);
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 result = (bool)(arg1)->Unassociate(arg2);
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 {
19290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19291 }
19292 return resultobj;
19293 fail:
19294 return NULL;
19295 }
19296
19297
19298 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19299 PyObject *resultobj = 0;
19300 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19301 void *argp1 = 0 ;
19302 int res1 = 0 ;
19303 PyObject *swig_obj[1] ;
19304
19305 if (!args) SWIG_fail;
19306 swig_obj[0] = args;
19307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19308 if (!SWIG_IsOK(res1)) {
19309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19310 }
19311 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19312 {
19313 PyThreadState* __tstate = wxPyBeginAllowThreads();
19314 delete arg1;
19315
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 resultobj = SWIG_Py_Void();
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19327 PyObject *obj;
19328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19329 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19330 return SWIG_Py_Void();
19331 }
19332
19333 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19334 return SWIG_Python_InitShadowInstance(args);
19335 }
19336
19337 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19338 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19339 return 1;
19340 }
19341
19342
19343 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19344 PyObject *pyobj = 0;
19345
19346 {
19347 #if wxUSE_UNICODE
19348 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19349 #else
19350 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19351 #endif
19352 }
19353 return pyobj;
19354 }
19355
19356
19357 SWIGINTERN int ART_MENU_set(PyObject *) {
19358 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19359 return 1;
19360 }
19361
19362
19363 SWIGINTERN PyObject *ART_MENU_get(void) {
19364 PyObject *pyobj = 0;
19365
19366 {
19367 #if wxUSE_UNICODE
19368 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19369 #else
19370 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19371 #endif
19372 }
19373 return pyobj;
19374 }
19375
19376
19377 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19378 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19379 return 1;
19380 }
19381
19382
19383 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19384 PyObject *pyobj = 0;
19385
19386 {
19387 #if wxUSE_UNICODE
19388 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19389 #else
19390 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19391 #endif
19392 }
19393 return pyobj;
19394 }
19395
19396
19397 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19398 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19399 return 1;
19400 }
19401
19402
19403 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19404 PyObject *pyobj = 0;
19405
19406 {
19407 #if wxUSE_UNICODE
19408 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19409 #else
19410 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19411 #endif
19412 }
19413 return pyobj;
19414 }
19415
19416
19417 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19418 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19419 return 1;
19420 }
19421
19422
19423 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19424 PyObject *pyobj = 0;
19425
19426 {
19427 #if wxUSE_UNICODE
19428 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19429 #else
19430 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19431 #endif
19432 }
19433 return pyobj;
19434 }
19435
19436
19437 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19438 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19439 return 1;
19440 }
19441
19442
19443 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19444 PyObject *pyobj = 0;
19445
19446 {
19447 #if wxUSE_UNICODE
19448 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19449 #else
19450 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19451 #endif
19452 }
19453 return pyobj;
19454 }
19455
19456
19457 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19458 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19459 return 1;
19460 }
19461
19462
19463 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19464 PyObject *pyobj = 0;
19465
19466 {
19467 #if wxUSE_UNICODE
19468 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19469 #else
19470 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19471 #endif
19472 }
19473 return pyobj;
19474 }
19475
19476
19477 SWIGINTERN int ART_OTHER_set(PyObject *) {
19478 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19479 return 1;
19480 }
19481
19482
19483 SWIGINTERN PyObject *ART_OTHER_get(void) {
19484 PyObject *pyobj = 0;
19485
19486 {
19487 #if wxUSE_UNICODE
19488 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19489 #else
19490 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19491 #endif
19492 }
19493 return pyobj;
19494 }
19495
19496
19497 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19498 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19499 return 1;
19500 }
19501
19502
19503 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19504 PyObject *pyobj = 0;
19505
19506 {
19507 #if wxUSE_UNICODE
19508 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19509 #else
19510 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19511 #endif
19512 }
19513 return pyobj;
19514 }
19515
19516
19517 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19518 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19519 return 1;
19520 }
19521
19522
19523 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19524 PyObject *pyobj = 0;
19525
19526 {
19527 #if wxUSE_UNICODE
19528 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19529 #else
19530 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19531 #endif
19532 }
19533 return pyobj;
19534 }
19535
19536
19537 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19538 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19539 return 1;
19540 }
19541
19542
19543 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19544 PyObject *pyobj = 0;
19545
19546 {
19547 #if wxUSE_UNICODE
19548 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19549 #else
19550 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19551 #endif
19552 }
19553 return pyobj;
19554 }
19555
19556
19557 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19558 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19559 return 1;
19560 }
19561
19562
19563 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19564 PyObject *pyobj = 0;
19565
19566 {
19567 #if wxUSE_UNICODE
19568 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19569 #else
19570 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19571 #endif
19572 }
19573 return pyobj;
19574 }
19575
19576
19577 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19578 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19579 return 1;
19580 }
19581
19582
19583 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19584 PyObject *pyobj = 0;
19585
19586 {
19587 #if wxUSE_UNICODE
19588 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19589 #else
19590 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19591 #endif
19592 }
19593 return pyobj;
19594 }
19595
19596
19597 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19598 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19599 return 1;
19600 }
19601
19602
19603 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19604 PyObject *pyobj = 0;
19605
19606 {
19607 #if wxUSE_UNICODE
19608 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19609 #else
19610 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19611 #endif
19612 }
19613 return pyobj;
19614 }
19615
19616
19617 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19618 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19619 return 1;
19620 }
19621
19622
19623 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19624 PyObject *pyobj = 0;
19625
19626 {
19627 #if wxUSE_UNICODE
19628 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19629 #else
19630 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19631 #endif
19632 }
19633 return pyobj;
19634 }
19635
19636
19637 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19638 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19639 return 1;
19640 }
19641
19642
19643 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19644 PyObject *pyobj = 0;
19645
19646 {
19647 #if wxUSE_UNICODE
19648 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19649 #else
19650 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19651 #endif
19652 }
19653 return pyobj;
19654 }
19655
19656
19657 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19658 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19659 return 1;
19660 }
19661
19662
19663 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19664 PyObject *pyobj = 0;
19665
19666 {
19667 #if wxUSE_UNICODE
19668 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19669 #else
19670 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19671 #endif
19672 }
19673 return pyobj;
19674 }
19675
19676
19677 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19678 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19679 return 1;
19680 }
19681
19682
19683 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19684 PyObject *pyobj = 0;
19685
19686 {
19687 #if wxUSE_UNICODE
19688 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19689 #else
19690 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19691 #endif
19692 }
19693 return pyobj;
19694 }
19695
19696
19697 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19698 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19699 return 1;
19700 }
19701
19702
19703 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19704 PyObject *pyobj = 0;
19705
19706 {
19707 #if wxUSE_UNICODE
19708 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19709 #else
19710 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19711 #endif
19712 }
19713 return pyobj;
19714 }
19715
19716
19717 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19718 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19719 return 1;
19720 }
19721
19722
19723 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19724 PyObject *pyobj = 0;
19725
19726 {
19727 #if wxUSE_UNICODE
19728 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19729 #else
19730 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19731 #endif
19732 }
19733 return pyobj;
19734 }
19735
19736
19737 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19738 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19739 return 1;
19740 }
19741
19742
19743 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19744 PyObject *pyobj = 0;
19745
19746 {
19747 #if wxUSE_UNICODE
19748 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19749 #else
19750 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19751 #endif
19752 }
19753 return pyobj;
19754 }
19755
19756
19757 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19758 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19759 return 1;
19760 }
19761
19762
19763 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19764 PyObject *pyobj = 0;
19765
19766 {
19767 #if wxUSE_UNICODE
19768 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19769 #else
19770 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19771 #endif
19772 }
19773 return pyobj;
19774 }
19775
19776
19777 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19778 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19779 return 1;
19780 }
19781
19782
19783 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19784 PyObject *pyobj = 0;
19785
19786 {
19787 #if wxUSE_UNICODE
19788 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19789 #else
19790 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19791 #endif
19792 }
19793 return pyobj;
19794 }
19795
19796
19797 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19798 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19799 return 1;
19800 }
19801
19802
19803 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19804 PyObject *pyobj = 0;
19805
19806 {
19807 #if wxUSE_UNICODE
19808 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19809 #else
19810 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19811 #endif
19812 }
19813 return pyobj;
19814 }
19815
19816
19817 SWIGINTERN int ART_PRINT_set(PyObject *) {
19818 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19819 return 1;
19820 }
19821
19822
19823 SWIGINTERN PyObject *ART_PRINT_get(void) {
19824 PyObject *pyobj = 0;
19825
19826 {
19827 #if wxUSE_UNICODE
19828 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19829 #else
19830 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19831 #endif
19832 }
19833 return pyobj;
19834 }
19835
19836
19837 SWIGINTERN int ART_HELP_set(PyObject *) {
19838 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19839 return 1;
19840 }
19841
19842
19843 SWIGINTERN PyObject *ART_HELP_get(void) {
19844 PyObject *pyobj = 0;
19845
19846 {
19847 #if wxUSE_UNICODE
19848 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19849 #else
19850 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19851 #endif
19852 }
19853 return pyobj;
19854 }
19855
19856
19857 SWIGINTERN int ART_TIP_set(PyObject *) {
19858 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19859 return 1;
19860 }
19861
19862
19863 SWIGINTERN PyObject *ART_TIP_get(void) {
19864 PyObject *pyobj = 0;
19865
19866 {
19867 #if wxUSE_UNICODE
19868 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19869 #else
19870 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19871 #endif
19872 }
19873 return pyobj;
19874 }
19875
19876
19877 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19878 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19879 return 1;
19880 }
19881
19882
19883 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19884 PyObject *pyobj = 0;
19885
19886 {
19887 #if wxUSE_UNICODE
19888 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19889 #else
19890 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19891 #endif
19892 }
19893 return pyobj;
19894 }
19895
19896
19897 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19898 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19899 return 1;
19900 }
19901
19902
19903 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19904 PyObject *pyobj = 0;
19905
19906 {
19907 #if wxUSE_UNICODE
19908 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19909 #else
19910 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19911 #endif
19912 }
19913 return pyobj;
19914 }
19915
19916
19917 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19918 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19919 return 1;
19920 }
19921
19922
19923 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19924 PyObject *pyobj = 0;
19925
19926 {
19927 #if wxUSE_UNICODE
19928 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19929 #else
19930 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19931 #endif
19932 }
19933 return pyobj;
19934 }
19935
19936
19937 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19938 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19939 return 1;
19940 }
19941
19942
19943 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19944 PyObject *pyobj = 0;
19945
19946 {
19947 #if wxUSE_UNICODE
19948 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19949 #else
19950 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19951 #endif
19952 }
19953 return pyobj;
19954 }
19955
19956
19957 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19958 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19959 return 1;
19960 }
19961
19962
19963 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19964 PyObject *pyobj = 0;
19965
19966 {
19967 #if wxUSE_UNICODE
19968 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19969 #else
19970 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19971 #endif
19972 }
19973 return pyobj;
19974 }
19975
19976
19977 SWIGINTERN int ART_CDROM_set(PyObject *) {
19978 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19979 return 1;
19980 }
19981
19982
19983 SWIGINTERN PyObject *ART_CDROM_get(void) {
19984 PyObject *pyobj = 0;
19985
19986 {
19987 #if wxUSE_UNICODE
19988 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19989 #else
19990 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19991 #endif
19992 }
19993 return pyobj;
19994 }
19995
19996
19997 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19998 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19999 return 1;
20000 }
20001
20002
20003 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20004 PyObject *pyobj = 0;
20005
20006 {
20007 #if wxUSE_UNICODE
20008 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20009 #else
20010 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20011 #endif
20012 }
20013 return pyobj;
20014 }
20015
20016
20017 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20018 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20019 return 1;
20020 }
20021
20022
20023 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20024 PyObject *pyobj = 0;
20025
20026 {
20027 #if wxUSE_UNICODE
20028 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20029 #else
20030 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20031 #endif
20032 }
20033 return pyobj;
20034 }
20035
20036
20037 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20038 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20039 return 1;
20040 }
20041
20042
20043 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20044 PyObject *pyobj = 0;
20045
20046 {
20047 #if wxUSE_UNICODE
20048 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20049 #else
20050 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20051 #endif
20052 }
20053 return pyobj;
20054 }
20055
20056
20057 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20058 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20059 return 1;
20060 }
20061
20062
20063 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20064 PyObject *pyobj = 0;
20065
20066 {
20067 #if wxUSE_UNICODE
20068 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20069 #else
20070 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20071 #endif
20072 }
20073 return pyobj;
20074 }
20075
20076
20077 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20078 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20079 return 1;
20080 }
20081
20082
20083 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20084 PyObject *pyobj = 0;
20085
20086 {
20087 #if wxUSE_UNICODE
20088 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20089 #else
20090 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20091 #endif
20092 }
20093 return pyobj;
20094 }
20095
20096
20097 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20098 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20099 return 1;
20100 }
20101
20102
20103 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20104 PyObject *pyobj = 0;
20105
20106 {
20107 #if wxUSE_UNICODE
20108 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20109 #else
20110 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20111 #endif
20112 }
20113 return pyobj;
20114 }
20115
20116
20117 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20118 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20119 return 1;
20120 }
20121
20122
20123 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20124 PyObject *pyobj = 0;
20125
20126 {
20127 #if wxUSE_UNICODE
20128 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20129 #else
20130 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20131 #endif
20132 }
20133 return pyobj;
20134 }
20135
20136
20137 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20138 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20139 return 1;
20140 }
20141
20142
20143 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20144 PyObject *pyobj = 0;
20145
20146 {
20147 #if wxUSE_UNICODE
20148 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20149 #else
20150 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20151 #endif
20152 }
20153 return pyobj;
20154 }
20155
20156
20157 SWIGINTERN int ART_ERROR_set(PyObject *) {
20158 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20159 return 1;
20160 }
20161
20162
20163 SWIGINTERN PyObject *ART_ERROR_get(void) {
20164 PyObject *pyobj = 0;
20165
20166 {
20167 #if wxUSE_UNICODE
20168 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20169 #else
20170 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20171 #endif
20172 }
20173 return pyobj;
20174 }
20175
20176
20177 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20178 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20179 return 1;
20180 }
20181
20182
20183 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20184 PyObject *pyobj = 0;
20185
20186 {
20187 #if wxUSE_UNICODE
20188 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20189 #else
20190 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20191 #endif
20192 }
20193 return pyobj;
20194 }
20195
20196
20197 SWIGINTERN int ART_WARNING_set(PyObject *) {
20198 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20199 return 1;
20200 }
20201
20202
20203 SWIGINTERN PyObject *ART_WARNING_get(void) {
20204 PyObject *pyobj = 0;
20205
20206 {
20207 #if wxUSE_UNICODE
20208 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20209 #else
20210 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20211 #endif
20212 }
20213 return pyobj;
20214 }
20215
20216
20217 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20218 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20219 return 1;
20220 }
20221
20222
20223 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20224 PyObject *pyobj = 0;
20225
20226 {
20227 #if wxUSE_UNICODE
20228 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20229 #else
20230 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20231 #endif
20232 }
20233 return pyobj;
20234 }
20235
20236
20237 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20238 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20239 return 1;
20240 }
20241
20242
20243 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20244 PyObject *pyobj = 0;
20245
20246 {
20247 #if wxUSE_UNICODE
20248 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20249 #else
20250 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20251 #endif
20252 }
20253 return pyobj;
20254 }
20255
20256
20257 SWIGINTERN int ART_COPY_set(PyObject *) {
20258 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20259 return 1;
20260 }
20261
20262
20263 SWIGINTERN PyObject *ART_COPY_get(void) {
20264 PyObject *pyobj = 0;
20265
20266 {
20267 #if wxUSE_UNICODE
20268 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20269 #else
20270 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20271 #endif
20272 }
20273 return pyobj;
20274 }
20275
20276
20277 SWIGINTERN int ART_CUT_set(PyObject *) {
20278 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20279 return 1;
20280 }
20281
20282
20283 SWIGINTERN PyObject *ART_CUT_get(void) {
20284 PyObject *pyobj = 0;
20285
20286 {
20287 #if wxUSE_UNICODE
20288 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20289 #else
20290 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20291 #endif
20292 }
20293 return pyobj;
20294 }
20295
20296
20297 SWIGINTERN int ART_PASTE_set(PyObject *) {
20298 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20299 return 1;
20300 }
20301
20302
20303 SWIGINTERN PyObject *ART_PASTE_get(void) {
20304 PyObject *pyobj = 0;
20305
20306 {
20307 #if wxUSE_UNICODE
20308 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20309 #else
20310 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20311 #endif
20312 }
20313 return pyobj;
20314 }
20315
20316
20317 SWIGINTERN int ART_DELETE_set(PyObject *) {
20318 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20319 return 1;
20320 }
20321
20322
20323 SWIGINTERN PyObject *ART_DELETE_get(void) {
20324 PyObject *pyobj = 0;
20325
20326 {
20327 #if wxUSE_UNICODE
20328 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20329 #else
20330 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20331 #endif
20332 }
20333 return pyobj;
20334 }
20335
20336
20337 SWIGINTERN int ART_NEW_set(PyObject *) {
20338 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20339 return 1;
20340 }
20341
20342
20343 SWIGINTERN PyObject *ART_NEW_get(void) {
20344 PyObject *pyobj = 0;
20345
20346 {
20347 #if wxUSE_UNICODE
20348 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20349 #else
20350 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20351 #endif
20352 }
20353 return pyobj;
20354 }
20355
20356
20357 SWIGINTERN int ART_UNDO_set(PyObject *) {
20358 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20359 return 1;
20360 }
20361
20362
20363 SWIGINTERN PyObject *ART_UNDO_get(void) {
20364 PyObject *pyobj = 0;
20365
20366 {
20367 #if wxUSE_UNICODE
20368 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20369 #else
20370 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20371 #endif
20372 }
20373 return pyobj;
20374 }
20375
20376
20377 SWIGINTERN int ART_REDO_set(PyObject *) {
20378 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20379 return 1;
20380 }
20381
20382
20383 SWIGINTERN PyObject *ART_REDO_get(void) {
20384 PyObject *pyobj = 0;
20385
20386 {
20387 #if wxUSE_UNICODE
20388 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20389 #else
20390 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20391 #endif
20392 }
20393 return pyobj;
20394 }
20395
20396
20397 SWIGINTERN int ART_QUIT_set(PyObject *) {
20398 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20399 return 1;
20400 }
20401
20402
20403 SWIGINTERN PyObject *ART_QUIT_get(void) {
20404 PyObject *pyobj = 0;
20405
20406 {
20407 #if wxUSE_UNICODE
20408 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20409 #else
20410 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20411 #endif
20412 }
20413 return pyobj;
20414 }
20415
20416
20417 SWIGINTERN int ART_FIND_set(PyObject *) {
20418 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20419 return 1;
20420 }
20421
20422
20423 SWIGINTERN PyObject *ART_FIND_get(void) {
20424 PyObject *pyobj = 0;
20425
20426 {
20427 #if wxUSE_UNICODE
20428 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20429 #else
20430 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20431 #endif
20432 }
20433 return pyobj;
20434 }
20435
20436
20437 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20438 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20439 return 1;
20440 }
20441
20442
20443 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20444 PyObject *pyobj = 0;
20445
20446 {
20447 #if wxUSE_UNICODE
20448 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20449 #else
20450 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20451 #endif
20452 }
20453 return pyobj;
20454 }
20455
20456
20457 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 PyObject *resultobj = 0;
20459 wxPyArtProvider *result = 0 ;
20460
20461 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20462 {
20463 if (!wxPyCheckForApp()) SWIG_fail;
20464 PyThreadState* __tstate = wxPyBeginAllowThreads();
20465 result = (wxPyArtProvider *)new wxPyArtProvider();
20466 wxPyEndAllowThreads(__tstate);
20467 if (PyErr_Occurred()) SWIG_fail;
20468 }
20469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20470 return resultobj;
20471 fail:
20472 return NULL;
20473 }
20474
20475
20476 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20477 PyObject *resultobj = 0;
20478 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20479 void *argp1 = 0 ;
20480 int res1 = 0 ;
20481 PyObject *swig_obj[1] ;
20482
20483 if (!args) SWIG_fail;
20484 swig_obj[0] = args;
20485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20488 }
20489 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 delete arg1;
20493
20494 wxPyEndAllowThreads(__tstate);
20495 if (PyErr_Occurred()) SWIG_fail;
20496 }
20497 resultobj = SWIG_Py_Void();
20498 return resultobj;
20499 fail:
20500 return NULL;
20501 }
20502
20503
20504 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20505 PyObject *resultobj = 0;
20506 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20507 PyObject *arg2 = (PyObject *) 0 ;
20508 PyObject *arg3 = (PyObject *) 0 ;
20509 void *argp1 = 0 ;
20510 int res1 = 0 ;
20511 PyObject * obj0 = 0 ;
20512 PyObject * obj1 = 0 ;
20513 PyObject * obj2 = 0 ;
20514 char * kwnames[] = {
20515 (char *) "self",(char *) "self",(char *) "_class", NULL
20516 };
20517
20518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20520 if (!SWIG_IsOK(res1)) {
20521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20522 }
20523 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20524 arg2 = obj1;
20525 arg3 = obj2;
20526 {
20527 PyThreadState* __tstate = wxPyBeginAllowThreads();
20528 (arg1)->_setCallbackInfo(arg2,arg3);
20529 wxPyEndAllowThreads(__tstate);
20530 if (PyErr_Occurred()) SWIG_fail;
20531 }
20532 resultobj = SWIG_Py_Void();
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20540 PyObject *resultobj = 0;
20541 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20542 int res1 = 0 ;
20543 PyObject * obj0 = 0 ;
20544 char * kwnames[] = {
20545 (char *) "provider", NULL
20546 };
20547
20548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20549 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20550 if (!SWIG_IsOK(res1)) {
20551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 wxPyArtProvider::Push(arg1);
20556 wxPyEndAllowThreads(__tstate);
20557 if (PyErr_Occurred()) SWIG_fail;
20558 }
20559 resultobj = SWIG_Py_Void();
20560 return resultobj;
20561 fail:
20562 return NULL;
20563 }
20564
20565
20566 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20567 PyObject *resultobj = 0;
20568 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20569 int res1 = 0 ;
20570 PyObject * obj0 = 0 ;
20571 char * kwnames[] = {
20572 (char *) "provider", NULL
20573 };
20574
20575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20576 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20577 if (!SWIG_IsOK(res1)) {
20578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20579 }
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 wxPyArtProvider::Insert(arg1);
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 resultobj = SWIG_Py_Void();
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20594 PyObject *resultobj = 0;
20595 bool result;
20596
20597 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20598 {
20599 PyThreadState* __tstate = wxPyBeginAllowThreads();
20600 result = (bool)wxPyArtProvider::Pop();
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 {
20605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20606 }
20607 return resultobj;
20608 fail:
20609 return NULL;
20610 }
20611
20612
20613 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20614 PyObject *resultobj = 0;
20615 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20616 bool result;
20617 void *argp1 = 0 ;
20618 int res1 = 0 ;
20619 PyObject * obj0 = 0 ;
20620 char * kwnames[] = {
20621 (char *) "provider", NULL
20622 };
20623
20624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20626 if (!SWIG_IsOK(res1)) {
20627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20628 }
20629 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20630 {
20631 PyThreadState* __tstate = wxPyBeginAllowThreads();
20632 result = (bool)wxPyArtProvider::Delete(arg1);
20633 wxPyEndAllowThreads(__tstate);
20634 if (PyErr_Occurred()) SWIG_fail;
20635 }
20636 {
20637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20638 }
20639 return resultobj;
20640 fail:
20641 return NULL;
20642 }
20643
20644
20645 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20646 PyObject *resultobj = 0;
20647 wxString *arg1 = 0 ;
20648 wxString const &arg2_defvalue = wxPyART_OTHER ;
20649 wxString *arg2 = (wxString *) &arg2_defvalue ;
20650 wxSize const &arg3_defvalue = wxDefaultSize ;
20651 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20652 wxBitmap result;
20653 bool temp1 = false ;
20654 bool temp2 = false ;
20655 wxSize temp3 ;
20656 PyObject * obj0 = 0 ;
20657 PyObject * obj1 = 0 ;
20658 PyObject * obj2 = 0 ;
20659 char * kwnames[] = {
20660 (char *) "id",(char *) "client",(char *) "size", NULL
20661 };
20662
20663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20664 {
20665 arg1 = wxString_in_helper(obj0);
20666 if (arg1 == NULL) SWIG_fail;
20667 temp1 = true;
20668 }
20669 if (obj1) {
20670 {
20671 arg2 = wxString_in_helper(obj1);
20672 if (arg2 == NULL) SWIG_fail;
20673 temp2 = true;
20674 }
20675 }
20676 if (obj2) {
20677 {
20678 arg3 = &temp3;
20679 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20680 }
20681 }
20682 {
20683 if (!wxPyCheckForApp()) SWIG_fail;
20684 PyThreadState* __tstate = wxPyBeginAllowThreads();
20685 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20686 wxPyEndAllowThreads(__tstate);
20687 if (PyErr_Occurred()) SWIG_fail;
20688 }
20689 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20690 {
20691 if (temp1)
20692 delete arg1;
20693 }
20694 {
20695 if (temp2)
20696 delete arg2;
20697 }
20698 return resultobj;
20699 fail:
20700 {
20701 if (temp1)
20702 delete arg1;
20703 }
20704 {
20705 if (temp2)
20706 delete arg2;
20707 }
20708 return NULL;
20709 }
20710
20711
20712 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20713 PyObject *resultobj = 0;
20714 wxString *arg1 = 0 ;
20715 wxString const &arg2_defvalue = wxPyART_OTHER ;
20716 wxString *arg2 = (wxString *) &arg2_defvalue ;
20717 wxSize const &arg3_defvalue = wxDefaultSize ;
20718 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20719 wxIcon result;
20720 bool temp1 = false ;
20721 bool temp2 = false ;
20722 wxSize temp3 ;
20723 PyObject * obj0 = 0 ;
20724 PyObject * obj1 = 0 ;
20725 PyObject * obj2 = 0 ;
20726 char * kwnames[] = {
20727 (char *) "id",(char *) "client",(char *) "size", NULL
20728 };
20729
20730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20731 {
20732 arg1 = wxString_in_helper(obj0);
20733 if (arg1 == NULL) SWIG_fail;
20734 temp1 = true;
20735 }
20736 if (obj1) {
20737 {
20738 arg2 = wxString_in_helper(obj1);
20739 if (arg2 == NULL) SWIG_fail;
20740 temp2 = true;
20741 }
20742 }
20743 if (obj2) {
20744 {
20745 arg3 = &temp3;
20746 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20747 }
20748 }
20749 {
20750 if (!wxPyCheckForApp()) SWIG_fail;
20751 PyThreadState* __tstate = wxPyBeginAllowThreads();
20752 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20753 wxPyEndAllowThreads(__tstate);
20754 if (PyErr_Occurred()) SWIG_fail;
20755 }
20756 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20757 {
20758 if (temp1)
20759 delete arg1;
20760 }
20761 {
20762 if (temp2)
20763 delete arg2;
20764 }
20765 return resultobj;
20766 fail:
20767 {
20768 if (temp1)
20769 delete arg1;
20770 }
20771 {
20772 if (temp2)
20773 delete arg2;
20774 }
20775 return NULL;
20776 }
20777
20778
20779 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20780 PyObject *resultobj = 0;
20781 wxString *arg1 = 0 ;
20782 bool arg2 = (bool) false ;
20783 wxSize result;
20784 bool temp1 = false ;
20785 bool val2 ;
20786 int ecode2 = 0 ;
20787 PyObject * obj0 = 0 ;
20788 PyObject * obj1 = 0 ;
20789 char * kwnames[] = {
20790 (char *) "client",(char *) "platform_dependent", NULL
20791 };
20792
20793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20794 {
20795 arg1 = wxString_in_helper(obj0);
20796 if (arg1 == NULL) SWIG_fail;
20797 temp1 = true;
20798 }
20799 if (obj1) {
20800 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20801 if (!SWIG_IsOK(ecode2)) {
20802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20803 }
20804 arg2 = static_cast< bool >(val2);
20805 }
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20813 {
20814 if (temp1)
20815 delete arg1;
20816 }
20817 return resultobj;
20818 fail:
20819 {
20820 if (temp1)
20821 delete arg1;
20822 }
20823 return NULL;
20824 }
20825
20826
20827 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20828 PyObject *resultobj = 0;
20829 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20830 void *argp1 = 0 ;
20831 int res1 = 0 ;
20832 PyObject *swig_obj[1] ;
20833
20834 if (!args) SWIG_fail;
20835 swig_obj[0] = args;
20836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20837 if (!SWIG_IsOK(res1)) {
20838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20839 }
20840 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 wxPyArtProvider_Destroy(arg1);
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 resultobj = SWIG_Py_Void();
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *obj;
20856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20857 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20858 return SWIG_Py_Void();
20859 }
20860
20861 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20862 return SWIG_Python_InitShadowInstance(args);
20863 }
20864
20865 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20866 PyObject *resultobj = 0;
20867 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20868 void *argp1 = 0 ;
20869 int res1 = 0 ;
20870 PyObject *swig_obj[1] ;
20871
20872 if (!args) SWIG_fail;
20873 swig_obj[0] = args;
20874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20875 if (!SWIG_IsOK(res1)) {
20876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20877 }
20878 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20879 {
20880 PyThreadState* __tstate = wxPyBeginAllowThreads();
20881 delete arg1;
20882
20883 wxPyEndAllowThreads(__tstate);
20884 if (PyErr_Occurred()) SWIG_fail;
20885 }
20886 resultobj = SWIG_Py_Void();
20887 return resultobj;
20888 fail:
20889 return NULL;
20890 }
20891
20892
20893 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20894 PyObject *resultobj = 0;
20895 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20896 wxConfigBase *result = 0 ;
20897 int res1 = 0 ;
20898 PyObject * obj0 = 0 ;
20899 char * kwnames[] = {
20900 (char *) "config", NULL
20901 };
20902
20903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20904 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20907 }
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20911 wxPyEndAllowThreads(__tstate);
20912 if (PyErr_Occurred()) SWIG_fail;
20913 }
20914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20922 PyObject *resultobj = 0;
20923 bool arg1 = (bool) true ;
20924 wxConfigBase *result = 0 ;
20925 bool val1 ;
20926 int ecode1 = 0 ;
20927 PyObject * obj0 = 0 ;
20928 char * kwnames[] = {
20929 (char *) "createOnDemand", NULL
20930 };
20931
20932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20933 if (obj0) {
20934 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20935 if (!SWIG_IsOK(ecode1)) {
20936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20937 }
20938 arg1 = static_cast< bool >(val1);
20939 }
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20954 PyObject *resultobj = 0;
20955 wxConfigBase *result = 0 ;
20956
20957 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20958 {
20959 PyThreadState* __tstate = wxPyBeginAllowThreads();
20960 result = (wxConfigBase *)wxConfigBase::Create();
20961 wxPyEndAllowThreads(__tstate);
20962 if (PyErr_Occurred()) SWIG_fail;
20963 }
20964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20965 return resultobj;
20966 fail:
20967 return NULL;
20968 }
20969
20970
20971 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20972 PyObject *resultobj = 0;
20973
20974 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20975 {
20976 PyThreadState* __tstate = wxPyBeginAllowThreads();
20977 wxConfigBase::DontCreateOnDemand();
20978 wxPyEndAllowThreads(__tstate);
20979 if (PyErr_Occurred()) SWIG_fail;
20980 }
20981 resultobj = SWIG_Py_Void();
20982 return resultobj;
20983 fail:
20984 return NULL;
20985 }
20986
20987
20988 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20989 PyObject *resultobj = 0;
20990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20991 wxString *arg2 = 0 ;
20992 void *argp1 = 0 ;
20993 int res1 = 0 ;
20994 bool temp2 = false ;
20995 PyObject * obj0 = 0 ;
20996 PyObject * obj1 = 0 ;
20997 char * kwnames[] = {
20998 (char *) "self",(char *) "path", NULL
20999 };
21000
21001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21003 if (!SWIG_IsOK(res1)) {
21004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21005 }
21006 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21007 {
21008 arg2 = wxString_in_helper(obj1);
21009 if (arg2 == NULL) SWIG_fail;
21010 temp2 = true;
21011 }
21012 {
21013 PyThreadState* __tstate = wxPyBeginAllowThreads();
21014 (arg1)->SetPath((wxString const &)*arg2);
21015 wxPyEndAllowThreads(__tstate);
21016 if (PyErr_Occurred()) SWIG_fail;
21017 }
21018 resultobj = SWIG_Py_Void();
21019 {
21020 if (temp2)
21021 delete arg2;
21022 }
21023 return resultobj;
21024 fail:
21025 {
21026 if (temp2)
21027 delete arg2;
21028 }
21029 return NULL;
21030 }
21031
21032
21033 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21034 PyObject *resultobj = 0;
21035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21036 wxString *result = 0 ;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 PyObject *swig_obj[1] ;
21040
21041 if (!args) SWIG_fail;
21042 swig_obj[0] = args;
21043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21044 if (!SWIG_IsOK(res1)) {
21045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21046 }
21047 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 {
21051 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21052 result = (wxString *) &_result_ref;
21053 }
21054 wxPyEndAllowThreads(__tstate);
21055 if (PyErr_Occurred()) SWIG_fail;
21056 }
21057 {
21058 #if wxUSE_UNICODE
21059 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21060 #else
21061 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21062 #endif
21063 }
21064 return resultobj;
21065 fail:
21066 return NULL;
21067 }
21068
21069
21070 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21071 PyObject *resultobj = 0;
21072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21073 PyObject *result = 0 ;
21074 void *argp1 = 0 ;
21075 int res1 = 0 ;
21076 PyObject *swig_obj[1] ;
21077
21078 if (!args) SWIG_fail;
21079 swig_obj[0] = args;
21080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21081 if (!SWIG_IsOK(res1)) {
21082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21083 }
21084 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21085 {
21086 PyThreadState* __tstate = wxPyBeginAllowThreads();
21087 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21088 wxPyEndAllowThreads(__tstate);
21089 if (PyErr_Occurred()) SWIG_fail;
21090 }
21091 resultobj = result;
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21099 PyObject *resultobj = 0;
21100 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21101 long arg2 ;
21102 PyObject *result = 0 ;
21103 void *argp1 = 0 ;
21104 int res1 = 0 ;
21105 long val2 ;
21106 int ecode2 = 0 ;
21107 PyObject * obj0 = 0 ;
21108 PyObject * obj1 = 0 ;
21109 char * kwnames[] = {
21110 (char *) "self",(char *) "index", NULL
21111 };
21112
21113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21115 if (!SWIG_IsOK(res1)) {
21116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21117 }
21118 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21119 ecode2 = SWIG_AsVal_long(obj1, &val2);
21120 if (!SWIG_IsOK(ecode2)) {
21121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21122 }
21123 arg2 = static_cast< long >(val2);
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21127 wxPyEndAllowThreads(__tstate);
21128 if (PyErr_Occurred()) SWIG_fail;
21129 }
21130 resultobj = result;
21131 return resultobj;
21132 fail:
21133 return NULL;
21134 }
21135
21136
21137 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21138 PyObject *resultobj = 0;
21139 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21140 PyObject *result = 0 ;
21141 void *argp1 = 0 ;
21142 int res1 = 0 ;
21143 PyObject *swig_obj[1] ;
21144
21145 if (!args) SWIG_fail;
21146 swig_obj[0] = args;
21147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21148 if (!SWIG_IsOK(res1)) {
21149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21150 }
21151 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 resultobj = result;
21159 return resultobj;
21160 fail:
21161 return NULL;
21162 }
21163
21164
21165 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21166 PyObject *resultobj = 0;
21167 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21168 long arg2 ;
21169 PyObject *result = 0 ;
21170 void *argp1 = 0 ;
21171 int res1 = 0 ;
21172 long val2 ;
21173 int ecode2 = 0 ;
21174 PyObject * obj0 = 0 ;
21175 PyObject * obj1 = 0 ;
21176 char * kwnames[] = {
21177 (char *) "self",(char *) "index", NULL
21178 };
21179
21180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21182 if (!SWIG_IsOK(res1)) {
21183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21184 }
21185 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21186 ecode2 = SWIG_AsVal_long(obj1, &val2);
21187 if (!SWIG_IsOK(ecode2)) {
21188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21189 }
21190 arg2 = static_cast< long >(val2);
21191 {
21192 PyThreadState* __tstate = wxPyBeginAllowThreads();
21193 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21194 wxPyEndAllowThreads(__tstate);
21195 if (PyErr_Occurred()) SWIG_fail;
21196 }
21197 resultobj = result;
21198 return resultobj;
21199 fail:
21200 return NULL;
21201 }
21202
21203
21204 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(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_GetNumberOfEntries",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_GetNumberOfEntries" "', 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_GetNumberOfEntries" "', 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)->GetNumberOfEntries(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_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21246 PyObject *resultobj = 0;
21247 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21248 bool arg2 = (bool) false ;
21249 size_t result;
21250 void *argp1 = 0 ;
21251 int res1 = 0 ;
21252 bool val2 ;
21253 int ecode2 = 0 ;
21254 PyObject * obj0 = 0 ;
21255 PyObject * obj1 = 0 ;
21256 char * kwnames[] = {
21257 (char *) "self",(char *) "recursive", NULL
21258 };
21259
21260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21264 }
21265 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21266 if (obj1) {
21267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21268 if (!SWIG_IsOK(ecode2)) {
21269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21270 }
21271 arg2 = static_cast< bool >(val2);
21272 }
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21280 return resultobj;
21281 fail:
21282 return NULL;
21283 }
21284
21285
21286 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj = 0;
21288 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21289 wxString *arg2 = 0 ;
21290 bool result;
21291 void *argp1 = 0 ;
21292 int res1 = 0 ;
21293 bool temp2 = false ;
21294 PyObject * obj0 = 0 ;
21295 PyObject * obj1 = 0 ;
21296 char * kwnames[] = {
21297 (char *) "self",(char *) "name", NULL
21298 };
21299
21300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21302 if (!SWIG_IsOK(res1)) {
21303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21304 }
21305 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21306 {
21307 arg2 = wxString_in_helper(obj1);
21308 if (arg2 == NULL) SWIG_fail;
21309 temp2 = true;
21310 }
21311 {
21312 PyThreadState* __tstate = wxPyBeginAllowThreads();
21313 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21314 wxPyEndAllowThreads(__tstate);
21315 if (PyErr_Occurred()) SWIG_fail;
21316 }
21317 {
21318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21319 }
21320 {
21321 if (temp2)
21322 delete arg2;
21323 }
21324 return resultobj;
21325 fail:
21326 {
21327 if (temp2)
21328 delete arg2;
21329 }
21330 return NULL;
21331 }
21332
21333
21334 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21335 PyObject *resultobj = 0;
21336 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21337 wxString *arg2 = 0 ;
21338 bool result;
21339 void *argp1 = 0 ;
21340 int res1 = 0 ;
21341 bool temp2 = false ;
21342 PyObject * obj0 = 0 ;
21343 PyObject * obj1 = 0 ;
21344 char * kwnames[] = {
21345 (char *) "self",(char *) "name", NULL
21346 };
21347
21348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21350 if (!SWIG_IsOK(res1)) {
21351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21352 }
21353 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21354 {
21355 arg2 = wxString_in_helper(obj1);
21356 if (arg2 == NULL) SWIG_fail;
21357 temp2 = true;
21358 }
21359 {
21360 PyThreadState* __tstate = wxPyBeginAllowThreads();
21361 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21362 wxPyEndAllowThreads(__tstate);
21363 if (PyErr_Occurred()) SWIG_fail;
21364 }
21365 {
21366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21367 }
21368 {
21369 if (temp2)
21370 delete arg2;
21371 }
21372 return resultobj;
21373 fail:
21374 {
21375 if (temp2)
21376 delete arg2;
21377 }
21378 return NULL;
21379 }
21380
21381
21382 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj = 0;
21384 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21385 wxString *arg2 = 0 ;
21386 bool result;
21387 void *argp1 = 0 ;
21388 int res1 = 0 ;
21389 bool temp2 = false ;
21390 PyObject * obj0 = 0 ;
21391 PyObject * obj1 = 0 ;
21392 char * kwnames[] = {
21393 (char *) "self",(char *) "name", NULL
21394 };
21395
21396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21398 if (!SWIG_IsOK(res1)) {
21399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21400 }
21401 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21402 {
21403 arg2 = wxString_in_helper(obj1);
21404 if (arg2 == NULL) SWIG_fail;
21405 temp2 = true;
21406 }
21407 {
21408 PyThreadState* __tstate = wxPyBeginAllowThreads();
21409 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21410 wxPyEndAllowThreads(__tstate);
21411 if (PyErr_Occurred()) SWIG_fail;
21412 }
21413 {
21414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21415 }
21416 {
21417 if (temp2)
21418 delete arg2;
21419 }
21420 return resultobj;
21421 fail:
21422 {
21423 if (temp2)
21424 delete arg2;
21425 }
21426 return NULL;
21427 }
21428
21429
21430 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21431 PyObject *resultobj = 0;
21432 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21433 wxString *arg2 = 0 ;
21434 wxConfigBase::EntryType result;
21435 void *argp1 = 0 ;
21436 int res1 = 0 ;
21437 bool temp2 = false ;
21438 PyObject * obj0 = 0 ;
21439 PyObject * obj1 = 0 ;
21440 char * kwnames[] = {
21441 (char *) "self",(char *) "name", NULL
21442 };
21443
21444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21446 if (!SWIG_IsOK(res1)) {
21447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21448 }
21449 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21450 {
21451 arg2 = wxString_in_helper(obj1);
21452 if (arg2 == NULL) SWIG_fail;
21453 temp2 = true;
21454 }
21455 {
21456 PyThreadState* __tstate = wxPyBeginAllowThreads();
21457 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21458 wxPyEndAllowThreads(__tstate);
21459 if (PyErr_Occurred()) SWIG_fail;
21460 }
21461 resultobj = SWIG_From_int(static_cast< int >(result));
21462 {
21463 if (temp2)
21464 delete arg2;
21465 }
21466 return resultobj;
21467 fail:
21468 {
21469 if (temp2)
21470 delete arg2;
21471 }
21472 return NULL;
21473 }
21474
21475
21476 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21477 PyObject *resultobj = 0;
21478 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21479 wxString *arg2 = 0 ;
21480 wxString const &arg3_defvalue = wxPyEmptyString ;
21481 wxString *arg3 = (wxString *) &arg3_defvalue ;
21482 wxString result;
21483 void *argp1 = 0 ;
21484 int res1 = 0 ;
21485 bool temp2 = false ;
21486 bool temp3 = false ;
21487 PyObject * obj0 = 0 ;
21488 PyObject * obj1 = 0 ;
21489 PyObject * obj2 = 0 ;
21490 char * kwnames[] = {
21491 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21492 };
21493
21494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21496 if (!SWIG_IsOK(res1)) {
21497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21498 }
21499 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21500 {
21501 arg2 = wxString_in_helper(obj1);
21502 if (arg2 == NULL) SWIG_fail;
21503 temp2 = true;
21504 }
21505 if (obj2) {
21506 {
21507 arg3 = wxString_in_helper(obj2);
21508 if (arg3 == NULL) SWIG_fail;
21509 temp3 = true;
21510 }
21511 }
21512 {
21513 PyThreadState* __tstate = wxPyBeginAllowThreads();
21514 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21515 wxPyEndAllowThreads(__tstate);
21516 if (PyErr_Occurred()) SWIG_fail;
21517 }
21518 {
21519 #if wxUSE_UNICODE
21520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21521 #else
21522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21523 #endif
21524 }
21525 {
21526 if (temp2)
21527 delete arg2;
21528 }
21529 {
21530 if (temp3)
21531 delete arg3;
21532 }
21533 return resultobj;
21534 fail:
21535 {
21536 if (temp2)
21537 delete arg2;
21538 }
21539 {
21540 if (temp3)
21541 delete arg3;
21542 }
21543 return NULL;
21544 }
21545
21546
21547 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj = 0;
21549 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21550 wxString *arg2 = 0 ;
21551 long arg3 = (long) 0 ;
21552 long result;
21553 void *argp1 = 0 ;
21554 int res1 = 0 ;
21555 bool temp2 = false ;
21556 long val3 ;
21557 int ecode3 = 0 ;
21558 PyObject * obj0 = 0 ;
21559 PyObject * obj1 = 0 ;
21560 PyObject * obj2 = 0 ;
21561 char * kwnames[] = {
21562 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21563 };
21564
21565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21567 if (!SWIG_IsOK(res1)) {
21568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21569 }
21570 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21571 {
21572 arg2 = wxString_in_helper(obj1);
21573 if (arg2 == NULL) SWIG_fail;
21574 temp2 = true;
21575 }
21576 if (obj2) {
21577 ecode3 = SWIG_AsVal_long(obj2, &val3);
21578 if (!SWIG_IsOK(ecode3)) {
21579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21580 }
21581 arg3 = static_cast< long >(val3);
21582 }
21583 {
21584 PyThreadState* __tstate = wxPyBeginAllowThreads();
21585 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21586 wxPyEndAllowThreads(__tstate);
21587 if (PyErr_Occurred()) SWIG_fail;
21588 }
21589 resultobj = SWIG_From_long(static_cast< long >(result));
21590 {
21591 if (temp2)
21592 delete arg2;
21593 }
21594 return resultobj;
21595 fail:
21596 {
21597 if (temp2)
21598 delete arg2;
21599 }
21600 return NULL;
21601 }
21602
21603
21604 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21605 PyObject *resultobj = 0;
21606 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21607 wxString *arg2 = 0 ;
21608 double arg3 = (double) 0.0 ;
21609 double result;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 bool temp2 = false ;
21613 double val3 ;
21614 int ecode3 = 0 ;
21615 PyObject * obj0 = 0 ;
21616 PyObject * obj1 = 0 ;
21617 PyObject * obj2 = 0 ;
21618 char * kwnames[] = {
21619 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21620 };
21621
21622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21624 if (!SWIG_IsOK(res1)) {
21625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21626 }
21627 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21628 {
21629 arg2 = wxString_in_helper(obj1);
21630 if (arg2 == NULL) SWIG_fail;
21631 temp2 = true;
21632 }
21633 if (obj2) {
21634 ecode3 = SWIG_AsVal_double(obj2, &val3);
21635 if (!SWIG_IsOK(ecode3)) {
21636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21637 }
21638 arg3 = static_cast< double >(val3);
21639 }
21640 {
21641 PyThreadState* __tstate = wxPyBeginAllowThreads();
21642 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 resultobj = SWIG_From_double(static_cast< double >(result));
21647 {
21648 if (temp2)
21649 delete arg2;
21650 }
21651 return resultobj;
21652 fail:
21653 {
21654 if (temp2)
21655 delete arg2;
21656 }
21657 return NULL;
21658 }
21659
21660
21661 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21662 PyObject *resultobj = 0;
21663 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21664 wxString *arg2 = 0 ;
21665 bool arg3 = (bool) false ;
21666 bool result;
21667 void *argp1 = 0 ;
21668 int res1 = 0 ;
21669 bool temp2 = false ;
21670 bool val3 ;
21671 int ecode3 = 0 ;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 PyObject * obj2 = 0 ;
21675 char * kwnames[] = {
21676 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21677 };
21678
21679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21683 }
21684 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21685 {
21686 arg2 = wxString_in_helper(obj1);
21687 if (arg2 == NULL) SWIG_fail;
21688 temp2 = true;
21689 }
21690 if (obj2) {
21691 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21692 if (!SWIG_IsOK(ecode3)) {
21693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21694 }
21695 arg3 = static_cast< bool >(val3);
21696 }
21697 {
21698 PyThreadState* __tstate = wxPyBeginAllowThreads();
21699 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21700 wxPyEndAllowThreads(__tstate);
21701 if (PyErr_Occurred()) SWIG_fail;
21702 }
21703 {
21704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21705 }
21706 {
21707 if (temp2)
21708 delete arg2;
21709 }
21710 return resultobj;
21711 fail:
21712 {
21713 if (temp2)
21714 delete arg2;
21715 }
21716 return NULL;
21717 }
21718
21719
21720 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21721 PyObject *resultobj = 0;
21722 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21723 wxString *arg2 = 0 ;
21724 wxString *arg3 = 0 ;
21725 bool result;
21726 void *argp1 = 0 ;
21727 int res1 = 0 ;
21728 bool temp2 = false ;
21729 bool temp3 = false ;
21730 PyObject * obj0 = 0 ;
21731 PyObject * obj1 = 0 ;
21732 PyObject * obj2 = 0 ;
21733 char * kwnames[] = {
21734 (char *) "self",(char *) "key",(char *) "value", NULL
21735 };
21736
21737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21739 if (!SWIG_IsOK(res1)) {
21740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21741 }
21742 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21743 {
21744 arg2 = wxString_in_helper(obj1);
21745 if (arg2 == NULL) SWIG_fail;
21746 temp2 = true;
21747 }
21748 {
21749 arg3 = wxString_in_helper(obj2);
21750 if (arg3 == NULL) SWIG_fail;
21751 temp3 = true;
21752 }
21753 {
21754 PyThreadState* __tstate = wxPyBeginAllowThreads();
21755 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21756 wxPyEndAllowThreads(__tstate);
21757 if (PyErr_Occurred()) SWIG_fail;
21758 }
21759 {
21760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21761 }
21762 {
21763 if (temp2)
21764 delete arg2;
21765 }
21766 {
21767 if (temp3)
21768 delete arg3;
21769 }
21770 return resultobj;
21771 fail:
21772 {
21773 if (temp2)
21774 delete arg2;
21775 }
21776 {
21777 if (temp3)
21778 delete arg3;
21779 }
21780 return NULL;
21781 }
21782
21783
21784 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21785 PyObject *resultobj = 0;
21786 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21787 wxString *arg2 = 0 ;
21788 long arg3 ;
21789 bool result;
21790 void *argp1 = 0 ;
21791 int res1 = 0 ;
21792 bool temp2 = false ;
21793 long val3 ;
21794 int ecode3 = 0 ;
21795 PyObject * obj0 = 0 ;
21796 PyObject * obj1 = 0 ;
21797 PyObject * obj2 = 0 ;
21798 char * kwnames[] = {
21799 (char *) "self",(char *) "key",(char *) "value", NULL
21800 };
21801
21802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21804 if (!SWIG_IsOK(res1)) {
21805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21806 }
21807 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21808 {
21809 arg2 = wxString_in_helper(obj1);
21810 if (arg2 == NULL) SWIG_fail;
21811 temp2 = true;
21812 }
21813 ecode3 = SWIG_AsVal_long(obj2, &val3);
21814 if (!SWIG_IsOK(ecode3)) {
21815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21816 }
21817 arg3 = static_cast< long >(val3);
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21821 wxPyEndAllowThreads(__tstate);
21822 if (PyErr_Occurred()) SWIG_fail;
21823 }
21824 {
21825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21826 }
21827 {
21828 if (temp2)
21829 delete arg2;
21830 }
21831 return resultobj;
21832 fail:
21833 {
21834 if (temp2)
21835 delete arg2;
21836 }
21837 return NULL;
21838 }
21839
21840
21841 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21842 PyObject *resultobj = 0;
21843 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21844 wxString *arg2 = 0 ;
21845 double arg3 ;
21846 bool result;
21847 void *argp1 = 0 ;
21848 int res1 = 0 ;
21849 bool temp2 = false ;
21850 double val3 ;
21851 int ecode3 = 0 ;
21852 PyObject * obj0 = 0 ;
21853 PyObject * obj1 = 0 ;
21854 PyObject * obj2 = 0 ;
21855 char * kwnames[] = {
21856 (char *) "self",(char *) "key",(char *) "value", NULL
21857 };
21858
21859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21863 }
21864 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21865 {
21866 arg2 = wxString_in_helper(obj1);
21867 if (arg2 == NULL) SWIG_fail;
21868 temp2 = true;
21869 }
21870 ecode3 = SWIG_AsVal_double(obj2, &val3);
21871 if (!SWIG_IsOK(ecode3)) {
21872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21873 }
21874 arg3 = static_cast< double >(val3);
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21878 wxPyEndAllowThreads(__tstate);
21879 if (PyErr_Occurred()) SWIG_fail;
21880 }
21881 {
21882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21883 }
21884 {
21885 if (temp2)
21886 delete arg2;
21887 }
21888 return resultobj;
21889 fail:
21890 {
21891 if (temp2)
21892 delete arg2;
21893 }
21894 return NULL;
21895 }
21896
21897
21898 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21899 PyObject *resultobj = 0;
21900 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21901 wxString *arg2 = 0 ;
21902 bool arg3 ;
21903 bool result;
21904 void *argp1 = 0 ;
21905 int res1 = 0 ;
21906 bool temp2 = false ;
21907 bool val3 ;
21908 int ecode3 = 0 ;
21909 PyObject * obj0 = 0 ;
21910 PyObject * obj1 = 0 ;
21911 PyObject * obj2 = 0 ;
21912 char * kwnames[] = {
21913 (char *) "self",(char *) "key",(char *) "value", NULL
21914 };
21915
21916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21918 if (!SWIG_IsOK(res1)) {
21919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21920 }
21921 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21922 {
21923 arg2 = wxString_in_helper(obj1);
21924 if (arg2 == NULL) SWIG_fail;
21925 temp2 = true;
21926 }
21927 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21928 if (!SWIG_IsOK(ecode3)) {
21929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21930 }
21931 arg3 = static_cast< bool >(val3);
21932 {
21933 PyThreadState* __tstate = wxPyBeginAllowThreads();
21934 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21935 wxPyEndAllowThreads(__tstate);
21936 if (PyErr_Occurred()) SWIG_fail;
21937 }
21938 {
21939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21940 }
21941 {
21942 if (temp2)
21943 delete arg2;
21944 }
21945 return resultobj;
21946 fail:
21947 {
21948 if (temp2)
21949 delete arg2;
21950 }
21951 return NULL;
21952 }
21953
21954
21955 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21956 PyObject *resultobj = 0;
21957 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21958 bool arg2 = (bool) false ;
21959 bool result;
21960 void *argp1 = 0 ;
21961 int res1 = 0 ;
21962 bool val2 ;
21963 int ecode2 = 0 ;
21964 PyObject * obj0 = 0 ;
21965 PyObject * obj1 = 0 ;
21966 char * kwnames[] = {
21967 (char *) "self",(char *) "currentOnly", NULL
21968 };
21969
21970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21972 if (!SWIG_IsOK(res1)) {
21973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21974 }
21975 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21976 if (obj1) {
21977 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21978 if (!SWIG_IsOK(ecode2)) {
21979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21980 }
21981 arg2 = static_cast< bool >(val2);
21982 }
21983 {
21984 PyThreadState* __tstate = wxPyBeginAllowThreads();
21985 result = (bool)(arg1)->Flush(arg2);
21986 wxPyEndAllowThreads(__tstate);
21987 if (PyErr_Occurred()) SWIG_fail;
21988 }
21989 {
21990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21991 }
21992 return resultobj;
21993 fail:
21994 return NULL;
21995 }
21996
21997
21998 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21999 PyObject *resultobj = 0;
22000 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22001 wxString *arg2 = 0 ;
22002 wxString *arg3 = 0 ;
22003 bool result;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 bool temp2 = false ;
22007 bool temp3 = false ;
22008 PyObject * obj0 = 0 ;
22009 PyObject * obj1 = 0 ;
22010 PyObject * obj2 = 0 ;
22011 char * kwnames[] = {
22012 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22013 };
22014
22015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22017 if (!SWIG_IsOK(res1)) {
22018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22019 }
22020 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22021 {
22022 arg2 = wxString_in_helper(obj1);
22023 if (arg2 == NULL) SWIG_fail;
22024 temp2 = true;
22025 }
22026 {
22027 arg3 = wxString_in_helper(obj2);
22028 if (arg3 == NULL) SWIG_fail;
22029 temp3 = true;
22030 }
22031 {
22032 PyThreadState* __tstate = wxPyBeginAllowThreads();
22033 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 {
22038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22039 }
22040 {
22041 if (temp2)
22042 delete arg2;
22043 }
22044 {
22045 if (temp3)
22046 delete arg3;
22047 }
22048 return resultobj;
22049 fail:
22050 {
22051 if (temp2)
22052 delete arg2;
22053 }
22054 {
22055 if (temp3)
22056 delete arg3;
22057 }
22058 return NULL;
22059 }
22060
22061
22062 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22063 PyObject *resultobj = 0;
22064 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22065 wxString *arg2 = 0 ;
22066 wxString *arg3 = 0 ;
22067 bool result;
22068 void *argp1 = 0 ;
22069 int res1 = 0 ;
22070 bool temp2 = false ;
22071 bool temp3 = false ;
22072 PyObject * obj0 = 0 ;
22073 PyObject * obj1 = 0 ;
22074 PyObject * obj2 = 0 ;
22075 char * kwnames[] = {
22076 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22077 };
22078
22079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22081 if (!SWIG_IsOK(res1)) {
22082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22083 }
22084 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22085 {
22086 arg2 = wxString_in_helper(obj1);
22087 if (arg2 == NULL) SWIG_fail;
22088 temp2 = true;
22089 }
22090 {
22091 arg3 = wxString_in_helper(obj2);
22092 if (arg3 == NULL) SWIG_fail;
22093 temp3 = true;
22094 }
22095 {
22096 PyThreadState* __tstate = wxPyBeginAllowThreads();
22097 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22098 wxPyEndAllowThreads(__tstate);
22099 if (PyErr_Occurred()) SWIG_fail;
22100 }
22101 {
22102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22103 }
22104 {
22105 if (temp2)
22106 delete arg2;
22107 }
22108 {
22109 if (temp3)
22110 delete arg3;
22111 }
22112 return resultobj;
22113 fail:
22114 {
22115 if (temp2)
22116 delete arg2;
22117 }
22118 {
22119 if (temp3)
22120 delete arg3;
22121 }
22122 return NULL;
22123 }
22124
22125
22126 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22127 PyObject *resultobj = 0;
22128 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22129 wxString *arg2 = 0 ;
22130 bool arg3 = (bool) true ;
22131 bool result;
22132 void *argp1 = 0 ;
22133 int res1 = 0 ;
22134 bool temp2 = false ;
22135 bool val3 ;
22136 int ecode3 = 0 ;
22137 PyObject * obj0 = 0 ;
22138 PyObject * obj1 = 0 ;
22139 PyObject * obj2 = 0 ;
22140 char * kwnames[] = {
22141 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22142 };
22143
22144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22146 if (!SWIG_IsOK(res1)) {
22147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22148 }
22149 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22150 {
22151 arg2 = wxString_in_helper(obj1);
22152 if (arg2 == NULL) SWIG_fail;
22153 temp2 = true;
22154 }
22155 if (obj2) {
22156 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22157 if (!SWIG_IsOK(ecode3)) {
22158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22159 }
22160 arg3 = static_cast< bool >(val3);
22161 }
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 {
22169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22170 }
22171 {
22172 if (temp2)
22173 delete arg2;
22174 }
22175 return resultobj;
22176 fail:
22177 {
22178 if (temp2)
22179 delete arg2;
22180 }
22181 return NULL;
22182 }
22183
22184
22185 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22186 PyObject *resultobj = 0;
22187 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22188 wxString *arg2 = 0 ;
22189 bool result;
22190 void *argp1 = 0 ;
22191 int res1 = 0 ;
22192 bool temp2 = false ;
22193 PyObject * obj0 = 0 ;
22194 PyObject * obj1 = 0 ;
22195 char * kwnames[] = {
22196 (char *) "self",(char *) "key", NULL
22197 };
22198
22199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22201 if (!SWIG_IsOK(res1)) {
22202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22203 }
22204 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22205 {
22206 arg2 = wxString_in_helper(obj1);
22207 if (arg2 == NULL) SWIG_fail;
22208 temp2 = true;
22209 }
22210 {
22211 PyThreadState* __tstate = wxPyBeginAllowThreads();
22212 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22213 wxPyEndAllowThreads(__tstate);
22214 if (PyErr_Occurred()) SWIG_fail;
22215 }
22216 {
22217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22218 }
22219 {
22220 if (temp2)
22221 delete arg2;
22222 }
22223 return resultobj;
22224 fail:
22225 {
22226 if (temp2)
22227 delete arg2;
22228 }
22229 return NULL;
22230 }
22231
22232
22233 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22234 PyObject *resultobj = 0;
22235 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22236 bool result;
22237 void *argp1 = 0 ;
22238 int res1 = 0 ;
22239 PyObject *swig_obj[1] ;
22240
22241 if (!args) SWIG_fail;
22242 swig_obj[0] = args;
22243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22244 if (!SWIG_IsOK(res1)) {
22245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22246 }
22247 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22248 {
22249 PyThreadState* __tstate = wxPyBeginAllowThreads();
22250 result = (bool)(arg1)->DeleteAll();
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 {
22255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22256 }
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj = 0;
22265 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22266 bool arg2 = (bool) true ;
22267 void *argp1 = 0 ;
22268 int res1 = 0 ;
22269 bool val2 ;
22270 int ecode2 = 0 ;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 char * kwnames[] = {
22274 (char *) "self",(char *) "doIt", NULL
22275 };
22276
22277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22279 if (!SWIG_IsOK(res1)) {
22280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22281 }
22282 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22283 if (obj1) {
22284 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22285 if (!SWIG_IsOK(ecode2)) {
22286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22287 }
22288 arg2 = static_cast< bool >(val2);
22289 }
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 (arg1)->SetExpandEnvVars(arg2);
22293 wxPyEndAllowThreads(__tstate);
22294 if (PyErr_Occurred()) SWIG_fail;
22295 }
22296 resultobj = SWIG_Py_Void();
22297 return resultobj;
22298 fail:
22299 return NULL;
22300 }
22301
22302
22303 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22304 PyObject *resultobj = 0;
22305 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22306 bool result;
22307 void *argp1 = 0 ;
22308 int res1 = 0 ;
22309 PyObject *swig_obj[1] ;
22310
22311 if (!args) SWIG_fail;
22312 swig_obj[0] = args;
22313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22314 if (!SWIG_IsOK(res1)) {
22315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22316 }
22317 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22318 {
22319 PyThreadState* __tstate = wxPyBeginAllowThreads();
22320 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22321 wxPyEndAllowThreads(__tstate);
22322 if (PyErr_Occurred()) SWIG_fail;
22323 }
22324 {
22325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22326 }
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22334 PyObject *resultobj = 0;
22335 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22336 bool arg2 = (bool) true ;
22337 void *argp1 = 0 ;
22338 int res1 = 0 ;
22339 bool val2 ;
22340 int ecode2 = 0 ;
22341 PyObject * obj0 = 0 ;
22342 PyObject * obj1 = 0 ;
22343 char * kwnames[] = {
22344 (char *) "self",(char *) "doIt", NULL
22345 };
22346
22347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22349 if (!SWIG_IsOK(res1)) {
22350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22351 }
22352 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22353 if (obj1) {
22354 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22355 if (!SWIG_IsOK(ecode2)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22357 }
22358 arg2 = static_cast< bool >(val2);
22359 }
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 (arg1)->SetRecordDefaults(arg2);
22363 wxPyEndAllowThreads(__tstate);
22364 if (PyErr_Occurred()) SWIG_fail;
22365 }
22366 resultobj = SWIG_Py_Void();
22367 return resultobj;
22368 fail:
22369 return NULL;
22370 }
22371
22372
22373 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22374 PyObject *resultobj = 0;
22375 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22376 bool result;
22377 void *argp1 = 0 ;
22378 int res1 = 0 ;
22379 PyObject *swig_obj[1] ;
22380
22381 if (!args) SWIG_fail;
22382 swig_obj[0] = args;
22383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22384 if (!SWIG_IsOK(res1)) {
22385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22386 }
22387 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22388 {
22389 PyThreadState* __tstate = wxPyBeginAllowThreads();
22390 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22391 wxPyEndAllowThreads(__tstate);
22392 if (PyErr_Occurred()) SWIG_fail;
22393 }
22394 {
22395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22396 }
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22404 PyObject *resultobj = 0;
22405 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22406 wxString *arg2 = 0 ;
22407 wxString result;
22408 void *argp1 = 0 ;
22409 int res1 = 0 ;
22410 bool temp2 = false ;
22411 PyObject * obj0 = 0 ;
22412 PyObject * obj1 = 0 ;
22413 char * kwnames[] = {
22414 (char *) "self",(char *) "str", NULL
22415 };
22416
22417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22419 if (!SWIG_IsOK(res1)) {
22420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22421 }
22422 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22423 {
22424 arg2 = wxString_in_helper(obj1);
22425 if (arg2 == NULL) SWIG_fail;
22426 temp2 = true;
22427 }
22428 {
22429 PyThreadState* __tstate = wxPyBeginAllowThreads();
22430 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22431 wxPyEndAllowThreads(__tstate);
22432 if (PyErr_Occurred()) SWIG_fail;
22433 }
22434 {
22435 #if wxUSE_UNICODE
22436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22437 #else
22438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22439 #endif
22440 }
22441 {
22442 if (temp2)
22443 delete arg2;
22444 }
22445 return resultobj;
22446 fail:
22447 {
22448 if (temp2)
22449 delete arg2;
22450 }
22451 return NULL;
22452 }
22453
22454
22455 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22456 PyObject *resultobj = 0;
22457 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22458 wxString result;
22459 void *argp1 = 0 ;
22460 int res1 = 0 ;
22461 PyObject *swig_obj[1] ;
22462
22463 if (!args) SWIG_fail;
22464 swig_obj[0] = args;
22465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22466 if (!SWIG_IsOK(res1)) {
22467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22468 }
22469 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22470 {
22471 PyThreadState* __tstate = wxPyBeginAllowThreads();
22472 result = ((wxConfigBase const *)arg1)->GetAppName();
22473 wxPyEndAllowThreads(__tstate);
22474 if (PyErr_Occurred()) SWIG_fail;
22475 }
22476 {
22477 #if wxUSE_UNICODE
22478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22479 #else
22480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22481 #endif
22482 }
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22490 PyObject *resultobj = 0;
22491 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22492 wxString result;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 PyObject *swig_obj[1] ;
22496
22497 if (!args) SWIG_fail;
22498 swig_obj[0] = args;
22499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22500 if (!SWIG_IsOK(res1)) {
22501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22502 }
22503 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22504 {
22505 PyThreadState* __tstate = wxPyBeginAllowThreads();
22506 result = ((wxConfigBase const *)arg1)->GetVendorName();
22507 wxPyEndAllowThreads(__tstate);
22508 if (PyErr_Occurred()) SWIG_fail;
22509 }
22510 {
22511 #if wxUSE_UNICODE
22512 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22513 #else
22514 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22515 #endif
22516 }
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj = 0;
22525 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22526 wxString *arg2 = 0 ;
22527 void *argp1 = 0 ;
22528 int res1 = 0 ;
22529 bool temp2 = false ;
22530 PyObject * obj0 = 0 ;
22531 PyObject * obj1 = 0 ;
22532 char * kwnames[] = {
22533 (char *) "self",(char *) "appName", NULL
22534 };
22535
22536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22540 }
22541 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22542 {
22543 arg2 = wxString_in_helper(obj1);
22544 if (arg2 == NULL) SWIG_fail;
22545 temp2 = true;
22546 }
22547 {
22548 PyThreadState* __tstate = wxPyBeginAllowThreads();
22549 (arg1)->SetAppName((wxString const &)*arg2);
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 resultobj = SWIG_Py_Void();
22554 {
22555 if (temp2)
22556 delete arg2;
22557 }
22558 return resultobj;
22559 fail:
22560 {
22561 if (temp2)
22562 delete arg2;
22563 }
22564 return NULL;
22565 }
22566
22567
22568 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22569 PyObject *resultobj = 0;
22570 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22571 wxString *arg2 = 0 ;
22572 void *argp1 = 0 ;
22573 int res1 = 0 ;
22574 bool temp2 = false ;
22575 PyObject * obj0 = 0 ;
22576 PyObject * obj1 = 0 ;
22577 char * kwnames[] = {
22578 (char *) "self",(char *) "vendorName", NULL
22579 };
22580
22581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22583 if (!SWIG_IsOK(res1)) {
22584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22585 }
22586 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22587 {
22588 arg2 = wxString_in_helper(obj1);
22589 if (arg2 == NULL) SWIG_fail;
22590 temp2 = true;
22591 }
22592 {
22593 PyThreadState* __tstate = wxPyBeginAllowThreads();
22594 (arg1)->SetVendorName((wxString const &)*arg2);
22595 wxPyEndAllowThreads(__tstate);
22596 if (PyErr_Occurred()) SWIG_fail;
22597 }
22598 resultobj = SWIG_Py_Void();
22599 {
22600 if (temp2)
22601 delete arg2;
22602 }
22603 return resultobj;
22604 fail:
22605 {
22606 if (temp2)
22607 delete arg2;
22608 }
22609 return NULL;
22610 }
22611
22612
22613 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22614 PyObject *resultobj = 0;
22615 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22616 long arg2 ;
22617 void *argp1 = 0 ;
22618 int res1 = 0 ;
22619 long val2 ;
22620 int ecode2 = 0 ;
22621 PyObject * obj0 = 0 ;
22622 PyObject * obj1 = 0 ;
22623 char * kwnames[] = {
22624 (char *) "self",(char *) "style", NULL
22625 };
22626
22627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22629 if (!SWIG_IsOK(res1)) {
22630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22631 }
22632 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22633 ecode2 = SWIG_AsVal_long(obj1, &val2);
22634 if (!SWIG_IsOK(ecode2)) {
22635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22636 }
22637 arg2 = static_cast< long >(val2);
22638 {
22639 PyThreadState* __tstate = wxPyBeginAllowThreads();
22640 (arg1)->SetStyle(arg2);
22641 wxPyEndAllowThreads(__tstate);
22642 if (PyErr_Occurred()) SWIG_fail;
22643 }
22644 resultobj = SWIG_Py_Void();
22645 return resultobj;
22646 fail:
22647 return NULL;
22648 }
22649
22650
22651 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22652 PyObject *resultobj = 0;
22653 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22654 long result;
22655 void *argp1 = 0 ;
22656 int res1 = 0 ;
22657 PyObject *swig_obj[1] ;
22658
22659 if (!args) SWIG_fail;
22660 swig_obj[0] = args;
22661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22662 if (!SWIG_IsOK(res1)) {
22663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22664 }
22665 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22666 {
22667 PyThreadState* __tstate = wxPyBeginAllowThreads();
22668 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22669 wxPyEndAllowThreads(__tstate);
22670 if (PyErr_Occurred()) SWIG_fail;
22671 }
22672 resultobj = SWIG_From_long(static_cast< long >(result));
22673 return resultobj;
22674 fail:
22675 return NULL;
22676 }
22677
22678
22679 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22680 PyObject *obj;
22681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22682 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22683 return SWIG_Py_Void();
22684 }
22685
22686 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22687 PyObject *resultobj = 0;
22688 wxString const &arg1_defvalue = wxPyEmptyString ;
22689 wxString *arg1 = (wxString *) &arg1_defvalue ;
22690 wxString const &arg2_defvalue = wxPyEmptyString ;
22691 wxString *arg2 = (wxString *) &arg2_defvalue ;
22692 wxString const &arg3_defvalue = wxPyEmptyString ;
22693 wxString *arg3 = (wxString *) &arg3_defvalue ;
22694 wxString const &arg4_defvalue = wxPyEmptyString ;
22695 wxString *arg4 = (wxString *) &arg4_defvalue ;
22696 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22697 wxConfig *result = 0 ;
22698 bool temp1 = false ;
22699 bool temp2 = false ;
22700 bool temp3 = false ;
22701 bool temp4 = false ;
22702 long val5 ;
22703 int ecode5 = 0 ;
22704 PyObject * obj0 = 0 ;
22705 PyObject * obj1 = 0 ;
22706 PyObject * obj2 = 0 ;
22707 PyObject * obj3 = 0 ;
22708 PyObject * obj4 = 0 ;
22709 char * kwnames[] = {
22710 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22711 };
22712
22713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22714 if (obj0) {
22715 {
22716 arg1 = wxString_in_helper(obj0);
22717 if (arg1 == NULL) SWIG_fail;
22718 temp1 = true;
22719 }
22720 }
22721 if (obj1) {
22722 {
22723 arg2 = wxString_in_helper(obj1);
22724 if (arg2 == NULL) SWIG_fail;
22725 temp2 = true;
22726 }
22727 }
22728 if (obj2) {
22729 {
22730 arg3 = wxString_in_helper(obj2);
22731 if (arg3 == NULL) SWIG_fail;
22732 temp3 = true;
22733 }
22734 }
22735 if (obj3) {
22736 {
22737 arg4 = wxString_in_helper(obj3);
22738 if (arg4 == NULL) SWIG_fail;
22739 temp4 = true;
22740 }
22741 }
22742 if (obj4) {
22743 ecode5 = SWIG_AsVal_long(obj4, &val5);
22744 if (!SWIG_IsOK(ecode5)) {
22745 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22746 }
22747 arg5 = static_cast< long >(val5);
22748 }
22749 {
22750 PyThreadState* __tstate = wxPyBeginAllowThreads();
22751 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22752 wxPyEndAllowThreads(__tstate);
22753 if (PyErr_Occurred()) SWIG_fail;
22754 }
22755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22756 {
22757 if (temp1)
22758 delete arg1;
22759 }
22760 {
22761 if (temp2)
22762 delete arg2;
22763 }
22764 {
22765 if (temp3)
22766 delete arg3;
22767 }
22768 {
22769 if (temp4)
22770 delete arg4;
22771 }
22772 return resultobj;
22773 fail:
22774 {
22775 if (temp1)
22776 delete arg1;
22777 }
22778 {
22779 if (temp2)
22780 delete arg2;
22781 }
22782 {
22783 if (temp3)
22784 delete arg3;
22785 }
22786 {
22787 if (temp4)
22788 delete arg4;
22789 }
22790 return NULL;
22791 }
22792
22793
22794 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22795 PyObject *resultobj = 0;
22796 wxConfig *arg1 = (wxConfig *) 0 ;
22797 void *argp1 = 0 ;
22798 int res1 = 0 ;
22799 PyObject *swig_obj[1] ;
22800
22801 if (!args) SWIG_fail;
22802 swig_obj[0] = args;
22803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22804 if (!SWIG_IsOK(res1)) {
22805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22806 }
22807 arg1 = reinterpret_cast< wxConfig * >(argp1);
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 delete arg1;
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 resultobj = SWIG_Py_Void();
22816 return resultobj;
22817 fail:
22818 return NULL;
22819 }
22820
22821
22822 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22823 PyObject *obj;
22824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22825 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22826 return SWIG_Py_Void();
22827 }
22828
22829 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22830 return SWIG_Python_InitShadowInstance(args);
22831 }
22832
22833 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22834 PyObject *resultobj = 0;
22835 wxString const &arg1_defvalue = wxPyEmptyString ;
22836 wxString *arg1 = (wxString *) &arg1_defvalue ;
22837 wxString const &arg2_defvalue = wxPyEmptyString ;
22838 wxString *arg2 = (wxString *) &arg2_defvalue ;
22839 wxString const &arg3_defvalue = wxPyEmptyString ;
22840 wxString *arg3 = (wxString *) &arg3_defvalue ;
22841 wxString const &arg4_defvalue = wxPyEmptyString ;
22842 wxString *arg4 = (wxString *) &arg4_defvalue ;
22843 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22844 wxFileConfig *result = 0 ;
22845 bool temp1 = false ;
22846 bool temp2 = false ;
22847 bool temp3 = false ;
22848 bool temp4 = false ;
22849 long val5 ;
22850 int ecode5 = 0 ;
22851 PyObject * obj0 = 0 ;
22852 PyObject * obj1 = 0 ;
22853 PyObject * obj2 = 0 ;
22854 PyObject * obj3 = 0 ;
22855 PyObject * obj4 = 0 ;
22856 char * kwnames[] = {
22857 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22858 };
22859
22860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22861 if (obj0) {
22862 {
22863 arg1 = wxString_in_helper(obj0);
22864 if (arg1 == NULL) SWIG_fail;
22865 temp1 = true;
22866 }
22867 }
22868 if (obj1) {
22869 {
22870 arg2 = wxString_in_helper(obj1);
22871 if (arg2 == NULL) SWIG_fail;
22872 temp2 = true;
22873 }
22874 }
22875 if (obj2) {
22876 {
22877 arg3 = wxString_in_helper(obj2);
22878 if (arg3 == NULL) SWIG_fail;
22879 temp3 = true;
22880 }
22881 }
22882 if (obj3) {
22883 {
22884 arg4 = wxString_in_helper(obj3);
22885 if (arg4 == NULL) SWIG_fail;
22886 temp4 = true;
22887 }
22888 }
22889 if (obj4) {
22890 ecode5 = SWIG_AsVal_long(obj4, &val5);
22891 if (!SWIG_IsOK(ecode5)) {
22892 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22893 }
22894 arg5 = static_cast< long >(val5);
22895 }
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22903 {
22904 if (temp1)
22905 delete arg1;
22906 }
22907 {
22908 if (temp2)
22909 delete arg2;
22910 }
22911 {
22912 if (temp3)
22913 delete arg3;
22914 }
22915 {
22916 if (temp4)
22917 delete arg4;
22918 }
22919 return resultobj;
22920 fail:
22921 {
22922 if (temp1)
22923 delete arg1;
22924 }
22925 {
22926 if (temp2)
22927 delete arg2;
22928 }
22929 {
22930 if (temp3)
22931 delete arg3;
22932 }
22933 {
22934 if (temp4)
22935 delete arg4;
22936 }
22937 return NULL;
22938 }
22939
22940
22941 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22942 PyObject *resultobj = 0;
22943 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22944 void *argp1 = 0 ;
22945 int res1 = 0 ;
22946 PyObject *swig_obj[1] ;
22947
22948 if (!args) SWIG_fail;
22949 swig_obj[0] = args;
22950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22951 if (!SWIG_IsOK(res1)) {
22952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22953 }
22954 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22955 {
22956 PyThreadState* __tstate = wxPyBeginAllowThreads();
22957 delete arg1;
22958
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 resultobj = SWIG_Py_Void();
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22970 PyObject *obj;
22971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22972 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22973 return SWIG_Py_Void();
22974 }
22975
22976 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22977 return SWIG_Python_InitShadowInstance(args);
22978 }
22979
22980 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22981 PyObject *resultobj = 0;
22982 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22983 wxString *arg2 = 0 ;
22984 wxConfigPathChanger *result = 0 ;
22985 void *argp1 = 0 ;
22986 int res1 = 0 ;
22987 bool temp2 = false ;
22988 PyObject * obj0 = 0 ;
22989 PyObject * obj1 = 0 ;
22990 char * kwnames[] = {
22991 (char *) "config",(char *) "entry", NULL
22992 };
22993
22994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22996 if (!SWIG_IsOK(res1)) {
22997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22998 }
22999 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23000 {
23001 arg2 = wxString_in_helper(obj1);
23002 if (arg2 == NULL) SWIG_fail;
23003 temp2 = true;
23004 }
23005 {
23006 PyThreadState* __tstate = wxPyBeginAllowThreads();
23007 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23012 {
23013 if (temp2)
23014 delete arg2;
23015 }
23016 return resultobj;
23017 fail:
23018 {
23019 if (temp2)
23020 delete arg2;
23021 }
23022 return NULL;
23023 }
23024
23025
23026 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23027 PyObject *resultobj = 0;
23028 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23029 void *argp1 = 0 ;
23030 int res1 = 0 ;
23031 PyObject *swig_obj[1] ;
23032
23033 if (!args) SWIG_fail;
23034 swig_obj[0] = args;
23035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23036 if (!SWIG_IsOK(res1)) {
23037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23038 }
23039 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23040 {
23041 PyThreadState* __tstate = wxPyBeginAllowThreads();
23042 delete arg1;
23043
23044 wxPyEndAllowThreads(__tstate);
23045 if (PyErr_Occurred()) SWIG_fail;
23046 }
23047 resultobj = SWIG_Py_Void();
23048 return resultobj;
23049 fail:
23050 return NULL;
23051 }
23052
23053
23054 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23055 PyObject *resultobj = 0;
23056 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23057 wxString *result = 0 ;
23058 void *argp1 = 0 ;
23059 int res1 = 0 ;
23060 PyObject *swig_obj[1] ;
23061
23062 if (!args) SWIG_fail;
23063 swig_obj[0] = args;
23064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23065 if (!SWIG_IsOK(res1)) {
23066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23067 }
23068 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 {
23072 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23073 result = (wxString *) &_result_ref;
23074 }
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 {
23079 #if wxUSE_UNICODE
23080 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23081 #else
23082 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23083 #endif
23084 }
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23092 PyObject *obj;
23093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23094 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23095 return SWIG_Py_Void();
23096 }
23097
23098 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23099 return SWIG_Python_InitShadowInstance(args);
23100 }
23101
23102 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23103 PyObject *resultobj = 0;
23104 wxString *arg1 = 0 ;
23105 wxString result;
23106 bool temp1 = false ;
23107 PyObject * obj0 = 0 ;
23108 char * kwnames[] = {
23109 (char *) "sz", NULL
23110 };
23111
23112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23113 {
23114 arg1 = wxString_in_helper(obj0);
23115 if (arg1 == NULL) SWIG_fail;
23116 temp1 = true;
23117 }
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = wxExpandEnvVars((wxString const &)*arg1);
23121 wxPyEndAllowThreads(__tstate);
23122 if (PyErr_Occurred()) SWIG_fail;
23123 }
23124 {
23125 #if wxUSE_UNICODE
23126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23127 #else
23128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23129 #endif
23130 }
23131 {
23132 if (temp1)
23133 delete arg1;
23134 }
23135 return resultobj;
23136 fail:
23137 {
23138 if (temp1)
23139 delete arg1;
23140 }
23141 return NULL;
23142 }
23143
23144
23145 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23146 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23147 return 1;
23148 }
23149
23150
23151 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23152 PyObject *pyobj = 0;
23153
23154 {
23155 #if wxUSE_UNICODE
23156 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23157 #else
23158 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23159 #endif
23160 }
23161 return pyobj;
23162 }
23163
23164
23165 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23166 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23167 return 1;
23168 }
23169
23170
23171 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23172 PyObject *pyobj = 0;
23173
23174 {
23175 #if wxUSE_UNICODE
23176 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23177 #else
23178 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23179 #endif
23180 }
23181 return pyobj;
23182 }
23183
23184
23185 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23186 PyObject *resultobj = 0;
23187 wxDateTime::Country arg1 ;
23188 int val1 ;
23189 int ecode1 = 0 ;
23190 PyObject * obj0 = 0 ;
23191 char * kwnames[] = {
23192 (char *) "country", NULL
23193 };
23194
23195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23196 ecode1 = SWIG_AsVal_int(obj0, &val1);
23197 if (!SWIG_IsOK(ecode1)) {
23198 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23199 }
23200 arg1 = static_cast< wxDateTime::Country >(val1);
23201 {
23202 PyThreadState* __tstate = wxPyBeginAllowThreads();
23203 wxDateTime::SetCountry(arg1);
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 resultobj = SWIG_Py_Void();
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23215 PyObject *resultobj = 0;
23216 wxDateTime::Country result;
23217
23218 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23219 {
23220 PyThreadState* __tstate = wxPyBeginAllowThreads();
23221 result = (wxDateTime::Country)wxDateTime::GetCountry();
23222 wxPyEndAllowThreads(__tstate);
23223 if (PyErr_Occurred()) SWIG_fail;
23224 }
23225 resultobj = SWIG_From_int(static_cast< int >(result));
23226 return resultobj;
23227 fail:
23228 return NULL;
23229 }
23230
23231
23232 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23233 PyObject *resultobj = 0;
23234 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23235 bool result;
23236 int val1 ;
23237 int ecode1 = 0 ;
23238 PyObject * obj0 = 0 ;
23239 char * kwnames[] = {
23240 (char *) "country", NULL
23241 };
23242
23243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23244 if (obj0) {
23245 ecode1 = SWIG_AsVal_int(obj0, &val1);
23246 if (!SWIG_IsOK(ecode1)) {
23247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23248 }
23249 arg1 = static_cast< wxDateTime::Country >(val1);
23250 }
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23254 wxPyEndAllowThreads(__tstate);
23255 if (PyErr_Occurred()) SWIG_fail;
23256 }
23257 {
23258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23259 }
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23267 PyObject *resultobj = 0;
23268 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23269 int result;
23270 int val1 ;
23271 int ecode1 = 0 ;
23272 PyObject * obj0 = 0 ;
23273 char * kwnames[] = {
23274 (char *) "cal", NULL
23275 };
23276
23277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23278 if (obj0) {
23279 ecode1 = SWIG_AsVal_int(obj0, &val1);
23280 if (!SWIG_IsOK(ecode1)) {
23281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23282 }
23283 arg1 = static_cast< wxDateTime::Calendar >(val1);
23284 }
23285 {
23286 PyThreadState* __tstate = wxPyBeginAllowThreads();
23287 result = (int)wxDateTime::GetCurrentYear(arg1);
23288 wxPyEndAllowThreads(__tstate);
23289 if (PyErr_Occurred()) SWIG_fail;
23290 }
23291 resultobj = SWIG_From_int(static_cast< int >(result));
23292 return resultobj;
23293 fail:
23294 return NULL;
23295 }
23296
23297
23298 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23299 PyObject *resultobj = 0;
23300 int arg1 ;
23301 int result;
23302 int val1 ;
23303 int ecode1 = 0 ;
23304 PyObject * obj0 = 0 ;
23305 char * kwnames[] = {
23306 (char *) "year", NULL
23307 };
23308
23309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23310 ecode1 = SWIG_AsVal_int(obj0, &val1);
23311 if (!SWIG_IsOK(ecode1)) {
23312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23313 }
23314 arg1 = static_cast< int >(val1);
23315 {
23316 PyThreadState* __tstate = wxPyBeginAllowThreads();
23317 result = (int)wxDateTime::ConvertYearToBC(arg1);
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 resultobj = SWIG_From_int(static_cast< int >(result));
23322 return resultobj;
23323 fail:
23324 return NULL;
23325 }
23326
23327
23328 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23329 PyObject *resultobj = 0;
23330 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23331 wxDateTime::Month result;
23332 int val1 ;
23333 int ecode1 = 0 ;
23334 PyObject * obj0 = 0 ;
23335 char * kwnames[] = {
23336 (char *) "cal", NULL
23337 };
23338
23339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23340 if (obj0) {
23341 ecode1 = SWIG_AsVal_int(obj0, &val1);
23342 if (!SWIG_IsOK(ecode1)) {
23343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23344 }
23345 arg1 = static_cast< wxDateTime::Calendar >(val1);
23346 }
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 resultobj = SWIG_From_int(static_cast< int >(result));
23354 return resultobj;
23355 fail:
23356 return NULL;
23357 }
23358
23359
23360 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23361 PyObject *resultobj = 0;
23362 int arg1 = (int) wxDateTime::Inv_Year ;
23363 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23364 bool result;
23365 int val1 ;
23366 int ecode1 = 0 ;
23367 int val2 ;
23368 int ecode2 = 0 ;
23369 PyObject * obj0 = 0 ;
23370 PyObject * obj1 = 0 ;
23371 char * kwnames[] = {
23372 (char *) "year",(char *) "cal", NULL
23373 };
23374
23375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23376 if (obj0) {
23377 ecode1 = SWIG_AsVal_int(obj0, &val1);
23378 if (!SWIG_IsOK(ecode1)) {
23379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23380 }
23381 arg1 = static_cast< int >(val1);
23382 }
23383 if (obj1) {
23384 ecode2 = SWIG_AsVal_int(obj1, &val2);
23385 if (!SWIG_IsOK(ecode2)) {
23386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23387 }
23388 arg2 = static_cast< wxDateTime::Calendar >(val2);
23389 }
23390 {
23391 PyThreadState* __tstate = wxPyBeginAllowThreads();
23392 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23393 wxPyEndAllowThreads(__tstate);
23394 if (PyErr_Occurred()) SWIG_fail;
23395 }
23396 {
23397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23398 }
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj = 0;
23407 int arg1 = (int) wxDateTime::Inv_Year ;
23408 int result;
23409 int val1 ;
23410 int ecode1 = 0 ;
23411 PyObject * obj0 = 0 ;
23412 char * kwnames[] = {
23413 (char *) "year", NULL
23414 };
23415
23416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23417 if (obj0) {
23418 ecode1 = SWIG_AsVal_int(obj0, &val1);
23419 if (!SWIG_IsOK(ecode1)) {
23420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23421 }
23422 arg1 = static_cast< int >(val1);
23423 }
23424 {
23425 PyThreadState* __tstate = wxPyBeginAllowThreads();
23426 result = (int)wxDateTime::GetCentury(arg1);
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 resultobj = SWIG_From_int(static_cast< int >(result));
23431 return resultobj;
23432 fail:
23433 return NULL;
23434 }
23435
23436
23437 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23438 PyObject *resultobj = 0;
23439 int arg1 ;
23440 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23441 int result;
23442 int val1 ;
23443 int ecode1 = 0 ;
23444 int val2 ;
23445 int ecode2 = 0 ;
23446 PyObject * obj0 = 0 ;
23447 PyObject * obj1 = 0 ;
23448 char * kwnames[] = {
23449 (char *) "year",(char *) "cal", NULL
23450 };
23451
23452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23453 ecode1 = SWIG_AsVal_int(obj0, &val1);
23454 if (!SWIG_IsOK(ecode1)) {
23455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23456 }
23457 arg1 = static_cast< int >(val1);
23458 if (obj1) {
23459 ecode2 = SWIG_AsVal_int(obj1, &val2);
23460 if (!SWIG_IsOK(ecode2)) {
23461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23462 }
23463 arg2 = static_cast< wxDateTime::Calendar >(val2);
23464 }
23465 {
23466 PyThreadState* __tstate = wxPyBeginAllowThreads();
23467 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23468 wxPyEndAllowThreads(__tstate);
23469 if (PyErr_Occurred()) SWIG_fail;
23470 }
23471 resultobj = SWIG_From_int(static_cast< int >(result));
23472 return resultobj;
23473 fail:
23474 return NULL;
23475 }
23476
23477
23478 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23479 PyObject *resultobj = 0;
23480 wxDateTime::Month arg1 ;
23481 int arg2 = (int) wxDateTime::Inv_Year ;
23482 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23483 int result;
23484 int val1 ;
23485 int ecode1 = 0 ;
23486 int val2 ;
23487 int ecode2 = 0 ;
23488 int val3 ;
23489 int ecode3 = 0 ;
23490 PyObject * obj0 = 0 ;
23491 PyObject * obj1 = 0 ;
23492 PyObject * obj2 = 0 ;
23493 char * kwnames[] = {
23494 (char *) "month",(char *) "year",(char *) "cal", NULL
23495 };
23496
23497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23498 ecode1 = SWIG_AsVal_int(obj0, &val1);
23499 if (!SWIG_IsOK(ecode1)) {
23500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23501 }
23502 arg1 = static_cast< wxDateTime::Month >(val1);
23503 if (obj1) {
23504 ecode2 = SWIG_AsVal_int(obj1, &val2);
23505 if (!SWIG_IsOK(ecode2)) {
23506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23507 }
23508 arg2 = static_cast< int >(val2);
23509 }
23510 if (obj2) {
23511 ecode3 = SWIG_AsVal_int(obj2, &val3);
23512 if (!SWIG_IsOK(ecode3)) {
23513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23514 }
23515 arg3 = static_cast< wxDateTime::Calendar >(val3);
23516 }
23517 {
23518 PyThreadState* __tstate = wxPyBeginAllowThreads();
23519 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23520 wxPyEndAllowThreads(__tstate);
23521 if (PyErr_Occurred()) SWIG_fail;
23522 }
23523 resultobj = SWIG_From_int(static_cast< int >(result));
23524 return resultobj;
23525 fail:
23526 return NULL;
23527 }
23528
23529
23530 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23531 PyObject *resultobj = 0;
23532 wxDateTime::Month arg1 ;
23533 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23534 wxString result;
23535 int val1 ;
23536 int ecode1 = 0 ;
23537 int val2 ;
23538 int ecode2 = 0 ;
23539 PyObject * obj0 = 0 ;
23540 PyObject * obj1 = 0 ;
23541 char * kwnames[] = {
23542 (char *) "month",(char *) "flags", NULL
23543 };
23544
23545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23546 ecode1 = SWIG_AsVal_int(obj0, &val1);
23547 if (!SWIG_IsOK(ecode1)) {
23548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23549 }
23550 arg1 = static_cast< wxDateTime::Month >(val1);
23551 if (obj1) {
23552 ecode2 = SWIG_AsVal_int(obj1, &val2);
23553 if (!SWIG_IsOK(ecode2)) {
23554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23555 }
23556 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23557 }
23558 {
23559 PyThreadState* __tstate = wxPyBeginAllowThreads();
23560 result = wxDateTime::GetMonthName(arg1,arg2);
23561 wxPyEndAllowThreads(__tstate);
23562 if (PyErr_Occurred()) SWIG_fail;
23563 }
23564 {
23565 #if wxUSE_UNICODE
23566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23567 #else
23568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23569 #endif
23570 }
23571 return resultobj;
23572 fail:
23573 return NULL;
23574 }
23575
23576
23577 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23578 PyObject *resultobj = 0;
23579 wxDateTime::WeekDay arg1 ;
23580 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23581 wxString result;
23582 int val1 ;
23583 int ecode1 = 0 ;
23584 int val2 ;
23585 int ecode2 = 0 ;
23586 PyObject * obj0 = 0 ;
23587 PyObject * obj1 = 0 ;
23588 char * kwnames[] = {
23589 (char *) "weekday",(char *) "flags", NULL
23590 };
23591
23592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23593 ecode1 = SWIG_AsVal_int(obj0, &val1);
23594 if (!SWIG_IsOK(ecode1)) {
23595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23596 }
23597 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23598 if (obj1) {
23599 ecode2 = SWIG_AsVal_int(obj1, &val2);
23600 if (!SWIG_IsOK(ecode2)) {
23601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23602 }
23603 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23604 }
23605 {
23606 PyThreadState* __tstate = wxPyBeginAllowThreads();
23607 result = wxDateTime::GetWeekDayName(arg1,arg2);
23608 wxPyEndAllowThreads(__tstate);
23609 if (PyErr_Occurred()) SWIG_fail;
23610 }
23611 {
23612 #if wxUSE_UNICODE
23613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23614 #else
23615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23616 #endif
23617 }
23618 return resultobj;
23619 fail:
23620 return NULL;
23621 }
23622
23623
23624 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23625 PyObject *resultobj = 0;
23626 PyObject *result = 0 ;
23627
23628 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 result = (PyObject *)wxDateTime_GetAmPmStrings();
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 resultobj = result;
23636 return resultobj;
23637 fail:
23638 return NULL;
23639 }
23640
23641
23642 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23643 PyObject *resultobj = 0;
23644 int arg1 = (int) wxDateTime::Inv_Year ;
23645 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23646 bool result;
23647 int val1 ;
23648 int ecode1 = 0 ;
23649 int val2 ;
23650 int ecode2 = 0 ;
23651 PyObject * obj0 = 0 ;
23652 PyObject * obj1 = 0 ;
23653 char * kwnames[] = {
23654 (char *) "year",(char *) "country", NULL
23655 };
23656
23657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23658 if (obj0) {
23659 ecode1 = SWIG_AsVal_int(obj0, &val1);
23660 if (!SWIG_IsOK(ecode1)) {
23661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23662 }
23663 arg1 = static_cast< int >(val1);
23664 }
23665 if (obj1) {
23666 ecode2 = SWIG_AsVal_int(obj1, &val2);
23667 if (!SWIG_IsOK(ecode2)) {
23668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23669 }
23670 arg2 = static_cast< wxDateTime::Country >(val2);
23671 }
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 {
23679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23680 }
23681 return resultobj;
23682 fail:
23683 return NULL;
23684 }
23685
23686
23687 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23688 PyObject *resultobj = 0;
23689 int arg1 = (int) wxDateTime::Inv_Year ;
23690 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23691 wxDateTime result;
23692 int val1 ;
23693 int ecode1 = 0 ;
23694 int val2 ;
23695 int ecode2 = 0 ;
23696 PyObject * obj0 = 0 ;
23697 PyObject * obj1 = 0 ;
23698 char * kwnames[] = {
23699 (char *) "year",(char *) "country", NULL
23700 };
23701
23702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23703 if (obj0) {
23704 ecode1 = SWIG_AsVal_int(obj0, &val1);
23705 if (!SWIG_IsOK(ecode1)) {
23706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23707 }
23708 arg1 = static_cast< int >(val1);
23709 }
23710 if (obj1) {
23711 ecode2 = SWIG_AsVal_int(obj1, &val2);
23712 if (!SWIG_IsOK(ecode2)) {
23713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23714 }
23715 arg2 = static_cast< wxDateTime::Country >(val2);
23716 }
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 result = wxDateTime::GetBeginDST(arg1,arg2);
23720 wxPyEndAllowThreads(__tstate);
23721 if (PyErr_Occurred()) SWIG_fail;
23722 }
23723 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23724 return resultobj;
23725 fail:
23726 return NULL;
23727 }
23728
23729
23730 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23731 PyObject *resultobj = 0;
23732 int arg1 = (int) wxDateTime::Inv_Year ;
23733 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23734 wxDateTime result;
23735 int val1 ;
23736 int ecode1 = 0 ;
23737 int val2 ;
23738 int ecode2 = 0 ;
23739 PyObject * obj0 = 0 ;
23740 PyObject * obj1 = 0 ;
23741 char * kwnames[] = {
23742 (char *) "year",(char *) "country", NULL
23743 };
23744
23745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23746 if (obj0) {
23747 ecode1 = SWIG_AsVal_int(obj0, &val1);
23748 if (!SWIG_IsOK(ecode1)) {
23749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23750 }
23751 arg1 = static_cast< int >(val1);
23752 }
23753 if (obj1) {
23754 ecode2 = SWIG_AsVal_int(obj1, &val2);
23755 if (!SWIG_IsOK(ecode2)) {
23756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23757 }
23758 arg2 = static_cast< wxDateTime::Country >(val2);
23759 }
23760 {
23761 PyThreadState* __tstate = wxPyBeginAllowThreads();
23762 result = wxDateTime::GetEndDST(arg1,arg2);
23763 wxPyEndAllowThreads(__tstate);
23764 if (PyErr_Occurred()) SWIG_fail;
23765 }
23766 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23767 return resultobj;
23768 fail:
23769 return NULL;
23770 }
23771
23772
23773 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23774 PyObject *resultobj = 0;
23775 wxDateTime result;
23776
23777 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23778 {
23779 PyThreadState* __tstate = wxPyBeginAllowThreads();
23780 result = wxDateTime::Now();
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23785 return resultobj;
23786 fail:
23787 return NULL;
23788 }
23789
23790
23791 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23792 PyObject *resultobj = 0;
23793 wxDateTime result;
23794
23795 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 result = wxDateTime::UNow();
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *resultobj = 0;
23811 wxDateTime result;
23812
23813 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23814 {
23815 PyThreadState* __tstate = wxPyBeginAllowThreads();
23816 result = wxDateTime::Today();
23817 wxPyEndAllowThreads(__tstate);
23818 if (PyErr_Occurred()) SWIG_fail;
23819 }
23820 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23821 return resultobj;
23822 fail:
23823 return NULL;
23824 }
23825
23826
23827 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23828 PyObject *resultobj = 0;
23829 wxDateTime *result = 0 ;
23830
23831 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23832 {
23833 PyThreadState* __tstate = wxPyBeginAllowThreads();
23834 result = (wxDateTime *)new wxDateTime();
23835 wxPyEndAllowThreads(__tstate);
23836 if (PyErr_Occurred()) SWIG_fail;
23837 }
23838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23839 return resultobj;
23840 fail:
23841 return NULL;
23842 }
23843
23844
23845 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23846 PyObject *resultobj = 0;
23847 time_t arg1 ;
23848 wxDateTime *result = 0 ;
23849 unsigned int val1 ;
23850 int ecode1 = 0 ;
23851 PyObject * obj0 = 0 ;
23852 char * kwnames[] = {
23853 (char *) "timet", NULL
23854 };
23855
23856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23857 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23858 if (!SWIG_IsOK(ecode1)) {
23859 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23860 }
23861 arg1 = static_cast< time_t >(val1);
23862 {
23863 PyThreadState* __tstate = wxPyBeginAllowThreads();
23864 result = (wxDateTime *)new wxDateTime(arg1);
23865 wxPyEndAllowThreads(__tstate);
23866 if (PyErr_Occurred()) SWIG_fail;
23867 }
23868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23869 return resultobj;
23870 fail:
23871 return NULL;
23872 }
23873
23874
23875 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23876 PyObject *resultobj = 0;
23877 double arg1 ;
23878 wxDateTime *result = 0 ;
23879 double val1 ;
23880 int ecode1 = 0 ;
23881 PyObject * obj0 = 0 ;
23882 char * kwnames[] = {
23883 (char *) "jdn", NULL
23884 };
23885
23886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23887 ecode1 = SWIG_AsVal_double(obj0, &val1);
23888 if (!SWIG_IsOK(ecode1)) {
23889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23890 }
23891 arg1 = static_cast< double >(val1);
23892 {
23893 PyThreadState* __tstate = wxPyBeginAllowThreads();
23894 result = (wxDateTime *)new wxDateTime(arg1);
23895 wxPyEndAllowThreads(__tstate);
23896 if (PyErr_Occurred()) SWIG_fail;
23897 }
23898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23899 return resultobj;
23900 fail:
23901 return NULL;
23902 }
23903
23904
23905 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23906 PyObject *resultobj = 0;
23907 int arg1 ;
23908 int arg2 = (int) 0 ;
23909 int arg3 = (int) 0 ;
23910 int arg4 = (int) 0 ;
23911 wxDateTime *result = 0 ;
23912 int val1 ;
23913 int ecode1 = 0 ;
23914 int val2 ;
23915 int ecode2 = 0 ;
23916 int val3 ;
23917 int ecode3 = 0 ;
23918 int val4 ;
23919 int ecode4 = 0 ;
23920 PyObject * obj0 = 0 ;
23921 PyObject * obj1 = 0 ;
23922 PyObject * obj2 = 0 ;
23923 PyObject * obj3 = 0 ;
23924 char * kwnames[] = {
23925 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23926 };
23927
23928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23929 ecode1 = SWIG_AsVal_int(obj0, &val1);
23930 if (!SWIG_IsOK(ecode1)) {
23931 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23932 }
23933 arg1 = static_cast< int >(val1);
23934 if (obj1) {
23935 ecode2 = SWIG_AsVal_int(obj1, &val2);
23936 if (!SWIG_IsOK(ecode2)) {
23937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23938 }
23939 arg2 = static_cast< int >(val2);
23940 }
23941 if (obj2) {
23942 ecode3 = SWIG_AsVal_int(obj2, &val3);
23943 if (!SWIG_IsOK(ecode3)) {
23944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23945 }
23946 arg3 = static_cast< int >(val3);
23947 }
23948 if (obj3) {
23949 ecode4 = SWIG_AsVal_int(obj3, &val4);
23950 if (!SWIG_IsOK(ecode4)) {
23951 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23952 }
23953 arg4 = static_cast< int >(val4);
23954 }
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj = 0;
23970 int arg1 ;
23971 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23972 int arg3 = (int) wxDateTime::Inv_Year ;
23973 int arg4 = (int) 0 ;
23974 int arg5 = (int) 0 ;
23975 int arg6 = (int) 0 ;
23976 int arg7 = (int) 0 ;
23977 wxDateTime *result = 0 ;
23978 int val1 ;
23979 int ecode1 = 0 ;
23980 int val2 ;
23981 int ecode2 = 0 ;
23982 int val3 ;
23983 int ecode3 = 0 ;
23984 int val4 ;
23985 int ecode4 = 0 ;
23986 int val5 ;
23987 int ecode5 = 0 ;
23988 int val6 ;
23989 int ecode6 = 0 ;
23990 int val7 ;
23991 int ecode7 = 0 ;
23992 PyObject * obj0 = 0 ;
23993 PyObject * obj1 = 0 ;
23994 PyObject * obj2 = 0 ;
23995 PyObject * obj3 = 0 ;
23996 PyObject * obj4 = 0 ;
23997 PyObject * obj5 = 0 ;
23998 PyObject * obj6 = 0 ;
23999 char * kwnames[] = {
24000 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24001 };
24002
24003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24004 ecode1 = SWIG_AsVal_int(obj0, &val1);
24005 if (!SWIG_IsOK(ecode1)) {
24006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24007 }
24008 arg1 = static_cast< int >(val1);
24009 if (obj1) {
24010 ecode2 = SWIG_AsVal_int(obj1, &val2);
24011 if (!SWIG_IsOK(ecode2)) {
24012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24013 }
24014 arg2 = static_cast< wxDateTime::Month >(val2);
24015 }
24016 if (obj2) {
24017 ecode3 = SWIG_AsVal_int(obj2, &val3);
24018 if (!SWIG_IsOK(ecode3)) {
24019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24020 }
24021 arg3 = static_cast< int >(val3);
24022 }
24023 if (obj3) {
24024 ecode4 = SWIG_AsVal_int(obj3, &val4);
24025 if (!SWIG_IsOK(ecode4)) {
24026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24027 }
24028 arg4 = static_cast< int >(val4);
24029 }
24030 if (obj4) {
24031 ecode5 = SWIG_AsVal_int(obj4, &val5);
24032 if (!SWIG_IsOK(ecode5)) {
24033 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24034 }
24035 arg5 = static_cast< int >(val5);
24036 }
24037 if (obj5) {
24038 ecode6 = SWIG_AsVal_int(obj5, &val6);
24039 if (!SWIG_IsOK(ecode6)) {
24040 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24041 }
24042 arg6 = static_cast< int >(val6);
24043 }
24044 if (obj6) {
24045 ecode7 = SWIG_AsVal_int(obj6, &val7);
24046 if (!SWIG_IsOK(ecode7)) {
24047 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24048 }
24049 arg7 = static_cast< int >(val7);
24050 }
24051 {
24052 PyThreadState* __tstate = wxPyBeginAllowThreads();
24053 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24065 PyObject *resultobj = 0;
24066 wxDateTime *arg1 = 0 ;
24067 wxDateTime *result = 0 ;
24068 void *argp1 = 0 ;
24069 int res1 = 0 ;
24070 PyObject * obj0 = 0 ;
24071 char * kwnames[] = {
24072 (char *) "date", NULL
24073 };
24074
24075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24076 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24077 if (!SWIG_IsOK(res1)) {
24078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24079 }
24080 if (!argp1) {
24081 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24082 }
24083 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24084 {
24085 PyThreadState* __tstate = wxPyBeginAllowThreads();
24086 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24098 PyObject *resultobj = 0;
24099 wxDateTime *arg1 = (wxDateTime *) 0 ;
24100 void *argp1 = 0 ;
24101 int res1 = 0 ;
24102 PyObject *swig_obj[1] ;
24103
24104 if (!args) SWIG_fail;
24105 swig_obj[0] = args;
24106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24107 if (!SWIG_IsOK(res1)) {
24108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24109 }
24110 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24111 {
24112 PyThreadState* __tstate = wxPyBeginAllowThreads();
24113 delete arg1;
24114
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 resultobj = SWIG_Py_Void();
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24126 PyObject *resultobj = 0;
24127 wxDateTime *arg1 = (wxDateTime *) 0 ;
24128 wxDateTime *result = 0 ;
24129 void *argp1 = 0 ;
24130 int res1 = 0 ;
24131 PyObject *swig_obj[1] ;
24132
24133 if (!args) SWIG_fail;
24134 swig_obj[0] = args;
24135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24136 if (!SWIG_IsOK(res1)) {
24137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24138 }
24139 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24140 {
24141 PyThreadState* __tstate = wxPyBeginAllowThreads();
24142 {
24143 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24144 result = (wxDateTime *) &_result_ref;
24145 }
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24157 PyObject *resultobj = 0;
24158 wxDateTime *arg1 = (wxDateTime *) 0 ;
24159 time_t arg2 ;
24160 wxDateTime *result = 0 ;
24161 void *argp1 = 0 ;
24162 int res1 = 0 ;
24163 unsigned int val2 ;
24164 int ecode2 = 0 ;
24165 PyObject * obj0 = 0 ;
24166 PyObject * obj1 = 0 ;
24167 char * kwnames[] = {
24168 (char *) "self",(char *) "timet", NULL
24169 };
24170
24171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24173 if (!SWIG_IsOK(res1)) {
24174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24175 }
24176 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24177 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24178 if (!SWIG_IsOK(ecode2)) {
24179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24180 }
24181 arg2 = static_cast< time_t >(val2);
24182 {
24183 PyThreadState* __tstate = wxPyBeginAllowThreads();
24184 {
24185 wxDateTime &_result_ref = (arg1)->Set(arg2);
24186 result = (wxDateTime *) &_result_ref;
24187 }
24188 wxPyEndAllowThreads(__tstate);
24189 if (PyErr_Occurred()) SWIG_fail;
24190 }
24191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj = 0;
24200 wxDateTime *arg1 = (wxDateTime *) 0 ;
24201 double arg2 ;
24202 wxDateTime *result = 0 ;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 double val2 ;
24206 int ecode2 = 0 ;
24207 PyObject * obj0 = 0 ;
24208 PyObject * obj1 = 0 ;
24209 char * kwnames[] = {
24210 (char *) "self",(char *) "jdn", NULL
24211 };
24212
24213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24215 if (!SWIG_IsOK(res1)) {
24216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24217 }
24218 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24219 ecode2 = SWIG_AsVal_double(obj1, &val2);
24220 if (!SWIG_IsOK(ecode2)) {
24221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24222 }
24223 arg2 = static_cast< double >(val2);
24224 {
24225 PyThreadState* __tstate = wxPyBeginAllowThreads();
24226 {
24227 wxDateTime &_result_ref = (arg1)->Set(arg2);
24228 result = (wxDateTime *) &_result_ref;
24229 }
24230 wxPyEndAllowThreads(__tstate);
24231 if (PyErr_Occurred()) SWIG_fail;
24232 }
24233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24234 return resultobj;
24235 fail:
24236 return NULL;
24237 }
24238
24239
24240 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24241 PyObject *resultobj = 0;
24242 wxDateTime *arg1 = (wxDateTime *) 0 ;
24243 int arg2 ;
24244 int arg3 = (int) 0 ;
24245 int arg4 = (int) 0 ;
24246 int arg5 = (int) 0 ;
24247 wxDateTime *result = 0 ;
24248 void *argp1 = 0 ;
24249 int res1 = 0 ;
24250 int val2 ;
24251 int ecode2 = 0 ;
24252 int val3 ;
24253 int ecode3 = 0 ;
24254 int val4 ;
24255 int ecode4 = 0 ;
24256 int val5 ;
24257 int ecode5 = 0 ;
24258 PyObject * obj0 = 0 ;
24259 PyObject * obj1 = 0 ;
24260 PyObject * obj2 = 0 ;
24261 PyObject * obj3 = 0 ;
24262 PyObject * obj4 = 0 ;
24263 char * kwnames[] = {
24264 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24265 };
24266
24267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24269 if (!SWIG_IsOK(res1)) {
24270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24271 }
24272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24273 ecode2 = SWIG_AsVal_int(obj1, &val2);
24274 if (!SWIG_IsOK(ecode2)) {
24275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24276 }
24277 arg2 = static_cast< int >(val2);
24278 if (obj2) {
24279 ecode3 = SWIG_AsVal_int(obj2, &val3);
24280 if (!SWIG_IsOK(ecode3)) {
24281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24282 }
24283 arg3 = static_cast< int >(val3);
24284 }
24285 if (obj3) {
24286 ecode4 = SWIG_AsVal_int(obj3, &val4);
24287 if (!SWIG_IsOK(ecode4)) {
24288 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24289 }
24290 arg4 = static_cast< int >(val4);
24291 }
24292 if (obj4) {
24293 ecode5 = SWIG_AsVal_int(obj4, &val5);
24294 if (!SWIG_IsOK(ecode5)) {
24295 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24296 }
24297 arg5 = static_cast< int >(val5);
24298 }
24299 {
24300 PyThreadState* __tstate = wxPyBeginAllowThreads();
24301 {
24302 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24303 result = (wxDateTime *) &_result_ref;
24304 }
24305 wxPyEndAllowThreads(__tstate);
24306 if (PyErr_Occurred()) SWIG_fail;
24307 }
24308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24309 return resultobj;
24310 fail:
24311 return NULL;
24312 }
24313
24314
24315 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24316 PyObject *resultobj = 0;
24317 wxDateTime *arg1 = (wxDateTime *) 0 ;
24318 int arg2 ;
24319 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24320 int arg4 = (int) wxDateTime::Inv_Year ;
24321 int arg5 = (int) 0 ;
24322 int arg6 = (int) 0 ;
24323 int arg7 = (int) 0 ;
24324 int arg8 = (int) 0 ;
24325 wxDateTime *result = 0 ;
24326 void *argp1 = 0 ;
24327 int res1 = 0 ;
24328 int val2 ;
24329 int ecode2 = 0 ;
24330 int val3 ;
24331 int ecode3 = 0 ;
24332 int val4 ;
24333 int ecode4 = 0 ;
24334 int val5 ;
24335 int ecode5 = 0 ;
24336 int val6 ;
24337 int ecode6 = 0 ;
24338 int val7 ;
24339 int ecode7 = 0 ;
24340 int val8 ;
24341 int ecode8 = 0 ;
24342 PyObject * obj0 = 0 ;
24343 PyObject * obj1 = 0 ;
24344 PyObject * obj2 = 0 ;
24345 PyObject * obj3 = 0 ;
24346 PyObject * obj4 = 0 ;
24347 PyObject * obj5 = 0 ;
24348 PyObject * obj6 = 0 ;
24349 PyObject * obj7 = 0 ;
24350 char * kwnames[] = {
24351 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24352 };
24353
24354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24356 if (!SWIG_IsOK(res1)) {
24357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24358 }
24359 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24360 ecode2 = SWIG_AsVal_int(obj1, &val2);
24361 if (!SWIG_IsOK(ecode2)) {
24362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24363 }
24364 arg2 = static_cast< int >(val2);
24365 if (obj2) {
24366 ecode3 = SWIG_AsVal_int(obj2, &val3);
24367 if (!SWIG_IsOK(ecode3)) {
24368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24369 }
24370 arg3 = static_cast< wxDateTime::Month >(val3);
24371 }
24372 if (obj3) {
24373 ecode4 = SWIG_AsVal_int(obj3, &val4);
24374 if (!SWIG_IsOK(ecode4)) {
24375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24376 }
24377 arg4 = static_cast< int >(val4);
24378 }
24379 if (obj4) {
24380 ecode5 = SWIG_AsVal_int(obj4, &val5);
24381 if (!SWIG_IsOK(ecode5)) {
24382 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24383 }
24384 arg5 = static_cast< int >(val5);
24385 }
24386 if (obj5) {
24387 ecode6 = SWIG_AsVal_int(obj5, &val6);
24388 if (!SWIG_IsOK(ecode6)) {
24389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24390 }
24391 arg6 = static_cast< int >(val6);
24392 }
24393 if (obj6) {
24394 ecode7 = SWIG_AsVal_int(obj6, &val7);
24395 if (!SWIG_IsOK(ecode7)) {
24396 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24397 }
24398 arg7 = static_cast< int >(val7);
24399 }
24400 if (obj7) {
24401 ecode8 = SWIG_AsVal_int(obj7, &val8);
24402 if (!SWIG_IsOK(ecode8)) {
24403 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24404 }
24405 arg8 = static_cast< int >(val8);
24406 }
24407 {
24408 PyThreadState* __tstate = wxPyBeginAllowThreads();
24409 {
24410 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24411 result = (wxDateTime *) &_result_ref;
24412 }
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24424 PyObject *resultobj = 0;
24425 wxDateTime *arg1 = (wxDateTime *) 0 ;
24426 wxDateTime *result = 0 ;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 PyObject *swig_obj[1] ;
24430
24431 if (!args) SWIG_fail;
24432 swig_obj[0] = args;
24433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24434 if (!SWIG_IsOK(res1)) {
24435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24436 }
24437 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24438 {
24439 PyThreadState* __tstate = wxPyBeginAllowThreads();
24440 {
24441 wxDateTime &_result_ref = (arg1)->ResetTime();
24442 result = (wxDateTime *) &_result_ref;
24443 }
24444 wxPyEndAllowThreads(__tstate);
24445 if (PyErr_Occurred()) SWIG_fail;
24446 }
24447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24448 return resultobj;
24449 fail:
24450 return NULL;
24451 }
24452
24453
24454 SWIGINTERN PyObject *_wrap_DateTime_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24455 PyObject *resultobj = 0;
24456 wxDateTime *arg1 = (wxDateTime *) 0 ;
24457 wxDateTime result;
24458 void *argp1 = 0 ;
24459 int res1 = 0 ;
24460 PyObject *swig_obj[1] ;
24461
24462 if (!args) SWIG_fail;
24463 swig_obj[0] = args;
24464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24465 if (!SWIG_IsOK(res1)) {
24466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24467 }
24468 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24469 {
24470 PyThreadState* __tstate = wxPyBeginAllowThreads();
24471 result = ((wxDateTime const *)arg1)->GetDateOnly();
24472 wxPyEndAllowThreads(__tstate);
24473 if (PyErr_Occurred()) SWIG_fail;
24474 }
24475 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24483 PyObject *resultobj = 0;
24484 wxDateTime *arg1 = (wxDateTime *) 0 ;
24485 int arg2 ;
24486 wxDateTime *result = 0 ;
24487 void *argp1 = 0 ;
24488 int res1 = 0 ;
24489 int val2 ;
24490 int ecode2 = 0 ;
24491 PyObject * obj0 = 0 ;
24492 PyObject * obj1 = 0 ;
24493 char * kwnames[] = {
24494 (char *) "self",(char *) "year", NULL
24495 };
24496
24497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24499 if (!SWIG_IsOK(res1)) {
24500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24501 }
24502 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24503 ecode2 = SWIG_AsVal_int(obj1, &val2);
24504 if (!SWIG_IsOK(ecode2)) {
24505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24506 }
24507 arg2 = static_cast< int >(val2);
24508 {
24509 PyThreadState* __tstate = wxPyBeginAllowThreads();
24510 {
24511 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24512 result = (wxDateTime *) &_result_ref;
24513 }
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24525 PyObject *resultobj = 0;
24526 wxDateTime *arg1 = (wxDateTime *) 0 ;
24527 wxDateTime::Month arg2 ;
24528 wxDateTime *result = 0 ;
24529 void *argp1 = 0 ;
24530 int res1 = 0 ;
24531 int val2 ;
24532 int ecode2 = 0 ;
24533 PyObject * obj0 = 0 ;
24534 PyObject * obj1 = 0 ;
24535 char * kwnames[] = {
24536 (char *) "self",(char *) "month", NULL
24537 };
24538
24539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24541 if (!SWIG_IsOK(res1)) {
24542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24543 }
24544 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24545 ecode2 = SWIG_AsVal_int(obj1, &val2);
24546 if (!SWIG_IsOK(ecode2)) {
24547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24548 }
24549 arg2 = static_cast< wxDateTime::Month >(val2);
24550 {
24551 PyThreadState* __tstate = wxPyBeginAllowThreads();
24552 {
24553 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24554 result = (wxDateTime *) &_result_ref;
24555 }
24556 wxPyEndAllowThreads(__tstate);
24557 if (PyErr_Occurred()) SWIG_fail;
24558 }
24559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24560 return resultobj;
24561 fail:
24562 return NULL;
24563 }
24564
24565
24566 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24567 PyObject *resultobj = 0;
24568 wxDateTime *arg1 = (wxDateTime *) 0 ;
24569 int arg2 ;
24570 wxDateTime *result = 0 ;
24571 void *argp1 = 0 ;
24572 int res1 = 0 ;
24573 int val2 ;
24574 int ecode2 = 0 ;
24575 PyObject * obj0 = 0 ;
24576 PyObject * obj1 = 0 ;
24577 char * kwnames[] = {
24578 (char *) "self",(char *) "day", NULL
24579 };
24580
24581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24583 if (!SWIG_IsOK(res1)) {
24584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24585 }
24586 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24587 ecode2 = SWIG_AsVal_int(obj1, &val2);
24588 if (!SWIG_IsOK(ecode2)) {
24589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24590 }
24591 arg2 = static_cast< int >(val2);
24592 {
24593 PyThreadState* __tstate = wxPyBeginAllowThreads();
24594 {
24595 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24596 result = (wxDateTime *) &_result_ref;
24597 }
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24609 PyObject *resultobj = 0;
24610 wxDateTime *arg1 = (wxDateTime *) 0 ;
24611 int arg2 ;
24612 wxDateTime *result = 0 ;
24613 void *argp1 = 0 ;
24614 int res1 = 0 ;
24615 int val2 ;
24616 int ecode2 = 0 ;
24617 PyObject * obj0 = 0 ;
24618 PyObject * obj1 = 0 ;
24619 char * kwnames[] = {
24620 (char *) "self",(char *) "hour", NULL
24621 };
24622
24623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24625 if (!SWIG_IsOK(res1)) {
24626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24627 }
24628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24629 ecode2 = SWIG_AsVal_int(obj1, &val2);
24630 if (!SWIG_IsOK(ecode2)) {
24631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24632 }
24633 arg2 = static_cast< int >(val2);
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 {
24637 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24638 result = (wxDateTime *) &_result_ref;
24639 }
24640 wxPyEndAllowThreads(__tstate);
24641 if (PyErr_Occurred()) SWIG_fail;
24642 }
24643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24651 PyObject *resultobj = 0;
24652 wxDateTime *arg1 = (wxDateTime *) 0 ;
24653 int arg2 ;
24654 wxDateTime *result = 0 ;
24655 void *argp1 = 0 ;
24656 int res1 = 0 ;
24657 int val2 ;
24658 int ecode2 = 0 ;
24659 PyObject * obj0 = 0 ;
24660 PyObject * obj1 = 0 ;
24661 char * kwnames[] = {
24662 (char *) "self",(char *) "minute", NULL
24663 };
24664
24665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24667 if (!SWIG_IsOK(res1)) {
24668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24669 }
24670 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24671 ecode2 = SWIG_AsVal_int(obj1, &val2);
24672 if (!SWIG_IsOK(ecode2)) {
24673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24674 }
24675 arg2 = static_cast< int >(val2);
24676 {
24677 PyThreadState* __tstate = wxPyBeginAllowThreads();
24678 {
24679 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24680 result = (wxDateTime *) &_result_ref;
24681 }
24682 wxPyEndAllowThreads(__tstate);
24683 if (PyErr_Occurred()) SWIG_fail;
24684 }
24685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24686 return resultobj;
24687 fail:
24688 return NULL;
24689 }
24690
24691
24692 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24693 PyObject *resultobj = 0;
24694 wxDateTime *arg1 = (wxDateTime *) 0 ;
24695 int arg2 ;
24696 wxDateTime *result = 0 ;
24697 void *argp1 = 0 ;
24698 int res1 = 0 ;
24699 int val2 ;
24700 int ecode2 = 0 ;
24701 PyObject * obj0 = 0 ;
24702 PyObject * obj1 = 0 ;
24703 char * kwnames[] = {
24704 (char *) "self",(char *) "second", NULL
24705 };
24706
24707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24709 if (!SWIG_IsOK(res1)) {
24710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24711 }
24712 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24713 ecode2 = SWIG_AsVal_int(obj1, &val2);
24714 if (!SWIG_IsOK(ecode2)) {
24715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24716 }
24717 arg2 = static_cast< int >(val2);
24718 {
24719 PyThreadState* __tstate = wxPyBeginAllowThreads();
24720 {
24721 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24722 result = (wxDateTime *) &_result_ref;
24723 }
24724 wxPyEndAllowThreads(__tstate);
24725 if (PyErr_Occurred()) SWIG_fail;
24726 }
24727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24728 return resultobj;
24729 fail:
24730 return NULL;
24731 }
24732
24733
24734 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24735 PyObject *resultobj = 0;
24736 wxDateTime *arg1 = (wxDateTime *) 0 ;
24737 int arg2 ;
24738 wxDateTime *result = 0 ;
24739 void *argp1 = 0 ;
24740 int res1 = 0 ;
24741 int val2 ;
24742 int ecode2 = 0 ;
24743 PyObject * obj0 = 0 ;
24744 PyObject * obj1 = 0 ;
24745 char * kwnames[] = {
24746 (char *) "self",(char *) "millisecond", NULL
24747 };
24748
24749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24751 if (!SWIG_IsOK(res1)) {
24752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24753 }
24754 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24755 ecode2 = SWIG_AsVal_int(obj1, &val2);
24756 if (!SWIG_IsOK(ecode2)) {
24757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24758 }
24759 arg2 = static_cast< int >(val2);
24760 {
24761 PyThreadState* __tstate = wxPyBeginAllowThreads();
24762 {
24763 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24764 result = (wxDateTime *) &_result_ref;
24765 }
24766 wxPyEndAllowThreads(__tstate);
24767 if (PyErr_Occurred()) SWIG_fail;
24768 }
24769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24770 return resultobj;
24771 fail:
24772 return NULL;
24773 }
24774
24775
24776 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24777 PyObject *resultobj = 0;
24778 wxDateTime *arg1 = (wxDateTime *) 0 ;
24779 wxDateTime::WeekDay arg2 ;
24780 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24781 wxDateTime *result = 0 ;
24782 void *argp1 = 0 ;
24783 int res1 = 0 ;
24784 int val2 ;
24785 int ecode2 = 0 ;
24786 int val3 ;
24787 int ecode3 = 0 ;
24788 PyObject * obj0 = 0 ;
24789 PyObject * obj1 = 0 ;
24790 PyObject * obj2 = 0 ;
24791 char * kwnames[] = {
24792 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24793 };
24794
24795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24799 }
24800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24801 ecode2 = SWIG_AsVal_int(obj1, &val2);
24802 if (!SWIG_IsOK(ecode2)) {
24803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24804 }
24805 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24806 if (obj2) {
24807 ecode3 = SWIG_AsVal_int(obj2, &val3);
24808 if (!SWIG_IsOK(ecode3)) {
24809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24810 }
24811 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24812 }
24813 {
24814 PyThreadState* __tstate = wxPyBeginAllowThreads();
24815 {
24816 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24817 result = (wxDateTime *) &_result_ref;
24818 }
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24823 return resultobj;
24824 fail:
24825 return NULL;
24826 }
24827
24828
24829 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj = 0;
24831 wxDateTime *arg1 = (wxDateTime *) 0 ;
24832 wxDateTime::WeekDay arg2 ;
24833 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24834 wxDateTime result;
24835 void *argp1 = 0 ;
24836 int res1 = 0 ;
24837 int val2 ;
24838 int ecode2 = 0 ;
24839 int val3 ;
24840 int ecode3 = 0 ;
24841 PyObject * obj0 = 0 ;
24842 PyObject * obj1 = 0 ;
24843 PyObject * obj2 = 0 ;
24844 char * kwnames[] = {
24845 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24846 };
24847
24848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24850 if (!SWIG_IsOK(res1)) {
24851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24852 }
24853 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24854 ecode2 = SWIG_AsVal_int(obj1, &val2);
24855 if (!SWIG_IsOK(ecode2)) {
24856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24857 }
24858 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24859 if (obj2) {
24860 ecode3 = SWIG_AsVal_int(obj2, &val3);
24861 if (!SWIG_IsOK(ecode3)) {
24862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24863 }
24864 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24865 }
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24869 wxPyEndAllowThreads(__tstate);
24870 if (PyErr_Occurred()) SWIG_fail;
24871 }
24872 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24880 PyObject *resultobj = 0;
24881 wxDateTime *arg1 = (wxDateTime *) 0 ;
24882 wxDateTime::WeekDay arg2 ;
24883 wxDateTime *result = 0 ;
24884 void *argp1 = 0 ;
24885 int res1 = 0 ;
24886 int val2 ;
24887 int ecode2 = 0 ;
24888 PyObject * obj0 = 0 ;
24889 PyObject * obj1 = 0 ;
24890 char * kwnames[] = {
24891 (char *) "self",(char *) "weekday", NULL
24892 };
24893
24894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24896 if (!SWIG_IsOK(res1)) {
24897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24898 }
24899 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24900 ecode2 = SWIG_AsVal_int(obj1, &val2);
24901 if (!SWIG_IsOK(ecode2)) {
24902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24903 }
24904 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 {
24908 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24909 result = (wxDateTime *) &_result_ref;
24910 }
24911 wxPyEndAllowThreads(__tstate);
24912 if (PyErr_Occurred()) SWIG_fail;
24913 }
24914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24915 return resultobj;
24916 fail:
24917 return NULL;
24918 }
24919
24920
24921 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24922 PyObject *resultobj = 0;
24923 wxDateTime *arg1 = (wxDateTime *) 0 ;
24924 wxDateTime::WeekDay arg2 ;
24925 wxDateTime result;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 int val2 ;
24929 int ecode2 = 0 ;
24930 PyObject * obj0 = 0 ;
24931 PyObject * obj1 = 0 ;
24932 char * kwnames[] = {
24933 (char *) "self",(char *) "weekday", NULL
24934 };
24935
24936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24938 if (!SWIG_IsOK(res1)) {
24939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24940 }
24941 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24942 ecode2 = SWIG_AsVal_int(obj1, &val2);
24943 if (!SWIG_IsOK(ecode2)) {
24944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24945 }
24946 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (arg1)->GetNextWeekDay(arg2);
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24954 return resultobj;
24955 fail:
24956 return NULL;
24957 }
24958
24959
24960 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24961 PyObject *resultobj = 0;
24962 wxDateTime *arg1 = (wxDateTime *) 0 ;
24963 wxDateTime::WeekDay arg2 ;
24964 wxDateTime *result = 0 ;
24965 void *argp1 = 0 ;
24966 int res1 = 0 ;
24967 int val2 ;
24968 int ecode2 = 0 ;
24969 PyObject * obj0 = 0 ;
24970 PyObject * obj1 = 0 ;
24971 char * kwnames[] = {
24972 (char *) "self",(char *) "weekday", NULL
24973 };
24974
24975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24977 if (!SWIG_IsOK(res1)) {
24978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24979 }
24980 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24981 ecode2 = SWIG_AsVal_int(obj1, &val2);
24982 if (!SWIG_IsOK(ecode2)) {
24983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24984 }
24985 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24986 {
24987 PyThreadState* __tstate = wxPyBeginAllowThreads();
24988 {
24989 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24990 result = (wxDateTime *) &_result_ref;
24991 }
24992 wxPyEndAllowThreads(__tstate);
24993 if (PyErr_Occurred()) SWIG_fail;
24994 }
24995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25003 PyObject *resultobj = 0;
25004 wxDateTime *arg1 = (wxDateTime *) 0 ;
25005 wxDateTime::WeekDay arg2 ;
25006 wxDateTime result;
25007 void *argp1 = 0 ;
25008 int res1 = 0 ;
25009 int val2 ;
25010 int ecode2 = 0 ;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 char * kwnames[] = {
25014 (char *) "self",(char *) "weekday", NULL
25015 };
25016
25017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25019 if (!SWIG_IsOK(res1)) {
25020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25021 }
25022 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25023 ecode2 = SWIG_AsVal_int(obj1, &val2);
25024 if (!SWIG_IsOK(ecode2)) {
25025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25026 }
25027 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25028 {
25029 PyThreadState* __tstate = wxPyBeginAllowThreads();
25030 result = (arg1)->GetPrevWeekDay(arg2);
25031 wxPyEndAllowThreads(__tstate);
25032 if (PyErr_Occurred()) SWIG_fail;
25033 }
25034 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25035 return resultobj;
25036 fail:
25037 return NULL;
25038 }
25039
25040
25041 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25042 PyObject *resultobj = 0;
25043 wxDateTime *arg1 = (wxDateTime *) 0 ;
25044 wxDateTime::WeekDay arg2 ;
25045 int arg3 = (int) 1 ;
25046 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25047 int arg5 = (int) wxDateTime::Inv_Year ;
25048 bool result;
25049 void *argp1 = 0 ;
25050 int res1 = 0 ;
25051 int val2 ;
25052 int ecode2 = 0 ;
25053 int val3 ;
25054 int ecode3 = 0 ;
25055 int val4 ;
25056 int ecode4 = 0 ;
25057 int val5 ;
25058 int ecode5 = 0 ;
25059 PyObject * obj0 = 0 ;
25060 PyObject * obj1 = 0 ;
25061 PyObject * obj2 = 0 ;
25062 PyObject * obj3 = 0 ;
25063 PyObject * obj4 = 0 ;
25064 char * kwnames[] = {
25065 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25066 };
25067
25068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25070 if (!SWIG_IsOK(res1)) {
25071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25072 }
25073 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25074 ecode2 = SWIG_AsVal_int(obj1, &val2);
25075 if (!SWIG_IsOK(ecode2)) {
25076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25077 }
25078 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25079 if (obj2) {
25080 ecode3 = SWIG_AsVal_int(obj2, &val3);
25081 if (!SWIG_IsOK(ecode3)) {
25082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25083 }
25084 arg3 = static_cast< int >(val3);
25085 }
25086 if (obj3) {
25087 ecode4 = SWIG_AsVal_int(obj3, &val4);
25088 if (!SWIG_IsOK(ecode4)) {
25089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25090 }
25091 arg4 = static_cast< wxDateTime::Month >(val4);
25092 }
25093 if (obj4) {
25094 ecode5 = SWIG_AsVal_int(obj4, &val5);
25095 if (!SWIG_IsOK(ecode5)) {
25096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25097 }
25098 arg5 = static_cast< int >(val5);
25099 }
25100 {
25101 PyThreadState* __tstate = wxPyBeginAllowThreads();
25102 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25103 wxPyEndAllowThreads(__tstate);
25104 if (PyErr_Occurred()) SWIG_fail;
25105 }
25106 {
25107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25108 }
25109 return resultobj;
25110 fail:
25111 return NULL;
25112 }
25113
25114
25115 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25116 PyObject *resultobj = 0;
25117 wxDateTime *arg1 = (wxDateTime *) 0 ;
25118 wxDateTime::WeekDay arg2 ;
25119 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25120 int arg4 = (int) wxDateTime::Inv_Year ;
25121 bool result;
25122 void *argp1 = 0 ;
25123 int res1 = 0 ;
25124 int val2 ;
25125 int ecode2 = 0 ;
25126 int val3 ;
25127 int ecode3 = 0 ;
25128 int val4 ;
25129 int ecode4 = 0 ;
25130 PyObject * obj0 = 0 ;
25131 PyObject * obj1 = 0 ;
25132 PyObject * obj2 = 0 ;
25133 PyObject * obj3 = 0 ;
25134 char * kwnames[] = {
25135 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25136 };
25137
25138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25140 if (!SWIG_IsOK(res1)) {
25141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25142 }
25143 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25144 ecode2 = SWIG_AsVal_int(obj1, &val2);
25145 if (!SWIG_IsOK(ecode2)) {
25146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25147 }
25148 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25149 if (obj2) {
25150 ecode3 = SWIG_AsVal_int(obj2, &val3);
25151 if (!SWIG_IsOK(ecode3)) {
25152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25153 }
25154 arg3 = static_cast< wxDateTime::Month >(val3);
25155 }
25156 if (obj3) {
25157 ecode4 = SWIG_AsVal_int(obj3, &val4);
25158 if (!SWIG_IsOK(ecode4)) {
25159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25160 }
25161 arg4 = static_cast< int >(val4);
25162 }
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 {
25170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25171 }
25172 return resultobj;
25173 fail:
25174 return NULL;
25175 }
25176
25177
25178 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25179 PyObject *resultobj = 0;
25180 wxDateTime *arg1 = (wxDateTime *) 0 ;
25181 wxDateTime::WeekDay arg2 ;
25182 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25183 int arg4 = (int) wxDateTime::Inv_Year ;
25184 wxDateTime result;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 int val2 ;
25188 int ecode2 = 0 ;
25189 int val3 ;
25190 int ecode3 = 0 ;
25191 int val4 ;
25192 int ecode4 = 0 ;
25193 PyObject * obj0 = 0 ;
25194 PyObject * obj1 = 0 ;
25195 PyObject * obj2 = 0 ;
25196 PyObject * obj3 = 0 ;
25197 char * kwnames[] = {
25198 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25199 };
25200
25201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25203 if (!SWIG_IsOK(res1)) {
25204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25205 }
25206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25207 ecode2 = SWIG_AsVal_int(obj1, &val2);
25208 if (!SWIG_IsOK(ecode2)) {
25209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25210 }
25211 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25212 if (obj2) {
25213 ecode3 = SWIG_AsVal_int(obj2, &val3);
25214 if (!SWIG_IsOK(ecode3)) {
25215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25216 }
25217 arg3 = static_cast< wxDateTime::Month >(val3);
25218 }
25219 if (obj3) {
25220 ecode4 = SWIG_AsVal_int(obj3, &val4);
25221 if (!SWIG_IsOK(ecode4)) {
25222 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25223 }
25224 arg4 = static_cast< int >(val4);
25225 }
25226 {
25227 PyThreadState* __tstate = wxPyBeginAllowThreads();
25228 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj = 0;
25241 wxDateTime *arg1 = (wxDateTime *) 0 ;
25242 int arg2 ;
25243 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25244 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25245 bool result;
25246 void *argp1 = 0 ;
25247 int res1 = 0 ;
25248 int val2 ;
25249 int ecode2 = 0 ;
25250 int val3 ;
25251 int ecode3 = 0 ;
25252 int val4 ;
25253 int ecode4 = 0 ;
25254 PyObject * obj0 = 0 ;
25255 PyObject * obj1 = 0 ;
25256 PyObject * obj2 = 0 ;
25257 PyObject * obj3 = 0 ;
25258 char * kwnames[] = {
25259 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25260 };
25261
25262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25264 if (!SWIG_IsOK(res1)) {
25265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25266 }
25267 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25268 ecode2 = SWIG_AsVal_int(obj1, &val2);
25269 if (!SWIG_IsOK(ecode2)) {
25270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25271 }
25272 arg2 = static_cast< int >(val2);
25273 if (obj2) {
25274 ecode3 = SWIG_AsVal_int(obj2, &val3);
25275 if (!SWIG_IsOK(ecode3)) {
25276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25277 }
25278 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25279 }
25280 if (obj3) {
25281 ecode4 = SWIG_AsVal_int(obj3, &val4);
25282 if (!SWIG_IsOK(ecode4)) {
25283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25284 }
25285 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25286 }
25287 {
25288 PyThreadState* __tstate = wxPyBeginAllowThreads();
25289 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25290 wxPyEndAllowThreads(__tstate);
25291 if (PyErr_Occurred()) SWIG_fail;
25292 }
25293 {
25294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25295 }
25296 return resultobj;
25297 fail:
25298 return NULL;
25299 }
25300
25301
25302 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25303 PyObject *resultobj = 0;
25304 wxDateTime *arg1 = (wxDateTime *) 0 ;
25305 int arg2 ;
25306 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25307 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25308 wxDateTime result;
25309 void *argp1 = 0 ;
25310 int res1 = 0 ;
25311 int val2 ;
25312 int ecode2 = 0 ;
25313 int val3 ;
25314 int ecode3 = 0 ;
25315 int val4 ;
25316 int ecode4 = 0 ;
25317 PyObject * obj0 = 0 ;
25318 PyObject * obj1 = 0 ;
25319 PyObject * obj2 = 0 ;
25320 PyObject * obj3 = 0 ;
25321 char * kwnames[] = {
25322 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25323 };
25324
25325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25327 if (!SWIG_IsOK(res1)) {
25328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25329 }
25330 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25331 ecode2 = SWIG_AsVal_int(obj1, &val2);
25332 if (!SWIG_IsOK(ecode2)) {
25333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25334 }
25335 arg2 = static_cast< int >(val2);
25336 if (obj2) {
25337 ecode3 = SWIG_AsVal_int(obj2, &val3);
25338 if (!SWIG_IsOK(ecode3)) {
25339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25340 }
25341 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25342 }
25343 if (obj3) {
25344 ecode4 = SWIG_AsVal_int(obj3, &val4);
25345 if (!SWIG_IsOK(ecode4)) {
25346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25347 }
25348 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25349 }
25350 {
25351 PyThreadState* __tstate = wxPyBeginAllowThreads();
25352 result = (arg1)->GetWeek(arg2,arg3,arg4);
25353 wxPyEndAllowThreads(__tstate);
25354 if (PyErr_Occurred()) SWIG_fail;
25355 }
25356 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25357 return resultobj;
25358 fail:
25359 return NULL;
25360 }
25361
25362
25363 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj = 0;
25365 int arg1 ;
25366 int arg2 ;
25367 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25368 wxDateTime result;
25369 int val1 ;
25370 int ecode1 = 0 ;
25371 int val2 ;
25372 int ecode2 = 0 ;
25373 int val3 ;
25374 int ecode3 = 0 ;
25375 PyObject * obj0 = 0 ;
25376 PyObject * obj1 = 0 ;
25377 PyObject * obj2 = 0 ;
25378 char * kwnames[] = {
25379 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25380 };
25381
25382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25383 ecode1 = SWIG_AsVal_int(obj0, &val1);
25384 if (!SWIG_IsOK(ecode1)) {
25385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25386 }
25387 arg1 = static_cast< int >(val1);
25388 ecode2 = SWIG_AsVal_int(obj1, &val2);
25389 if (!SWIG_IsOK(ecode2)) {
25390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25391 }
25392 arg2 = static_cast< int >(val2);
25393 if (obj2) {
25394 ecode3 = SWIG_AsVal_int(obj2, &val3);
25395 if (!SWIG_IsOK(ecode3)) {
25396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25397 }
25398 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25399 }
25400 {
25401 PyThreadState* __tstate = wxPyBeginAllowThreads();
25402 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25403 wxPyEndAllowThreads(__tstate);
25404 if (PyErr_Occurred()) SWIG_fail;
25405 }
25406 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj = 0;
25415 wxDateTime *arg1 = (wxDateTime *) 0 ;
25416 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25417 int arg3 = (int) wxDateTime::Inv_Year ;
25418 wxDateTime *result = 0 ;
25419 void *argp1 = 0 ;
25420 int res1 = 0 ;
25421 int val2 ;
25422 int ecode2 = 0 ;
25423 int val3 ;
25424 int ecode3 = 0 ;
25425 PyObject * obj0 = 0 ;
25426 PyObject * obj1 = 0 ;
25427 PyObject * obj2 = 0 ;
25428 char * kwnames[] = {
25429 (char *) "self",(char *) "month",(char *) "year", NULL
25430 };
25431
25432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25434 if (!SWIG_IsOK(res1)) {
25435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25436 }
25437 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25438 if (obj1) {
25439 ecode2 = SWIG_AsVal_int(obj1, &val2);
25440 if (!SWIG_IsOK(ecode2)) {
25441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25442 }
25443 arg2 = static_cast< wxDateTime::Month >(val2);
25444 }
25445 if (obj2) {
25446 ecode3 = SWIG_AsVal_int(obj2, &val3);
25447 if (!SWIG_IsOK(ecode3)) {
25448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25449 }
25450 arg3 = static_cast< int >(val3);
25451 }
25452 {
25453 PyThreadState* __tstate = wxPyBeginAllowThreads();
25454 {
25455 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25456 result = (wxDateTime *) &_result_ref;
25457 }
25458 wxPyEndAllowThreads(__tstate);
25459 if (PyErr_Occurred()) SWIG_fail;
25460 }
25461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25462 return resultobj;
25463 fail:
25464 return NULL;
25465 }
25466
25467
25468 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25469 PyObject *resultobj = 0;
25470 wxDateTime *arg1 = (wxDateTime *) 0 ;
25471 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25472 int arg3 = (int) wxDateTime::Inv_Year ;
25473 wxDateTime result;
25474 void *argp1 = 0 ;
25475 int res1 = 0 ;
25476 int val2 ;
25477 int ecode2 = 0 ;
25478 int val3 ;
25479 int ecode3 = 0 ;
25480 PyObject * obj0 = 0 ;
25481 PyObject * obj1 = 0 ;
25482 PyObject * obj2 = 0 ;
25483 char * kwnames[] = {
25484 (char *) "self",(char *) "month",(char *) "year", NULL
25485 };
25486
25487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25489 if (!SWIG_IsOK(res1)) {
25490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25491 }
25492 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25493 if (obj1) {
25494 ecode2 = SWIG_AsVal_int(obj1, &val2);
25495 if (!SWIG_IsOK(ecode2)) {
25496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25497 }
25498 arg2 = static_cast< wxDateTime::Month >(val2);
25499 }
25500 if (obj2) {
25501 ecode3 = SWIG_AsVal_int(obj2, &val3);
25502 if (!SWIG_IsOK(ecode3)) {
25503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25504 }
25505 arg3 = static_cast< int >(val3);
25506 }
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 result = (arg1)->GetLastMonthDay(arg2,arg3);
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25521 PyObject *resultobj = 0;
25522 wxDateTime *arg1 = (wxDateTime *) 0 ;
25523 int arg2 ;
25524 wxDateTime *result = 0 ;
25525 void *argp1 = 0 ;
25526 int res1 = 0 ;
25527 int val2 ;
25528 int ecode2 = 0 ;
25529 PyObject * obj0 = 0 ;
25530 PyObject * obj1 = 0 ;
25531 char * kwnames[] = {
25532 (char *) "self",(char *) "yday", NULL
25533 };
25534
25535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25537 if (!SWIG_IsOK(res1)) {
25538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25539 }
25540 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25541 ecode2 = SWIG_AsVal_int(obj1, &val2);
25542 if (!SWIG_IsOK(ecode2)) {
25543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25544 }
25545 arg2 = static_cast< int >(val2);
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 {
25549 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25550 result = (wxDateTime *) &_result_ref;
25551 }
25552 wxPyEndAllowThreads(__tstate);
25553 if (PyErr_Occurred()) SWIG_fail;
25554 }
25555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25556 return resultobj;
25557 fail:
25558 return NULL;
25559 }
25560
25561
25562 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25563 PyObject *resultobj = 0;
25564 wxDateTime *arg1 = (wxDateTime *) 0 ;
25565 int arg2 ;
25566 wxDateTime result;
25567 void *argp1 = 0 ;
25568 int res1 = 0 ;
25569 int val2 ;
25570 int ecode2 = 0 ;
25571 PyObject * obj0 = 0 ;
25572 PyObject * obj1 = 0 ;
25573 char * kwnames[] = {
25574 (char *) "self",(char *) "yday", NULL
25575 };
25576
25577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25579 if (!SWIG_IsOK(res1)) {
25580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25581 }
25582 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25583 ecode2 = SWIG_AsVal_int(obj1, &val2);
25584 if (!SWIG_IsOK(ecode2)) {
25585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25586 }
25587 arg2 = static_cast< int >(val2);
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 result = (arg1)->GetYearDay(arg2);
25591 wxPyEndAllowThreads(__tstate);
25592 if (PyErr_Occurred()) SWIG_fail;
25593 }
25594 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25595 return resultobj;
25596 fail:
25597 return NULL;
25598 }
25599
25600
25601 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25602 PyObject *resultobj = 0;
25603 wxDateTime *arg1 = (wxDateTime *) 0 ;
25604 double result;
25605 void *argp1 = 0 ;
25606 int res1 = 0 ;
25607 PyObject *swig_obj[1] ;
25608
25609 if (!args) SWIG_fail;
25610 swig_obj[0] = args;
25611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25612 if (!SWIG_IsOK(res1)) {
25613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25614 }
25615 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 result = (double)(arg1)->GetJulianDayNumber();
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 resultobj = SWIG_From_double(static_cast< double >(result));
25623 return resultobj;
25624 fail:
25625 return NULL;
25626 }
25627
25628
25629 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25630 PyObject *resultobj = 0;
25631 wxDateTime *arg1 = (wxDateTime *) 0 ;
25632 double result;
25633 void *argp1 = 0 ;
25634 int res1 = 0 ;
25635 PyObject *swig_obj[1] ;
25636
25637 if (!args) SWIG_fail;
25638 swig_obj[0] = args;
25639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25640 if (!SWIG_IsOK(res1)) {
25641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25642 }
25643 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = (double)(arg1)->GetJDN();
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 resultobj = SWIG_From_double(static_cast< double >(result));
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25658 PyObject *resultobj = 0;
25659 wxDateTime *arg1 = (wxDateTime *) 0 ;
25660 double result;
25661 void *argp1 = 0 ;
25662 int res1 = 0 ;
25663 PyObject *swig_obj[1] ;
25664
25665 if (!args) SWIG_fail;
25666 swig_obj[0] = args;
25667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25668 if (!SWIG_IsOK(res1)) {
25669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25670 }
25671 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 resultobj = SWIG_From_double(static_cast< double >(result));
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 PyObject *resultobj = 0;
25687 wxDateTime *arg1 = (wxDateTime *) 0 ;
25688 double result;
25689 void *argp1 = 0 ;
25690 int res1 = 0 ;
25691 PyObject *swig_obj[1] ;
25692
25693 if (!args) SWIG_fail;
25694 swig_obj[0] = args;
25695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25696 if (!SWIG_IsOK(res1)) {
25697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25698 }
25699 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 result = (double)(arg1)->GetMJD();
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_From_double(static_cast< double >(result));
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25714 PyObject *resultobj = 0;
25715 wxDateTime *arg1 = (wxDateTime *) 0 ;
25716 double result;
25717 void *argp1 = 0 ;
25718 int res1 = 0 ;
25719 PyObject *swig_obj[1] ;
25720
25721 if (!args) SWIG_fail;
25722 swig_obj[0] = args;
25723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25724 if (!SWIG_IsOK(res1)) {
25725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25726 }
25727 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 result = (double)(arg1)->GetRataDie();
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 resultobj = SWIG_From_double(static_cast< double >(result));
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25742 PyObject *resultobj = 0;
25743 wxDateTime *arg1 = (wxDateTime *) 0 ;
25744 wxDateTime::TimeZone *arg2 = 0 ;
25745 bool arg3 = (bool) false ;
25746 wxDateTime result;
25747 void *argp1 = 0 ;
25748 int res1 = 0 ;
25749 bool temp2 = false ;
25750 bool val3 ;
25751 int ecode3 = 0 ;
25752 PyObject * obj0 = 0 ;
25753 PyObject * obj1 = 0 ;
25754 PyObject * obj2 = 0 ;
25755 char * kwnames[] = {
25756 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25757 };
25758
25759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25761 if (!SWIG_IsOK(res1)) {
25762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25763 }
25764 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25765 {
25766 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25767 temp2 = true;
25768 }
25769 if (obj2) {
25770 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25771 if (!SWIG_IsOK(ecode3)) {
25772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25773 }
25774 arg3 = static_cast< bool >(val3);
25775 }
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25779 wxPyEndAllowThreads(__tstate);
25780 if (PyErr_Occurred()) SWIG_fail;
25781 }
25782 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25783 {
25784 if (temp2) delete arg2;
25785 }
25786 return resultobj;
25787 fail:
25788 {
25789 if (temp2) delete arg2;
25790 }
25791 return NULL;
25792 }
25793
25794
25795 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25796 PyObject *resultobj = 0;
25797 wxDateTime *arg1 = (wxDateTime *) 0 ;
25798 wxDateTime::TimeZone *arg2 = 0 ;
25799 bool arg3 = (bool) false ;
25800 wxDateTime *result = 0 ;
25801 void *argp1 = 0 ;
25802 int res1 = 0 ;
25803 bool temp2 = false ;
25804 bool val3 ;
25805 int ecode3 = 0 ;
25806 PyObject * obj0 = 0 ;
25807 PyObject * obj1 = 0 ;
25808 PyObject * obj2 = 0 ;
25809 char * kwnames[] = {
25810 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25811 };
25812
25813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25815 if (!SWIG_IsOK(res1)) {
25816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25817 }
25818 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25819 {
25820 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25821 temp2 = true;
25822 }
25823 if (obj2) {
25824 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25825 if (!SWIG_IsOK(ecode3)) {
25826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25827 }
25828 arg3 = static_cast< bool >(val3);
25829 }
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 {
25833 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25834 result = (wxDateTime *) &_result_ref;
25835 }
25836 wxPyEndAllowThreads(__tstate);
25837 if (PyErr_Occurred()) SWIG_fail;
25838 }
25839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25840 {
25841 if (temp2) delete arg2;
25842 }
25843 return resultobj;
25844 fail:
25845 {
25846 if (temp2) delete arg2;
25847 }
25848 return NULL;
25849 }
25850
25851
25852 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25853 PyObject *resultobj = 0;
25854 wxDateTime *arg1 = (wxDateTime *) 0 ;
25855 wxDateTime::TimeZone *arg2 = 0 ;
25856 bool arg3 = (bool) false ;
25857 wxDateTime result;
25858 void *argp1 = 0 ;
25859 int res1 = 0 ;
25860 bool temp2 = false ;
25861 bool val3 ;
25862 int ecode3 = 0 ;
25863 PyObject * obj0 = 0 ;
25864 PyObject * obj1 = 0 ;
25865 PyObject * obj2 = 0 ;
25866 char * kwnames[] = {
25867 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25868 };
25869
25870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25872 if (!SWIG_IsOK(res1)) {
25873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25874 }
25875 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25876 {
25877 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25878 temp2 = true;
25879 }
25880 if (obj2) {
25881 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25882 if (!SWIG_IsOK(ecode3)) {
25883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25884 }
25885 arg3 = static_cast< bool >(val3);
25886 }
25887 {
25888 PyThreadState* __tstate = wxPyBeginAllowThreads();
25889 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25890 wxPyEndAllowThreads(__tstate);
25891 if (PyErr_Occurred()) SWIG_fail;
25892 }
25893 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25894 {
25895 if (temp2) delete arg2;
25896 }
25897 return resultobj;
25898 fail:
25899 {
25900 if (temp2) delete arg2;
25901 }
25902 return NULL;
25903 }
25904
25905
25906 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25907 PyObject *resultobj = 0;
25908 wxDateTime *arg1 = (wxDateTime *) 0 ;
25909 wxDateTime::TimeZone *arg2 = 0 ;
25910 bool arg3 = (bool) false ;
25911 wxDateTime *result = 0 ;
25912 void *argp1 = 0 ;
25913 int res1 = 0 ;
25914 bool temp2 = false ;
25915 bool val3 ;
25916 int ecode3 = 0 ;
25917 PyObject * obj0 = 0 ;
25918 PyObject * obj1 = 0 ;
25919 PyObject * obj2 = 0 ;
25920 char * kwnames[] = {
25921 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25922 };
25923
25924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25926 if (!SWIG_IsOK(res1)) {
25927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25928 }
25929 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25930 {
25931 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25932 temp2 = true;
25933 }
25934 if (obj2) {
25935 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25936 if (!SWIG_IsOK(ecode3)) {
25937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25938 }
25939 arg3 = static_cast< bool >(val3);
25940 }
25941 {
25942 PyThreadState* __tstate = wxPyBeginAllowThreads();
25943 {
25944 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25945 result = (wxDateTime *) &_result_ref;
25946 }
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25951 {
25952 if (temp2) delete arg2;
25953 }
25954 return resultobj;
25955 fail:
25956 {
25957 if (temp2) delete arg2;
25958 }
25959 return NULL;
25960 }
25961
25962
25963 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25964 PyObject *resultobj = 0;
25965 wxDateTime *arg1 = (wxDateTime *) 0 ;
25966 bool arg2 = (bool) false ;
25967 wxDateTime result;
25968 void *argp1 = 0 ;
25969 int res1 = 0 ;
25970 bool val2 ;
25971 int ecode2 = 0 ;
25972 PyObject * obj0 = 0 ;
25973 PyObject * obj1 = 0 ;
25974 char * kwnames[] = {
25975 (char *) "self",(char *) "noDST", NULL
25976 };
25977
25978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25980 if (!SWIG_IsOK(res1)) {
25981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25982 }
25983 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25984 if (obj1) {
25985 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25986 if (!SWIG_IsOK(ecode2)) {
25987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25988 }
25989 arg2 = static_cast< bool >(val2);
25990 }
25991 {
25992 PyThreadState* __tstate = wxPyBeginAllowThreads();
25993 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25994 wxPyEndAllowThreads(__tstate);
25995 if (PyErr_Occurred()) SWIG_fail;
25996 }
25997 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25998 return resultobj;
25999 fail:
26000 return NULL;
26001 }
26002
26003
26004 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26005 PyObject *resultobj = 0;
26006 wxDateTime *arg1 = (wxDateTime *) 0 ;
26007 bool arg2 = (bool) false ;
26008 wxDateTime *result = 0 ;
26009 void *argp1 = 0 ;
26010 int res1 = 0 ;
26011 bool val2 ;
26012 int ecode2 = 0 ;
26013 PyObject * obj0 = 0 ;
26014 PyObject * obj1 = 0 ;
26015 char * kwnames[] = {
26016 (char *) "self",(char *) "noDST", NULL
26017 };
26018
26019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26021 if (!SWIG_IsOK(res1)) {
26022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26023 }
26024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26025 if (obj1) {
26026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26027 if (!SWIG_IsOK(ecode2)) {
26028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26029 }
26030 arg2 = static_cast< bool >(val2);
26031 }
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 {
26035 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26036 result = (wxDateTime *) &_result_ref;
26037 }
26038 wxPyEndAllowThreads(__tstate);
26039 if (PyErr_Occurred()) SWIG_fail;
26040 }
26041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26042 return resultobj;
26043 fail:
26044 return NULL;
26045 }
26046
26047
26048 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26049 PyObject *resultobj = 0;
26050 wxDateTime *arg1 = (wxDateTime *) 0 ;
26051 bool arg2 = (bool) false ;
26052 wxDateTime result;
26053 void *argp1 = 0 ;
26054 int res1 = 0 ;
26055 bool val2 ;
26056 int ecode2 = 0 ;
26057 PyObject * obj0 = 0 ;
26058 PyObject * obj1 = 0 ;
26059 char * kwnames[] = {
26060 (char *) "self",(char *) "noDST", NULL
26061 };
26062
26063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26065 if (!SWIG_IsOK(res1)) {
26066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26067 }
26068 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26069 if (obj1) {
26070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26071 if (!SWIG_IsOK(ecode2)) {
26072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26073 }
26074 arg2 = static_cast< bool >(val2);
26075 }
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26090 PyObject *resultobj = 0;
26091 wxDateTime *arg1 = (wxDateTime *) 0 ;
26092 bool arg2 = (bool) false ;
26093 wxDateTime *result = 0 ;
26094 void *argp1 = 0 ;
26095 int res1 = 0 ;
26096 bool val2 ;
26097 int ecode2 = 0 ;
26098 PyObject * obj0 = 0 ;
26099 PyObject * obj1 = 0 ;
26100 char * kwnames[] = {
26101 (char *) "self",(char *) "noDST", NULL
26102 };
26103
26104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26106 if (!SWIG_IsOK(res1)) {
26107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26108 }
26109 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26110 if (obj1) {
26111 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26112 if (!SWIG_IsOK(ecode2)) {
26113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26114 }
26115 arg2 = static_cast< bool >(val2);
26116 }
26117 {
26118 PyThreadState* __tstate = wxPyBeginAllowThreads();
26119 {
26120 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26121 result = (wxDateTime *) &_result_ref;
26122 }
26123 wxPyEndAllowThreads(__tstate);
26124 if (PyErr_Occurred()) SWIG_fail;
26125 }
26126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26127 return resultobj;
26128 fail:
26129 return NULL;
26130 }
26131
26132
26133 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26134 PyObject *resultobj = 0;
26135 wxDateTime *arg1 = (wxDateTime *) 0 ;
26136 bool arg2 = (bool) false ;
26137 wxDateTime result;
26138 void *argp1 = 0 ;
26139 int res1 = 0 ;
26140 bool val2 ;
26141 int ecode2 = 0 ;
26142 PyObject * obj0 = 0 ;
26143 PyObject * obj1 = 0 ;
26144 char * kwnames[] = {
26145 (char *) "self",(char *) "noDST", NULL
26146 };
26147
26148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26150 if (!SWIG_IsOK(res1)) {
26151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26152 }
26153 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26154 if (obj1) {
26155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26156 if (!SWIG_IsOK(ecode2)) {
26157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26158 }
26159 arg2 = static_cast< bool >(val2);
26160 }
26161 {
26162 PyThreadState* __tstate = wxPyBeginAllowThreads();
26163 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26175 PyObject *resultobj = 0;
26176 wxDateTime *arg1 = (wxDateTime *) 0 ;
26177 bool arg2 = (bool) false ;
26178 wxDateTime *result = 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 bool val2 ;
26182 int ecode2 = 0 ;
26183 PyObject * obj0 = 0 ;
26184 PyObject * obj1 = 0 ;
26185 char * kwnames[] = {
26186 (char *) "self",(char *) "noDST", NULL
26187 };
26188
26189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26191 if (!SWIG_IsOK(res1)) {
26192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26193 }
26194 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26195 if (obj1) {
26196 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26197 if (!SWIG_IsOK(ecode2)) {
26198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26199 }
26200 arg2 = static_cast< bool >(val2);
26201 }
26202 {
26203 PyThreadState* __tstate = wxPyBeginAllowThreads();
26204 {
26205 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26206 result = (wxDateTime *) &_result_ref;
26207 }
26208 wxPyEndAllowThreads(__tstate);
26209 if (PyErr_Occurred()) SWIG_fail;
26210 }
26211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26212 return resultobj;
26213 fail:
26214 return NULL;
26215 }
26216
26217
26218 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26219 PyObject *resultobj = 0;
26220 wxDateTime *arg1 = (wxDateTime *) 0 ;
26221 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26222 int result;
26223 void *argp1 = 0 ;
26224 int res1 = 0 ;
26225 int val2 ;
26226 int ecode2 = 0 ;
26227 PyObject * obj0 = 0 ;
26228 PyObject * obj1 = 0 ;
26229 char * kwnames[] = {
26230 (char *) "self",(char *) "country", NULL
26231 };
26232
26233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26235 if (!SWIG_IsOK(res1)) {
26236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26237 }
26238 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26239 if (obj1) {
26240 ecode2 = SWIG_AsVal_int(obj1, &val2);
26241 if (!SWIG_IsOK(ecode2)) {
26242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26243 }
26244 arg2 = static_cast< wxDateTime::Country >(val2);
26245 }
26246 {
26247 PyThreadState* __tstate = wxPyBeginAllowThreads();
26248 result = (int)(arg1)->IsDST(arg2);
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 resultobj = SWIG_From_int(static_cast< int >(result));
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26260 PyObject *resultobj = 0;
26261 wxDateTime *arg1 = (wxDateTime *) 0 ;
26262 bool result;
26263 void *argp1 = 0 ;
26264 int res1 = 0 ;
26265 PyObject *swig_obj[1] ;
26266
26267 if (!args) SWIG_fail;
26268 swig_obj[0] = args;
26269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26270 if (!SWIG_IsOK(res1)) {
26271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26272 }
26273 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26274 {
26275 PyThreadState* __tstate = wxPyBeginAllowThreads();
26276 result = (bool)((wxDateTime const *)arg1)->IsValid();
26277 wxPyEndAllowThreads(__tstate);
26278 if (PyErr_Occurred()) SWIG_fail;
26279 }
26280 {
26281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26282 }
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *resultobj = 0;
26291 wxDateTime *arg1 = (wxDateTime *) 0 ;
26292 time_t result;
26293 void *argp1 = 0 ;
26294 int res1 = 0 ;
26295 PyObject *swig_obj[1] ;
26296
26297 if (!args) SWIG_fail;
26298 swig_obj[0] = args;
26299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26300 if (!SWIG_IsOK(res1)) {
26301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26302 }
26303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26311 return resultobj;
26312 fail:
26313 return NULL;
26314 }
26315
26316
26317 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26318 PyObject *resultobj = 0;
26319 wxDateTime *arg1 = (wxDateTime *) 0 ;
26320 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26321 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26322 int result;
26323 void *argp1 = 0 ;
26324 int res1 = 0 ;
26325 bool temp2 = false ;
26326 PyObject * obj0 = 0 ;
26327 PyObject * obj1 = 0 ;
26328 char * kwnames[] = {
26329 (char *) "self",(char *) "tz", NULL
26330 };
26331
26332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26334 if (!SWIG_IsOK(res1)) {
26335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26336 }
26337 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26338 if (obj1) {
26339 {
26340 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26341 temp2 = true;
26342 }
26343 }
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 resultobj = SWIG_From_int(static_cast< int >(result));
26351 {
26352 if (temp2) delete arg2;
26353 }
26354 return resultobj;
26355 fail:
26356 {
26357 if (temp2) delete arg2;
26358 }
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26364 PyObject *resultobj = 0;
26365 wxDateTime *arg1 = (wxDateTime *) 0 ;
26366 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26367 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26368 wxDateTime::Month result;
26369 void *argp1 = 0 ;
26370 int res1 = 0 ;
26371 bool temp2 = false ;
26372 PyObject * obj0 = 0 ;
26373 PyObject * obj1 = 0 ;
26374 char * kwnames[] = {
26375 (char *) "self",(char *) "tz", NULL
26376 };
26377
26378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26380 if (!SWIG_IsOK(res1)) {
26381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26382 }
26383 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26384 if (obj1) {
26385 {
26386 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26387 temp2 = true;
26388 }
26389 }
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26393 wxPyEndAllowThreads(__tstate);
26394 if (PyErr_Occurred()) SWIG_fail;
26395 }
26396 resultobj = SWIG_From_int(static_cast< int >(result));
26397 {
26398 if (temp2) delete arg2;
26399 }
26400 return resultobj;
26401 fail:
26402 {
26403 if (temp2) delete arg2;
26404 }
26405 return NULL;
26406 }
26407
26408
26409 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26410 PyObject *resultobj = 0;
26411 wxDateTime *arg1 = (wxDateTime *) 0 ;
26412 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26413 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26414 int result;
26415 void *argp1 = 0 ;
26416 int res1 = 0 ;
26417 bool temp2 = false ;
26418 PyObject * obj0 = 0 ;
26419 PyObject * obj1 = 0 ;
26420 char * kwnames[] = {
26421 (char *) "self",(char *) "tz", NULL
26422 };
26423
26424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26426 if (!SWIG_IsOK(res1)) {
26427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26428 }
26429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26430 if (obj1) {
26431 {
26432 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26433 temp2 = true;
26434 }
26435 }
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26439 wxPyEndAllowThreads(__tstate);
26440 if (PyErr_Occurred()) SWIG_fail;
26441 }
26442 resultobj = SWIG_From_int(static_cast< int >(result));
26443 {
26444 if (temp2) delete arg2;
26445 }
26446 return resultobj;
26447 fail:
26448 {
26449 if (temp2) delete arg2;
26450 }
26451 return NULL;
26452 }
26453
26454
26455 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj = 0;
26457 wxDateTime *arg1 = (wxDateTime *) 0 ;
26458 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26459 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26460 wxDateTime::WeekDay result;
26461 void *argp1 = 0 ;
26462 int res1 = 0 ;
26463 bool temp2 = false ;
26464 PyObject * obj0 = 0 ;
26465 PyObject * obj1 = 0 ;
26466 char * kwnames[] = {
26467 (char *) "self",(char *) "tz", NULL
26468 };
26469
26470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26472 if (!SWIG_IsOK(res1)) {
26473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26474 }
26475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26476 if (obj1) {
26477 {
26478 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26479 temp2 = true;
26480 }
26481 }
26482 {
26483 PyThreadState* __tstate = wxPyBeginAllowThreads();
26484 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26485 wxPyEndAllowThreads(__tstate);
26486 if (PyErr_Occurred()) SWIG_fail;
26487 }
26488 resultobj = SWIG_From_int(static_cast< int >(result));
26489 {
26490 if (temp2) delete arg2;
26491 }
26492 return resultobj;
26493 fail:
26494 {
26495 if (temp2) delete arg2;
26496 }
26497 return NULL;
26498 }
26499
26500
26501 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26502 PyObject *resultobj = 0;
26503 wxDateTime *arg1 = (wxDateTime *) 0 ;
26504 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26505 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26506 int result;
26507 void *argp1 = 0 ;
26508 int res1 = 0 ;
26509 bool temp2 = false ;
26510 PyObject * obj0 = 0 ;
26511 PyObject * obj1 = 0 ;
26512 char * kwnames[] = {
26513 (char *) "self",(char *) "tz", NULL
26514 };
26515
26516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26518 if (!SWIG_IsOK(res1)) {
26519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26520 }
26521 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26522 if (obj1) {
26523 {
26524 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26525 temp2 = true;
26526 }
26527 }
26528 {
26529 PyThreadState* __tstate = wxPyBeginAllowThreads();
26530 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26531 wxPyEndAllowThreads(__tstate);
26532 if (PyErr_Occurred()) SWIG_fail;
26533 }
26534 resultobj = SWIG_From_int(static_cast< int >(result));
26535 {
26536 if (temp2) delete arg2;
26537 }
26538 return resultobj;
26539 fail:
26540 {
26541 if (temp2) delete arg2;
26542 }
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj = 0;
26549 wxDateTime *arg1 = (wxDateTime *) 0 ;
26550 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26551 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26552 int result;
26553 void *argp1 = 0 ;
26554 int res1 = 0 ;
26555 bool temp2 = false ;
26556 PyObject * obj0 = 0 ;
26557 PyObject * obj1 = 0 ;
26558 char * kwnames[] = {
26559 (char *) "self",(char *) "tz", NULL
26560 };
26561
26562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26564 if (!SWIG_IsOK(res1)) {
26565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26566 }
26567 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26568 if (obj1) {
26569 {
26570 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26571 temp2 = true;
26572 }
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 resultobj = SWIG_From_int(static_cast< int >(result));
26581 {
26582 if (temp2) delete arg2;
26583 }
26584 return resultobj;
26585 fail:
26586 {
26587 if (temp2) delete arg2;
26588 }
26589 return NULL;
26590 }
26591
26592
26593 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26594 PyObject *resultobj = 0;
26595 wxDateTime *arg1 = (wxDateTime *) 0 ;
26596 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26597 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26598 int result;
26599 void *argp1 = 0 ;
26600 int res1 = 0 ;
26601 bool temp2 = false ;
26602 PyObject * obj0 = 0 ;
26603 PyObject * obj1 = 0 ;
26604 char * kwnames[] = {
26605 (char *) "self",(char *) "tz", NULL
26606 };
26607
26608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26610 if (!SWIG_IsOK(res1)) {
26611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26612 }
26613 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26614 if (obj1) {
26615 {
26616 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26617 temp2 = true;
26618 }
26619 }
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26623 wxPyEndAllowThreads(__tstate);
26624 if (PyErr_Occurred()) SWIG_fail;
26625 }
26626 resultobj = SWIG_From_int(static_cast< int >(result));
26627 {
26628 if (temp2) delete arg2;
26629 }
26630 return resultobj;
26631 fail:
26632 {
26633 if (temp2) delete arg2;
26634 }
26635 return NULL;
26636 }
26637
26638
26639 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj = 0;
26641 wxDateTime *arg1 = (wxDateTime *) 0 ;
26642 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26643 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26644 int result;
26645 void *argp1 = 0 ;
26646 int res1 = 0 ;
26647 bool temp2 = false ;
26648 PyObject * obj0 = 0 ;
26649 PyObject * obj1 = 0 ;
26650 char * kwnames[] = {
26651 (char *) "self",(char *) "tz", NULL
26652 };
26653
26654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26656 if (!SWIG_IsOK(res1)) {
26657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26658 }
26659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26660 if (obj1) {
26661 {
26662 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26663 temp2 = true;
26664 }
26665 }
26666 {
26667 PyThreadState* __tstate = wxPyBeginAllowThreads();
26668 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26669 wxPyEndAllowThreads(__tstate);
26670 if (PyErr_Occurred()) SWIG_fail;
26671 }
26672 resultobj = SWIG_From_int(static_cast< int >(result));
26673 {
26674 if (temp2) delete arg2;
26675 }
26676 return resultobj;
26677 fail:
26678 {
26679 if (temp2) delete arg2;
26680 }
26681 return NULL;
26682 }
26683
26684
26685 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26686 PyObject *resultobj = 0;
26687 wxDateTime *arg1 = (wxDateTime *) 0 ;
26688 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26689 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26690 int result;
26691 void *argp1 = 0 ;
26692 int res1 = 0 ;
26693 bool temp2 = false ;
26694 PyObject * obj0 = 0 ;
26695 PyObject * obj1 = 0 ;
26696 char * kwnames[] = {
26697 (char *) "self",(char *) "tz", NULL
26698 };
26699
26700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26702 if (!SWIG_IsOK(res1)) {
26703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26704 }
26705 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26706 if (obj1) {
26707 {
26708 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26709 temp2 = true;
26710 }
26711 }
26712 {
26713 PyThreadState* __tstate = wxPyBeginAllowThreads();
26714 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26715 wxPyEndAllowThreads(__tstate);
26716 if (PyErr_Occurred()) SWIG_fail;
26717 }
26718 resultobj = SWIG_From_int(static_cast< int >(result));
26719 {
26720 if (temp2) delete arg2;
26721 }
26722 return resultobj;
26723 fail:
26724 {
26725 if (temp2) delete arg2;
26726 }
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj = 0;
26733 wxDateTime *arg1 = (wxDateTime *) 0 ;
26734 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26735 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26736 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26737 int result;
26738 void *argp1 = 0 ;
26739 int res1 = 0 ;
26740 int val2 ;
26741 int ecode2 = 0 ;
26742 bool temp3 = false ;
26743 PyObject * obj0 = 0 ;
26744 PyObject * obj1 = 0 ;
26745 PyObject * obj2 = 0 ;
26746 char * kwnames[] = {
26747 (char *) "self",(char *) "flags",(char *) "tz", NULL
26748 };
26749
26750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26752 if (!SWIG_IsOK(res1)) {
26753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26754 }
26755 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26756 if (obj1) {
26757 ecode2 = SWIG_AsVal_int(obj1, &val2);
26758 if (!SWIG_IsOK(ecode2)) {
26759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26760 }
26761 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26762 }
26763 if (obj2) {
26764 {
26765 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26766 temp3 = true;
26767 }
26768 }
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26772 wxPyEndAllowThreads(__tstate);
26773 if (PyErr_Occurred()) SWIG_fail;
26774 }
26775 resultobj = SWIG_From_int(static_cast< int >(result));
26776 {
26777 if (temp3) delete arg3;
26778 }
26779 return resultobj;
26780 fail:
26781 {
26782 if (temp3) delete arg3;
26783 }
26784 return NULL;
26785 }
26786
26787
26788 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26789 PyObject *resultobj = 0;
26790 wxDateTime *arg1 = (wxDateTime *) 0 ;
26791 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26792 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26793 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26794 int result;
26795 void *argp1 = 0 ;
26796 int res1 = 0 ;
26797 int val2 ;
26798 int ecode2 = 0 ;
26799 bool temp3 = false ;
26800 PyObject * obj0 = 0 ;
26801 PyObject * obj1 = 0 ;
26802 PyObject * obj2 = 0 ;
26803 char * kwnames[] = {
26804 (char *) "self",(char *) "flags",(char *) "tz", NULL
26805 };
26806
26807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26809 if (!SWIG_IsOK(res1)) {
26810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26811 }
26812 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26813 if (obj1) {
26814 ecode2 = SWIG_AsVal_int(obj1, &val2);
26815 if (!SWIG_IsOK(ecode2)) {
26816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26817 }
26818 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26819 }
26820 if (obj2) {
26821 {
26822 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26823 temp3 = true;
26824 }
26825 }
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26829 wxPyEndAllowThreads(__tstate);
26830 if (PyErr_Occurred()) SWIG_fail;
26831 }
26832 resultobj = SWIG_From_int(static_cast< int >(result));
26833 {
26834 if (temp3) delete arg3;
26835 }
26836 return resultobj;
26837 fail:
26838 {
26839 if (temp3) delete arg3;
26840 }
26841 return NULL;
26842 }
26843
26844
26845 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26846 PyObject *resultobj = 0;
26847 wxDateTime *arg1 = (wxDateTime *) 0 ;
26848 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26849 bool result;
26850 void *argp1 = 0 ;
26851 int res1 = 0 ;
26852 int val2 ;
26853 int ecode2 = 0 ;
26854 PyObject * obj0 = 0 ;
26855 PyObject * obj1 = 0 ;
26856 char * kwnames[] = {
26857 (char *) "self",(char *) "country", NULL
26858 };
26859
26860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26862 if (!SWIG_IsOK(res1)) {
26863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26864 }
26865 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26866 if (obj1) {
26867 ecode2 = SWIG_AsVal_int(obj1, &val2);
26868 if (!SWIG_IsOK(ecode2)) {
26869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26870 }
26871 arg2 = static_cast< wxDateTime::Country >(val2);
26872 }
26873 {
26874 PyThreadState* __tstate = wxPyBeginAllowThreads();
26875 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26876 wxPyEndAllowThreads(__tstate);
26877 if (PyErr_Occurred()) SWIG_fail;
26878 }
26879 {
26880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26881 }
26882 return resultobj;
26883 fail:
26884 return NULL;
26885 }
26886
26887
26888 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26889 PyObject *resultobj = 0;
26890 wxDateTime *arg1 = (wxDateTime *) 0 ;
26891 wxDateTime *arg2 = 0 ;
26892 bool result;
26893 void *argp1 = 0 ;
26894 int res1 = 0 ;
26895 void *argp2 = 0 ;
26896 int res2 = 0 ;
26897 PyObject * obj0 = 0 ;
26898 PyObject * obj1 = 0 ;
26899 char * kwnames[] = {
26900 (char *) "self",(char *) "datetime", NULL
26901 };
26902
26903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26905 if (!SWIG_IsOK(res1)) {
26906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26907 }
26908 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26910 if (!SWIG_IsOK(res2)) {
26911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26912 }
26913 if (!argp2) {
26914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26915 }
26916 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26917 {
26918 PyThreadState* __tstate = wxPyBeginAllowThreads();
26919 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26920 wxPyEndAllowThreads(__tstate);
26921 if (PyErr_Occurred()) SWIG_fail;
26922 }
26923 {
26924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26925 }
26926 return resultobj;
26927 fail:
26928 return NULL;
26929 }
26930
26931
26932 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26933 PyObject *resultobj = 0;
26934 wxDateTime *arg1 = (wxDateTime *) 0 ;
26935 wxDateTime *arg2 = 0 ;
26936 bool result;
26937 void *argp1 = 0 ;
26938 int res1 = 0 ;
26939 void *argp2 = 0 ;
26940 int res2 = 0 ;
26941 PyObject * obj0 = 0 ;
26942 PyObject * obj1 = 0 ;
26943 char * kwnames[] = {
26944 (char *) "self",(char *) "datetime", NULL
26945 };
26946
26947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26949 if (!SWIG_IsOK(res1)) {
26950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26951 }
26952 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26954 if (!SWIG_IsOK(res2)) {
26955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26956 }
26957 if (!argp2) {
26958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26959 }
26960 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26961 {
26962 PyThreadState* __tstate = wxPyBeginAllowThreads();
26963 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 {
26968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26969 }
26970 return resultobj;
26971 fail:
26972 return NULL;
26973 }
26974
26975
26976 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj = 0;
26978 wxDateTime *arg1 = (wxDateTime *) 0 ;
26979 wxDateTime *arg2 = 0 ;
26980 bool result;
26981 void *argp1 = 0 ;
26982 int res1 = 0 ;
26983 void *argp2 = 0 ;
26984 int res2 = 0 ;
26985 PyObject * obj0 = 0 ;
26986 PyObject * obj1 = 0 ;
26987 char * kwnames[] = {
26988 (char *) "self",(char *) "datetime", NULL
26989 };
26990
26991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26993 if (!SWIG_IsOK(res1)) {
26994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26995 }
26996 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26997 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26998 if (!SWIG_IsOK(res2)) {
26999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27000 }
27001 if (!argp2) {
27002 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27003 }
27004 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
27008 wxPyEndAllowThreads(__tstate);
27009 if (PyErr_Occurred()) SWIG_fail;
27010 }
27011 {
27012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27013 }
27014 return resultobj;
27015 fail:
27016 return NULL;
27017 }
27018
27019
27020 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27021 PyObject *resultobj = 0;
27022 wxDateTime *arg1 = (wxDateTime *) 0 ;
27023 wxDateTime *arg2 = 0 ;
27024 wxDateTime *arg3 = 0 ;
27025 bool result;
27026 void *argp1 = 0 ;
27027 int res1 = 0 ;
27028 void *argp2 = 0 ;
27029 int res2 = 0 ;
27030 void *argp3 = 0 ;
27031 int res3 = 0 ;
27032 PyObject * obj0 = 0 ;
27033 PyObject * obj1 = 0 ;
27034 PyObject * obj2 = 0 ;
27035 char * kwnames[] = {
27036 (char *) "self",(char *) "t1",(char *) "t2", NULL
27037 };
27038
27039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27041 if (!SWIG_IsOK(res1)) {
27042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27043 }
27044 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27045 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27046 if (!SWIG_IsOK(res2)) {
27047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27048 }
27049 if (!argp2) {
27050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27051 }
27052 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27053 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27054 if (!SWIG_IsOK(res3)) {
27055 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27056 }
27057 if (!argp3) {
27058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27059 }
27060 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 {
27068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27069 }
27070 return resultobj;
27071 fail:
27072 return NULL;
27073 }
27074
27075
27076 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27077 PyObject *resultobj = 0;
27078 wxDateTime *arg1 = (wxDateTime *) 0 ;
27079 wxDateTime *arg2 = 0 ;
27080 wxDateTime *arg3 = 0 ;
27081 bool result;
27082 void *argp1 = 0 ;
27083 int res1 = 0 ;
27084 void *argp2 = 0 ;
27085 int res2 = 0 ;
27086 void *argp3 = 0 ;
27087 int res3 = 0 ;
27088 PyObject * obj0 = 0 ;
27089 PyObject * obj1 = 0 ;
27090 PyObject * obj2 = 0 ;
27091 char * kwnames[] = {
27092 (char *) "self",(char *) "t1",(char *) "t2", NULL
27093 };
27094
27095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27097 if (!SWIG_IsOK(res1)) {
27098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27099 }
27100 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27102 if (!SWIG_IsOK(res2)) {
27103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27104 }
27105 if (!argp2) {
27106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27107 }
27108 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27109 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27110 if (!SWIG_IsOK(res3)) {
27111 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27112 }
27113 if (!argp3) {
27114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27115 }
27116 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27117 {
27118 PyThreadState* __tstate = wxPyBeginAllowThreads();
27119 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27120 wxPyEndAllowThreads(__tstate);
27121 if (PyErr_Occurred()) SWIG_fail;
27122 }
27123 {
27124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27125 }
27126 return resultobj;
27127 fail:
27128 return NULL;
27129 }
27130
27131
27132 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj = 0;
27134 wxDateTime *arg1 = (wxDateTime *) 0 ;
27135 wxDateTime *arg2 = 0 ;
27136 bool result;
27137 void *argp1 = 0 ;
27138 int res1 = 0 ;
27139 void *argp2 = 0 ;
27140 int res2 = 0 ;
27141 PyObject * obj0 = 0 ;
27142 PyObject * obj1 = 0 ;
27143 char * kwnames[] = {
27144 (char *) "self",(char *) "dt", NULL
27145 };
27146
27147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27149 if (!SWIG_IsOK(res1)) {
27150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27151 }
27152 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27154 if (!SWIG_IsOK(res2)) {
27155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27156 }
27157 if (!argp2) {
27158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27159 }
27160 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27161 {
27162 PyThreadState* __tstate = wxPyBeginAllowThreads();
27163 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 {
27168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27169 }
27170 return resultobj;
27171 fail:
27172 return NULL;
27173 }
27174
27175
27176 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj = 0;
27178 wxDateTime *arg1 = (wxDateTime *) 0 ;
27179 wxDateTime *arg2 = 0 ;
27180 bool result;
27181 void *argp1 = 0 ;
27182 int res1 = 0 ;
27183 void *argp2 = 0 ;
27184 int res2 = 0 ;
27185 PyObject * obj0 = 0 ;
27186 PyObject * obj1 = 0 ;
27187 char * kwnames[] = {
27188 (char *) "self",(char *) "dt", NULL
27189 };
27190
27191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27193 if (!SWIG_IsOK(res1)) {
27194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27195 }
27196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27197 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27198 if (!SWIG_IsOK(res2)) {
27199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27200 }
27201 if (!argp2) {
27202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27203 }
27204 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27205 {
27206 PyThreadState* __tstate = wxPyBeginAllowThreads();
27207 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 {
27212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27213 }
27214 return resultobj;
27215 fail:
27216 return NULL;
27217 }
27218
27219
27220 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27221 PyObject *resultobj = 0;
27222 wxDateTime *arg1 = (wxDateTime *) 0 ;
27223 wxDateTime *arg2 = 0 ;
27224 wxTimeSpan *arg3 = 0 ;
27225 bool result;
27226 void *argp1 = 0 ;
27227 int res1 = 0 ;
27228 void *argp2 = 0 ;
27229 int res2 = 0 ;
27230 void *argp3 = 0 ;
27231 int res3 = 0 ;
27232 PyObject * obj0 = 0 ;
27233 PyObject * obj1 = 0 ;
27234 PyObject * obj2 = 0 ;
27235 char * kwnames[] = {
27236 (char *) "self",(char *) "dt",(char *) "ts", NULL
27237 };
27238
27239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27241 if (!SWIG_IsOK(res1)) {
27242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27243 }
27244 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27246 if (!SWIG_IsOK(res2)) {
27247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27248 }
27249 if (!argp2) {
27250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27251 }
27252 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27253 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27254 if (!SWIG_IsOK(res3)) {
27255 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27256 }
27257 if (!argp3) {
27258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27259 }
27260 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27261 {
27262 PyThreadState* __tstate = wxPyBeginAllowThreads();
27263 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27264 wxPyEndAllowThreads(__tstate);
27265 if (PyErr_Occurred()) SWIG_fail;
27266 }
27267 {
27268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27269 }
27270 return resultobj;
27271 fail:
27272 return NULL;
27273 }
27274
27275
27276 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27277 PyObject *resultobj = 0;
27278 wxDateTime *arg1 = (wxDateTime *) 0 ;
27279 wxTimeSpan *arg2 = 0 ;
27280 wxDateTime *result = 0 ;
27281 void *argp1 = 0 ;
27282 int res1 = 0 ;
27283 void *argp2 = 0 ;
27284 int res2 = 0 ;
27285 PyObject * obj0 = 0 ;
27286 PyObject * obj1 = 0 ;
27287 char * kwnames[] = {
27288 (char *) "self",(char *) "diff", NULL
27289 };
27290
27291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27293 if (!SWIG_IsOK(res1)) {
27294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27295 }
27296 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27297 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27298 if (!SWIG_IsOK(res2)) {
27299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27300 }
27301 if (!argp2) {
27302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27303 }
27304 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 {
27308 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27309 result = (wxDateTime *) &_result_ref;
27310 }
27311 wxPyEndAllowThreads(__tstate);
27312 if (PyErr_Occurred()) SWIG_fail;
27313 }
27314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27322 PyObject *resultobj = 0;
27323 wxDateTime *arg1 = (wxDateTime *) 0 ;
27324 wxDateSpan *arg2 = 0 ;
27325 wxDateTime *result = 0 ;
27326 void *argp1 = 0 ;
27327 int res1 = 0 ;
27328 void *argp2 = 0 ;
27329 int res2 = 0 ;
27330 PyObject * obj0 = 0 ;
27331 PyObject * obj1 = 0 ;
27332 char * kwnames[] = {
27333 (char *) "self",(char *) "diff", NULL
27334 };
27335
27336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27338 if (!SWIG_IsOK(res1)) {
27339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27340 }
27341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27342 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27343 if (!SWIG_IsOK(res2)) {
27344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27345 }
27346 if (!argp2) {
27347 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27348 }
27349 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27350 {
27351 PyThreadState* __tstate = wxPyBeginAllowThreads();
27352 {
27353 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27354 result = (wxDateTime *) &_result_ref;
27355 }
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27360 return resultobj;
27361 fail:
27362 return NULL;
27363 }
27364
27365
27366 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27367 PyObject *resultobj = 0;
27368 wxDateTime *arg1 = (wxDateTime *) 0 ;
27369 wxTimeSpan *arg2 = 0 ;
27370 wxDateTime *result = 0 ;
27371 void *argp1 = 0 ;
27372 int res1 = 0 ;
27373 void *argp2 = 0 ;
27374 int res2 = 0 ;
27375 PyObject * obj0 = 0 ;
27376 PyObject * obj1 = 0 ;
27377 char * kwnames[] = {
27378 (char *) "self",(char *) "diff", NULL
27379 };
27380
27381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27383 if (!SWIG_IsOK(res1)) {
27384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27385 }
27386 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27387 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27388 if (!SWIG_IsOK(res2)) {
27389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27390 }
27391 if (!argp2) {
27392 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27393 }
27394 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27395 {
27396 PyThreadState* __tstate = wxPyBeginAllowThreads();
27397 {
27398 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27399 result = (wxDateTime *) &_result_ref;
27400 }
27401 wxPyEndAllowThreads(__tstate);
27402 if (PyErr_Occurred()) SWIG_fail;
27403 }
27404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27405 return resultobj;
27406 fail:
27407 return NULL;
27408 }
27409
27410
27411 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27412 PyObject *resultobj = 0;
27413 wxDateTime *arg1 = (wxDateTime *) 0 ;
27414 wxDateSpan *arg2 = 0 ;
27415 wxDateTime *result = 0 ;
27416 void *argp1 = 0 ;
27417 int res1 = 0 ;
27418 void *argp2 = 0 ;
27419 int res2 = 0 ;
27420 PyObject * obj0 = 0 ;
27421 PyObject * obj1 = 0 ;
27422 char * kwnames[] = {
27423 (char *) "self",(char *) "diff", NULL
27424 };
27425
27426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27428 if (!SWIG_IsOK(res1)) {
27429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27430 }
27431 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27432 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27433 if (!SWIG_IsOK(res2)) {
27434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27435 }
27436 if (!argp2) {
27437 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27438 }
27439 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27440 {
27441 PyThreadState* __tstate = wxPyBeginAllowThreads();
27442 {
27443 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27444 result = (wxDateTime *) &_result_ref;
27445 }
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27450 return resultobj;
27451 fail:
27452 return NULL;
27453 }
27454
27455
27456 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27457 PyObject *resultobj = 0;
27458 wxDateTime *arg1 = (wxDateTime *) 0 ;
27459 wxDateTime *arg2 = 0 ;
27460 wxTimeSpan result;
27461 void *argp1 = 0 ;
27462 int res1 = 0 ;
27463 void *argp2 = 0 ;
27464 int res2 = 0 ;
27465 PyObject * obj0 = 0 ;
27466 PyObject * obj1 = 0 ;
27467 char * kwnames[] = {
27468 (char *) "self",(char *) "dt", NULL
27469 };
27470
27471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27473 if (!SWIG_IsOK(res1)) {
27474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27475 }
27476 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27477 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27478 if (!SWIG_IsOK(res2)) {
27479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27480 }
27481 if (!argp2) {
27482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27483 }
27484 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27499 PyObject *resultobj = 0;
27500 wxDateTime *arg1 = (wxDateTime *) 0 ;
27501 wxTimeSpan *arg2 = 0 ;
27502 wxDateTime *result = 0 ;
27503 void *argp1 = 0 ;
27504 int res1 = 0 ;
27505 void *argp2 = 0 ;
27506 int res2 = 0 ;
27507
27508 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27510 if (!SWIG_IsOK(res1)) {
27511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27512 }
27513 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27514 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27515 if (!SWIG_IsOK(res2)) {
27516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27517 }
27518 if (!argp2) {
27519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27520 }
27521 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 {
27525 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27526 result = (wxDateTime *) &_result_ref;
27527 }
27528 wxPyEndAllowThreads(__tstate);
27529 if (PyErr_Occurred()) SWIG_fail;
27530 }
27531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27532 return resultobj;
27533 fail:
27534 return NULL;
27535 }
27536
27537
27538 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27539 PyObject *resultobj = 0;
27540 wxDateTime *arg1 = (wxDateTime *) 0 ;
27541 wxDateSpan *arg2 = 0 ;
27542 wxDateTime *result = 0 ;
27543 void *argp1 = 0 ;
27544 int res1 = 0 ;
27545 void *argp2 = 0 ;
27546 int res2 = 0 ;
27547
27548 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27550 if (!SWIG_IsOK(res1)) {
27551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27552 }
27553 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27554 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27555 if (!SWIG_IsOK(res2)) {
27556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27557 }
27558 if (!argp2) {
27559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27560 }
27561 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 {
27565 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27566 result = (wxDateTime *) &_result_ref;
27567 }
27568 wxPyEndAllowThreads(__tstate);
27569 if (PyErr_Occurred()) SWIG_fail;
27570 }
27571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27572 return resultobj;
27573 fail:
27574 return NULL;
27575 }
27576
27577
27578 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27579 int argc;
27580 PyObject *argv[3];
27581
27582 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27583 --argc;
27584 if (argc == 2) {
27585 int _v = 0;
27586 {
27587 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27588 _v = SWIG_CheckState(res);
27589 }
27590 if (!_v) goto check_1;
27591 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27592 }
27593 check_1:
27594
27595 if (argc == 2) {
27596 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27597 }
27598
27599 fail:
27600 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27601 return NULL;
27602 }
27603
27604
27605 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27606 PyObject *resultobj = 0;
27607 wxDateTime *arg1 = (wxDateTime *) 0 ;
27608 wxTimeSpan *arg2 = 0 ;
27609 wxDateTime *result = 0 ;
27610 void *argp1 = 0 ;
27611 int res1 = 0 ;
27612 void *argp2 = 0 ;
27613 int res2 = 0 ;
27614
27615 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27617 if (!SWIG_IsOK(res1)) {
27618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27619 }
27620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27621 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27622 if (!SWIG_IsOK(res2)) {
27623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27624 }
27625 if (!argp2) {
27626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27627 }
27628 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 {
27632 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27633 result = (wxDateTime *) &_result_ref;
27634 }
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27639 return resultobj;
27640 fail:
27641 return NULL;
27642 }
27643
27644
27645 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27646 PyObject *resultobj = 0;
27647 wxDateTime *arg1 = (wxDateTime *) 0 ;
27648 wxDateSpan *arg2 = 0 ;
27649 wxDateTime *result = 0 ;
27650 void *argp1 = 0 ;
27651 int res1 = 0 ;
27652 void *argp2 = 0 ;
27653 int res2 = 0 ;
27654
27655 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27657 if (!SWIG_IsOK(res1)) {
27658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27659 }
27660 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27661 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27662 if (!SWIG_IsOK(res2)) {
27663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27664 }
27665 if (!argp2) {
27666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27667 }
27668 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 {
27672 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27673 result = (wxDateTime *) &_result_ref;
27674 }
27675 wxPyEndAllowThreads(__tstate);
27676 if (PyErr_Occurred()) SWIG_fail;
27677 }
27678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27686 int argc;
27687 PyObject *argv[3];
27688
27689 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27690 --argc;
27691 if (argc == 2) {
27692 int _v = 0;
27693 {
27694 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27695 _v = SWIG_CheckState(res);
27696 }
27697 if (!_v) goto check_1;
27698 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27699 }
27700 check_1:
27701
27702 if (argc == 2) {
27703 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27704 }
27705
27706 fail:
27707 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27708 return NULL;
27709 }
27710
27711
27712 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27713 PyObject *resultobj = 0;
27714 wxDateTime *arg1 = (wxDateTime *) 0 ;
27715 wxTimeSpan *arg2 = 0 ;
27716 wxDateTime result;
27717 void *argp1 = 0 ;
27718 int res1 = 0 ;
27719 void *argp2 = 0 ;
27720 int res2 = 0 ;
27721
27722 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27724 if (!SWIG_IsOK(res1)) {
27725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27726 }
27727 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27728 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27729 if (!SWIG_IsOK(res2)) {
27730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27731 }
27732 if (!argp2) {
27733 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27734 }
27735 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27736 {
27737 PyThreadState* __tstate = wxPyBeginAllowThreads();
27738 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27739 wxPyEndAllowThreads(__tstate);
27740 if (PyErr_Occurred()) SWIG_fail;
27741 }
27742 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27743 return resultobj;
27744 fail:
27745 return NULL;
27746 }
27747
27748
27749 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27750 PyObject *resultobj = 0;
27751 wxDateTime *arg1 = (wxDateTime *) 0 ;
27752 wxDateSpan *arg2 = 0 ;
27753 wxDateTime result;
27754 void *argp1 = 0 ;
27755 int res1 = 0 ;
27756 void *argp2 = 0 ;
27757 int res2 = 0 ;
27758
27759 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27761 if (!SWIG_IsOK(res1)) {
27762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27763 }
27764 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27765 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27766 if (!SWIG_IsOK(res2)) {
27767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27768 }
27769 if (!argp2) {
27770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27771 }
27772 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27773 {
27774 PyThreadState* __tstate = wxPyBeginAllowThreads();
27775 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27787 int argc;
27788 PyObject *argv[3];
27789
27790 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27791 --argc;
27792 if (argc == 2) {
27793 int _v = 0;
27794 {
27795 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27796 _v = SWIG_CheckState(res);
27797 }
27798 if (!_v) goto check_1;
27799 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27800 }
27801 check_1:
27802
27803 if (argc == 2) {
27804 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27805 }
27806
27807 fail:
27808 Py_INCREF(Py_NotImplemented);
27809 return Py_NotImplemented;
27810 }
27811
27812
27813 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27814 PyObject *resultobj = 0;
27815 wxDateTime *arg1 = (wxDateTime *) 0 ;
27816 wxDateTime *arg2 = 0 ;
27817 wxTimeSpan result;
27818 void *argp1 = 0 ;
27819 int res1 = 0 ;
27820 void *argp2 = 0 ;
27821 int res2 = 0 ;
27822
27823 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27825 if (!SWIG_IsOK(res1)) {
27826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27827 }
27828 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27829 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27830 if (!SWIG_IsOK(res2)) {
27831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27832 }
27833 if (!argp2) {
27834 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27835 }
27836 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27837 {
27838 PyThreadState* __tstate = wxPyBeginAllowThreads();
27839 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27840 wxPyEndAllowThreads(__tstate);
27841 if (PyErr_Occurred()) SWIG_fail;
27842 }
27843 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27844 return resultobj;
27845 fail:
27846 return NULL;
27847 }
27848
27849
27850 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27851 PyObject *resultobj = 0;
27852 wxDateTime *arg1 = (wxDateTime *) 0 ;
27853 wxTimeSpan *arg2 = 0 ;
27854 wxDateTime result;
27855 void *argp1 = 0 ;
27856 int res1 = 0 ;
27857 void *argp2 = 0 ;
27858 int res2 = 0 ;
27859
27860 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27862 if (!SWIG_IsOK(res1)) {
27863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27864 }
27865 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27866 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27867 if (!SWIG_IsOK(res2)) {
27868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27869 }
27870 if (!argp2) {
27871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27872 }
27873 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27874 {
27875 PyThreadState* __tstate = wxPyBeginAllowThreads();
27876 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27888 PyObject *resultobj = 0;
27889 wxDateTime *arg1 = (wxDateTime *) 0 ;
27890 wxDateSpan *arg2 = 0 ;
27891 wxDateTime result;
27892 void *argp1 = 0 ;
27893 int res1 = 0 ;
27894 void *argp2 = 0 ;
27895 int res2 = 0 ;
27896
27897 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27899 if (!SWIG_IsOK(res1)) {
27900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27901 }
27902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27903 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27904 if (!SWIG_IsOK(res2)) {
27905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27906 }
27907 if (!argp2) {
27908 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27909 }
27910 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27911 {
27912 PyThreadState* __tstate = wxPyBeginAllowThreads();
27913 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27914 wxPyEndAllowThreads(__tstate);
27915 if (PyErr_Occurred()) SWIG_fail;
27916 }
27917 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27918 return resultobj;
27919 fail:
27920 return NULL;
27921 }
27922
27923
27924 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27925 int argc;
27926 PyObject *argv[3];
27927
27928 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27929 --argc;
27930 if (argc == 2) {
27931 int _v = 0;
27932 {
27933 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27934 _v = SWIG_CheckState(res);
27935 }
27936 if (!_v) goto check_1;
27937 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27938 }
27939 check_1:
27940
27941 if (argc == 2) {
27942 int _v = 0;
27943 {
27944 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27945 _v = SWIG_CheckState(res);
27946 }
27947 if (!_v) goto check_2;
27948 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27949 }
27950 check_2:
27951
27952 if (argc == 2) {
27953 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27954 }
27955
27956 fail:
27957 Py_INCREF(Py_NotImplemented);
27958 return Py_NotImplemented;
27959 }
27960
27961
27962 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27963 PyObject *resultobj = 0;
27964 wxDateTime *arg1 = (wxDateTime *) 0 ;
27965 wxDateTime *arg2 = (wxDateTime *) 0 ;
27966 bool result;
27967 void *argp1 = 0 ;
27968 int res1 = 0 ;
27969 void *argp2 = 0 ;
27970 int res2 = 0 ;
27971 PyObject * obj0 = 0 ;
27972 PyObject * obj1 = 0 ;
27973 char * kwnames[] = {
27974 (char *) "self",(char *) "other", NULL
27975 };
27976
27977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27979 if (!SWIG_IsOK(res1)) {
27980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27981 }
27982 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27984 if (!SWIG_IsOK(res2)) {
27985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27986 }
27987 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27991 wxPyEndAllowThreads(__tstate);
27992 if (PyErr_Occurred()) SWIG_fail;
27993 }
27994 {
27995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27996 }
27997 return resultobj;
27998 fail:
27999 return NULL;
28000 }
28001
28002
28003 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28004 PyObject *resultobj = 0;
28005 wxDateTime *arg1 = (wxDateTime *) 0 ;
28006 wxDateTime *arg2 = (wxDateTime *) 0 ;
28007 bool result;
28008 void *argp1 = 0 ;
28009 int res1 = 0 ;
28010 void *argp2 = 0 ;
28011 int res2 = 0 ;
28012 PyObject * obj0 = 0 ;
28013 PyObject * obj1 = 0 ;
28014 char * kwnames[] = {
28015 (char *) "self",(char *) "other", NULL
28016 };
28017
28018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28020 if (!SWIG_IsOK(res1)) {
28021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28022 }
28023 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28025 if (!SWIG_IsOK(res2)) {
28026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28027 }
28028 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28029 {
28030 PyThreadState* __tstate = wxPyBeginAllowThreads();
28031 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28032 wxPyEndAllowThreads(__tstate);
28033 if (PyErr_Occurred()) SWIG_fail;
28034 }
28035 {
28036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28037 }
28038 return resultobj;
28039 fail:
28040 return NULL;
28041 }
28042
28043
28044 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28045 PyObject *resultobj = 0;
28046 wxDateTime *arg1 = (wxDateTime *) 0 ;
28047 wxDateTime *arg2 = (wxDateTime *) 0 ;
28048 bool result;
28049 void *argp1 = 0 ;
28050 int res1 = 0 ;
28051 void *argp2 = 0 ;
28052 int res2 = 0 ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char * kwnames[] = {
28056 (char *) "self",(char *) "other", NULL
28057 };
28058
28059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28061 if (!SWIG_IsOK(res1)) {
28062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28063 }
28064 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28065 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28066 if (!SWIG_IsOK(res2)) {
28067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28068 }
28069 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 {
28077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28078 }
28079 return resultobj;
28080 fail:
28081 return NULL;
28082 }
28083
28084
28085 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28086 PyObject *resultobj = 0;
28087 wxDateTime *arg1 = (wxDateTime *) 0 ;
28088 wxDateTime *arg2 = (wxDateTime *) 0 ;
28089 bool result;
28090 void *argp1 = 0 ;
28091 int res1 = 0 ;
28092 void *argp2 = 0 ;
28093 int res2 = 0 ;
28094 PyObject * obj0 = 0 ;
28095 PyObject * obj1 = 0 ;
28096 char * kwnames[] = {
28097 (char *) "self",(char *) "other", NULL
28098 };
28099
28100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28102 if (!SWIG_IsOK(res1)) {
28103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28104 }
28105 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28107 if (!SWIG_IsOK(res2)) {
28108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28109 }
28110 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28114 wxPyEndAllowThreads(__tstate);
28115 if (PyErr_Occurred()) SWIG_fail;
28116 }
28117 {
28118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28119 }
28120 return resultobj;
28121 fail:
28122 return NULL;
28123 }
28124
28125
28126 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28127 PyObject *resultobj = 0;
28128 wxDateTime *arg1 = (wxDateTime *) 0 ;
28129 wxDateTime *arg2 = (wxDateTime *) 0 ;
28130 bool result;
28131 void *argp1 = 0 ;
28132 int res1 = 0 ;
28133 void *argp2 = 0 ;
28134 int res2 = 0 ;
28135 PyObject * obj0 = 0 ;
28136 PyObject * obj1 = 0 ;
28137 char * kwnames[] = {
28138 (char *) "self",(char *) "other", NULL
28139 };
28140
28141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28143 if (!SWIG_IsOK(res1)) {
28144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28145 }
28146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28148 if (!SWIG_IsOK(res2)) {
28149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28150 }
28151 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28152 {
28153 PyThreadState* __tstate = wxPyBeginAllowThreads();
28154 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28155 wxPyEndAllowThreads(__tstate);
28156 if (PyErr_Occurred()) SWIG_fail;
28157 }
28158 {
28159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28160 }
28161 return resultobj;
28162 fail:
28163 return NULL;
28164 }
28165
28166
28167 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28168 PyObject *resultobj = 0;
28169 wxDateTime *arg1 = (wxDateTime *) 0 ;
28170 wxDateTime *arg2 = (wxDateTime *) 0 ;
28171 bool result;
28172 void *argp1 = 0 ;
28173 int res1 = 0 ;
28174 void *argp2 = 0 ;
28175 int res2 = 0 ;
28176 PyObject * obj0 = 0 ;
28177 PyObject * obj1 = 0 ;
28178 char * kwnames[] = {
28179 (char *) "self",(char *) "other", NULL
28180 };
28181
28182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28184 if (!SWIG_IsOK(res1)) {
28185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28186 }
28187 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28189 if (!SWIG_IsOK(res2)) {
28190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28191 }
28192 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 {
28200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28201 }
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28209 PyObject *resultobj = 0;
28210 wxDateTime *arg1 = (wxDateTime *) 0 ;
28211 wxString *arg2 = 0 ;
28212 int result;
28213 void *argp1 = 0 ;
28214 int res1 = 0 ;
28215 bool temp2 = false ;
28216 PyObject * obj0 = 0 ;
28217 PyObject * obj1 = 0 ;
28218 char * kwnames[] = {
28219 (char *) "self",(char *) "date", NULL
28220 };
28221
28222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28224 if (!SWIG_IsOK(res1)) {
28225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28226 }
28227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28228 {
28229 arg2 = wxString_in_helper(obj1);
28230 if (arg2 == NULL) SWIG_fail;
28231 temp2 = true;
28232 }
28233 {
28234 PyThreadState* __tstate = wxPyBeginAllowThreads();
28235 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28236 wxPyEndAllowThreads(__tstate);
28237 if (PyErr_Occurred()) SWIG_fail;
28238 }
28239 resultobj = SWIG_From_int(static_cast< int >(result));
28240 {
28241 if (temp2)
28242 delete arg2;
28243 }
28244 return resultobj;
28245 fail:
28246 {
28247 if (temp2)
28248 delete arg2;
28249 }
28250 return NULL;
28251 }
28252
28253
28254 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj = 0;
28256 wxDateTime *arg1 = (wxDateTime *) 0 ;
28257 wxString *arg2 = 0 ;
28258 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28259 wxString *arg3 = (wxString *) &arg3_defvalue ;
28260 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28261 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28262 int result;
28263 void *argp1 = 0 ;
28264 int res1 = 0 ;
28265 bool temp2 = false ;
28266 bool temp3 = false ;
28267 void *argp4 = 0 ;
28268 int res4 = 0 ;
28269 PyObject * obj0 = 0 ;
28270 PyObject * obj1 = 0 ;
28271 PyObject * obj2 = 0 ;
28272 PyObject * obj3 = 0 ;
28273 char * kwnames[] = {
28274 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28275 };
28276
28277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28279 if (!SWIG_IsOK(res1)) {
28280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28281 }
28282 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28283 {
28284 arg2 = wxString_in_helper(obj1);
28285 if (arg2 == NULL) SWIG_fail;
28286 temp2 = true;
28287 }
28288 if (obj2) {
28289 {
28290 arg3 = wxString_in_helper(obj2);
28291 if (arg3 == NULL) SWIG_fail;
28292 temp3 = true;
28293 }
28294 }
28295 if (obj3) {
28296 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28297 if (!SWIG_IsOK(res4)) {
28298 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28299 }
28300 if (!argp4) {
28301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28302 }
28303 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28304 }
28305 {
28306 PyThreadState* __tstate = wxPyBeginAllowThreads();
28307 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28308 wxPyEndAllowThreads(__tstate);
28309 if (PyErr_Occurred()) SWIG_fail;
28310 }
28311 resultobj = SWIG_From_int(static_cast< int >(result));
28312 {
28313 if (temp2)
28314 delete arg2;
28315 }
28316 {
28317 if (temp3)
28318 delete arg3;
28319 }
28320 return resultobj;
28321 fail:
28322 {
28323 if (temp2)
28324 delete arg2;
28325 }
28326 {
28327 if (temp3)
28328 delete arg3;
28329 }
28330 return NULL;
28331 }
28332
28333
28334 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28335 PyObject *resultobj = 0;
28336 wxDateTime *arg1 = (wxDateTime *) 0 ;
28337 wxString *arg2 = 0 ;
28338 int result;
28339 void *argp1 = 0 ;
28340 int res1 = 0 ;
28341 bool temp2 = false ;
28342 PyObject * obj0 = 0 ;
28343 PyObject * obj1 = 0 ;
28344 char * kwnames[] = {
28345 (char *) "self",(char *) "datetime", NULL
28346 };
28347
28348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28350 if (!SWIG_IsOK(res1)) {
28351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28352 }
28353 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28354 {
28355 arg2 = wxString_in_helper(obj1);
28356 if (arg2 == NULL) SWIG_fail;
28357 temp2 = true;
28358 }
28359 {
28360 PyThreadState* __tstate = wxPyBeginAllowThreads();
28361 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 resultobj = SWIG_From_int(static_cast< int >(result));
28366 {
28367 if (temp2)
28368 delete arg2;
28369 }
28370 return resultobj;
28371 fail:
28372 {
28373 if (temp2)
28374 delete arg2;
28375 }
28376 return NULL;
28377 }
28378
28379
28380 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28381 PyObject *resultobj = 0;
28382 wxDateTime *arg1 = (wxDateTime *) 0 ;
28383 wxString *arg2 = 0 ;
28384 int result;
28385 void *argp1 = 0 ;
28386 int res1 = 0 ;
28387 bool temp2 = false ;
28388 PyObject * obj0 = 0 ;
28389 PyObject * obj1 = 0 ;
28390 char * kwnames[] = {
28391 (char *) "self",(char *) "date", NULL
28392 };
28393
28394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28396 if (!SWIG_IsOK(res1)) {
28397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28398 }
28399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28400 {
28401 arg2 = wxString_in_helper(obj1);
28402 if (arg2 == NULL) SWIG_fail;
28403 temp2 = true;
28404 }
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 resultobj = SWIG_From_int(static_cast< int >(result));
28412 {
28413 if (temp2)
28414 delete arg2;
28415 }
28416 return resultobj;
28417 fail:
28418 {
28419 if (temp2)
28420 delete arg2;
28421 }
28422 return NULL;
28423 }
28424
28425
28426 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28427 PyObject *resultobj = 0;
28428 wxDateTime *arg1 = (wxDateTime *) 0 ;
28429 wxString *arg2 = 0 ;
28430 int result;
28431 void *argp1 = 0 ;
28432 int res1 = 0 ;
28433 bool temp2 = false ;
28434 PyObject * obj0 = 0 ;
28435 PyObject * obj1 = 0 ;
28436 char * kwnames[] = {
28437 (char *) "self",(char *) "time", NULL
28438 };
28439
28440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28442 if (!SWIG_IsOK(res1)) {
28443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28444 }
28445 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28446 {
28447 arg2 = wxString_in_helper(obj1);
28448 if (arg2 == NULL) SWIG_fail;
28449 temp2 = true;
28450 }
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 resultobj = SWIG_From_int(static_cast< int >(result));
28458 {
28459 if (temp2)
28460 delete arg2;
28461 }
28462 return resultobj;
28463 fail:
28464 {
28465 if (temp2)
28466 delete arg2;
28467 }
28468 return NULL;
28469 }
28470
28471
28472 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28473 PyObject *resultobj = 0;
28474 wxDateTime *arg1 = (wxDateTime *) 0 ;
28475 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28476 wxString *arg2 = (wxString *) &arg2_defvalue ;
28477 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28478 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28479 wxString result;
28480 void *argp1 = 0 ;
28481 int res1 = 0 ;
28482 bool temp2 = false ;
28483 bool temp3 = false ;
28484 PyObject * obj0 = 0 ;
28485 PyObject * obj1 = 0 ;
28486 PyObject * obj2 = 0 ;
28487 char * kwnames[] = {
28488 (char *) "self",(char *) "format",(char *) "tz", NULL
28489 };
28490
28491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28495 }
28496 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28497 if (obj1) {
28498 {
28499 arg2 = wxString_in_helper(obj1);
28500 if (arg2 == NULL) SWIG_fail;
28501 temp2 = true;
28502 }
28503 }
28504 if (obj2) {
28505 {
28506 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28507 temp3 = true;
28508 }
28509 }
28510 {
28511 PyThreadState* __tstate = wxPyBeginAllowThreads();
28512 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 {
28517 #if wxUSE_UNICODE
28518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28519 #else
28520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28521 #endif
28522 }
28523 {
28524 if (temp2)
28525 delete arg2;
28526 }
28527 {
28528 if (temp3) delete arg3;
28529 }
28530 return resultobj;
28531 fail:
28532 {
28533 if (temp2)
28534 delete arg2;
28535 }
28536 {
28537 if (temp3) delete arg3;
28538 }
28539 return NULL;
28540 }
28541
28542
28543 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(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_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28556 }
28557 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = ((wxDateTime const *)arg1)->FormatDate();
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_FormatTime(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_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28590 }
28591 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 result = ((wxDateTime const *)arg1)->FormatTime();
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 *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28612 PyObject *resultobj = 0;
28613 wxDateTime *arg1 = (wxDateTime *) 0 ;
28614 wxString result;
28615 void *argp1 = 0 ;
28616 int res1 = 0 ;
28617 PyObject *swig_obj[1] ;
28618
28619 if (!args) SWIG_fail;
28620 swig_obj[0] = args;
28621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28622 if (!SWIG_IsOK(res1)) {
28623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28624 }
28625 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 result = ((wxDateTime const *)arg1)->FormatISODate();
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 {
28633 #if wxUSE_UNICODE
28634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28635 #else
28636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28637 #endif
28638 }
28639 return resultobj;
28640 fail:
28641 return NULL;
28642 }
28643
28644
28645 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28646 PyObject *resultobj = 0;
28647 wxDateTime *arg1 = (wxDateTime *) 0 ;
28648 wxString result;
28649 void *argp1 = 0 ;
28650 int res1 = 0 ;
28651 PyObject *swig_obj[1] ;
28652
28653 if (!args) SWIG_fail;
28654 swig_obj[0] = args;
28655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28656 if (!SWIG_IsOK(res1)) {
28657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28658 }
28659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 result = ((wxDateTime const *)arg1)->FormatISOTime();
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 {
28667 #if wxUSE_UNICODE
28668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28669 #else
28670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28671 #endif
28672 }
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28680 PyObject *obj;
28681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28682 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28683 return SWIG_Py_Void();
28684 }
28685
28686 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28687 return SWIG_Python_InitShadowInstance(args);
28688 }
28689
28690 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28691 PyObject *resultobj = 0;
28692 long arg1 ;
28693 wxTimeSpan result;
28694 long val1 ;
28695 int ecode1 = 0 ;
28696 PyObject * obj0 = 0 ;
28697 char * kwnames[] = {
28698 (char *) "ms", NULL
28699 };
28700
28701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28702 ecode1 = SWIG_AsVal_long(obj0, &val1);
28703 if (!SWIG_IsOK(ecode1)) {
28704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28705 }
28706 arg1 = static_cast< long >(val1);
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 result = wxTimeSpan::Milliseconds(arg1);
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28721 PyObject *resultobj = 0;
28722 wxTimeSpan result;
28723
28724 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 result = wxTimeSpan::Millisecond();
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj = 0;
28740 long arg1 ;
28741 wxTimeSpan result;
28742 long val1 ;
28743 int ecode1 = 0 ;
28744 PyObject * obj0 = 0 ;
28745 char * kwnames[] = {
28746 (char *) "sec", NULL
28747 };
28748
28749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28750 ecode1 = SWIG_AsVal_long(obj0, &val1);
28751 if (!SWIG_IsOK(ecode1)) {
28752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28753 }
28754 arg1 = static_cast< long >(val1);
28755 {
28756 PyThreadState* __tstate = wxPyBeginAllowThreads();
28757 result = wxTimeSpan::Seconds(arg1);
28758 wxPyEndAllowThreads(__tstate);
28759 if (PyErr_Occurred()) SWIG_fail;
28760 }
28761 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28762 return resultobj;
28763 fail:
28764 return NULL;
28765 }
28766
28767
28768 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28769 PyObject *resultobj = 0;
28770 wxTimeSpan result;
28771
28772 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = wxTimeSpan::Second();
28776 wxPyEndAllowThreads(__tstate);
28777 if (PyErr_Occurred()) SWIG_fail;
28778 }
28779 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28780 return resultobj;
28781 fail:
28782 return NULL;
28783 }
28784
28785
28786 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28787 PyObject *resultobj = 0;
28788 long arg1 ;
28789 wxTimeSpan result;
28790 long val1 ;
28791 int ecode1 = 0 ;
28792 PyObject * obj0 = 0 ;
28793 char * kwnames[] = {
28794 (char *) "min", NULL
28795 };
28796
28797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28798 ecode1 = SWIG_AsVal_long(obj0, &val1);
28799 if (!SWIG_IsOK(ecode1)) {
28800 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28801 }
28802 arg1 = static_cast< long >(val1);
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 result = wxTimeSpan::Minutes(arg1);
28806 wxPyEndAllowThreads(__tstate);
28807 if (PyErr_Occurred()) SWIG_fail;
28808 }
28809 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28810 return resultobj;
28811 fail:
28812 return NULL;
28813 }
28814
28815
28816 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28817 PyObject *resultobj = 0;
28818 wxTimeSpan result;
28819
28820 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 result = wxTimeSpan::Minute();
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28828 return resultobj;
28829 fail:
28830 return NULL;
28831 }
28832
28833
28834 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28835 PyObject *resultobj = 0;
28836 long arg1 ;
28837 wxTimeSpan result;
28838 long val1 ;
28839 int ecode1 = 0 ;
28840 PyObject * obj0 = 0 ;
28841 char * kwnames[] = {
28842 (char *) "hours", NULL
28843 };
28844
28845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28846 ecode1 = SWIG_AsVal_long(obj0, &val1);
28847 if (!SWIG_IsOK(ecode1)) {
28848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28849 }
28850 arg1 = static_cast< long >(val1);
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 result = wxTimeSpan::Hours(arg1);
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28865 PyObject *resultobj = 0;
28866 wxTimeSpan result;
28867
28868 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 result = wxTimeSpan::Hour();
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj = 0;
28884 long arg1 ;
28885 wxTimeSpan result;
28886 long val1 ;
28887 int ecode1 = 0 ;
28888 PyObject * obj0 = 0 ;
28889 char * kwnames[] = {
28890 (char *) "days", NULL
28891 };
28892
28893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28894 ecode1 = SWIG_AsVal_long(obj0, &val1);
28895 if (!SWIG_IsOK(ecode1)) {
28896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28897 }
28898 arg1 = static_cast< long >(val1);
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 result = wxTimeSpan::Days(arg1);
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28906 return resultobj;
28907 fail:
28908 return NULL;
28909 }
28910
28911
28912 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28913 PyObject *resultobj = 0;
28914 wxTimeSpan result;
28915
28916 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = wxTimeSpan::Day();
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28924 return resultobj;
28925 fail:
28926 return NULL;
28927 }
28928
28929
28930 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28931 PyObject *resultobj = 0;
28932 long arg1 ;
28933 wxTimeSpan result;
28934 long val1 ;
28935 int ecode1 = 0 ;
28936 PyObject * obj0 = 0 ;
28937 char * kwnames[] = {
28938 (char *) "days", NULL
28939 };
28940
28941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28942 ecode1 = SWIG_AsVal_long(obj0, &val1);
28943 if (!SWIG_IsOK(ecode1)) {
28944 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28945 }
28946 arg1 = static_cast< long >(val1);
28947 {
28948 PyThreadState* __tstate = wxPyBeginAllowThreads();
28949 result = wxTimeSpan::Weeks(arg1);
28950 wxPyEndAllowThreads(__tstate);
28951 if (PyErr_Occurred()) SWIG_fail;
28952 }
28953 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28954 return resultobj;
28955 fail:
28956 return NULL;
28957 }
28958
28959
28960 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28961 PyObject *resultobj = 0;
28962 wxTimeSpan result;
28963
28964 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28965 {
28966 PyThreadState* __tstate = wxPyBeginAllowThreads();
28967 result = wxTimeSpan::Week();
28968 wxPyEndAllowThreads(__tstate);
28969 if (PyErr_Occurred()) SWIG_fail;
28970 }
28971 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28972 return resultobj;
28973 fail:
28974 return NULL;
28975 }
28976
28977
28978 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28979 PyObject *resultobj = 0;
28980 long arg1 = (long) 0 ;
28981 long arg2 = (long) 0 ;
28982 long arg3 = (long) 0 ;
28983 long arg4 = (long) 0 ;
28984 wxTimeSpan *result = 0 ;
28985 long val1 ;
28986 int ecode1 = 0 ;
28987 long val2 ;
28988 int ecode2 = 0 ;
28989 long val3 ;
28990 int ecode3 = 0 ;
28991 long val4 ;
28992 int ecode4 = 0 ;
28993 PyObject * obj0 = 0 ;
28994 PyObject * obj1 = 0 ;
28995 PyObject * obj2 = 0 ;
28996 PyObject * obj3 = 0 ;
28997 char * kwnames[] = {
28998 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28999 };
29000
29001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29002 if (obj0) {
29003 ecode1 = SWIG_AsVal_long(obj0, &val1);
29004 if (!SWIG_IsOK(ecode1)) {
29005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
29006 }
29007 arg1 = static_cast< long >(val1);
29008 }
29009 if (obj1) {
29010 ecode2 = SWIG_AsVal_long(obj1, &val2);
29011 if (!SWIG_IsOK(ecode2)) {
29012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
29013 }
29014 arg2 = static_cast< long >(val2);
29015 }
29016 if (obj2) {
29017 ecode3 = SWIG_AsVal_long(obj2, &val3);
29018 if (!SWIG_IsOK(ecode3)) {
29019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
29020 }
29021 arg3 = static_cast< long >(val3);
29022 }
29023 if (obj3) {
29024 ecode4 = SWIG_AsVal_long(obj3, &val4);
29025 if (!SWIG_IsOK(ecode4)) {
29026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
29027 }
29028 arg4 = static_cast< long >(val4);
29029 }
29030 {
29031 PyThreadState* __tstate = wxPyBeginAllowThreads();
29032 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29033 wxPyEndAllowThreads(__tstate);
29034 if (PyErr_Occurred()) SWIG_fail;
29035 }
29036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29037 return resultobj;
29038 fail:
29039 return NULL;
29040 }
29041
29042
29043 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29044 PyObject *resultobj = 0;
29045 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29046 void *argp1 = 0 ;
29047 int res1 = 0 ;
29048 PyObject *swig_obj[1] ;
29049
29050 if (!args) SWIG_fail;
29051 swig_obj[0] = args;
29052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29053 if (!SWIG_IsOK(res1)) {
29054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29055 }
29056 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 delete arg1;
29060
29061 wxPyEndAllowThreads(__tstate);
29062 if (PyErr_Occurred()) SWIG_fail;
29063 }
29064 resultobj = SWIG_Py_Void();
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29072 PyObject *resultobj = 0;
29073 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29074 wxTimeSpan *arg2 = 0 ;
29075 wxTimeSpan *result = 0 ;
29076 void *argp1 = 0 ;
29077 int res1 = 0 ;
29078 void *argp2 = 0 ;
29079 int res2 = 0 ;
29080 PyObject * obj0 = 0 ;
29081 PyObject * obj1 = 0 ;
29082 char * kwnames[] = {
29083 (char *) "self",(char *) "diff", NULL
29084 };
29085
29086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29088 if (!SWIG_IsOK(res1)) {
29089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29090 }
29091 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29092 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29093 if (!SWIG_IsOK(res2)) {
29094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29095 }
29096 if (!argp2) {
29097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29098 }
29099 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 {
29103 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29104 result = (wxTimeSpan *) &_result_ref;
29105 }
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj = 0;
29118 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29119 wxTimeSpan *arg2 = 0 ;
29120 wxTimeSpan *result = 0 ;
29121 void *argp1 = 0 ;
29122 int res1 = 0 ;
29123 void *argp2 = 0 ;
29124 int res2 = 0 ;
29125 PyObject * obj0 = 0 ;
29126 PyObject * obj1 = 0 ;
29127 char * kwnames[] = {
29128 (char *) "self",(char *) "diff", NULL
29129 };
29130
29131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29133 if (!SWIG_IsOK(res1)) {
29134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29135 }
29136 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29137 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29138 if (!SWIG_IsOK(res2)) {
29139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29140 }
29141 if (!argp2) {
29142 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29143 }
29144 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29145 {
29146 PyThreadState* __tstate = wxPyBeginAllowThreads();
29147 {
29148 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29149 result = (wxTimeSpan *) &_result_ref;
29150 }
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29162 PyObject *resultobj = 0;
29163 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29164 int arg2 ;
29165 wxTimeSpan *result = 0 ;
29166 void *argp1 = 0 ;
29167 int res1 = 0 ;
29168 int val2 ;
29169 int ecode2 = 0 ;
29170 PyObject * obj0 = 0 ;
29171 PyObject * obj1 = 0 ;
29172 char * kwnames[] = {
29173 (char *) "self",(char *) "n", NULL
29174 };
29175
29176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29178 if (!SWIG_IsOK(res1)) {
29179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29180 }
29181 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29182 ecode2 = SWIG_AsVal_int(obj1, &val2);
29183 if (!SWIG_IsOK(ecode2)) {
29184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29185 }
29186 arg2 = static_cast< int >(val2);
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 {
29190 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29191 result = (wxTimeSpan *) &_result_ref;
29192 }
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29204 PyObject *resultobj = 0;
29205 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29206 wxTimeSpan *result = 0 ;
29207 void *argp1 = 0 ;
29208 int res1 = 0 ;
29209 PyObject *swig_obj[1] ;
29210
29211 if (!args) SWIG_fail;
29212 swig_obj[0] = args;
29213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29214 if (!SWIG_IsOK(res1)) {
29215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29216 }
29217 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 {
29221 wxTimeSpan &_result_ref = (arg1)->Neg();
29222 result = (wxTimeSpan *) &_result_ref;
29223 }
29224 wxPyEndAllowThreads(__tstate);
29225 if (PyErr_Occurred()) SWIG_fail;
29226 }
29227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29228 return resultobj;
29229 fail:
29230 return NULL;
29231 }
29232
29233
29234 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29235 PyObject *resultobj = 0;
29236 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29237 wxTimeSpan result;
29238 void *argp1 = 0 ;
29239 int res1 = 0 ;
29240 PyObject *swig_obj[1] ;
29241
29242 if (!args) SWIG_fail;
29243 swig_obj[0] = args;
29244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29245 if (!SWIG_IsOK(res1)) {
29246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29247 }
29248 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29249 {
29250 PyThreadState* __tstate = wxPyBeginAllowThreads();
29251 result = ((wxTimeSpan const *)arg1)->Abs();
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29263 PyObject *resultobj = 0;
29264 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29265 wxTimeSpan *arg2 = 0 ;
29266 wxTimeSpan *result = 0 ;
29267 void *argp1 = 0 ;
29268 int res1 = 0 ;
29269 void *argp2 = 0 ;
29270 int res2 = 0 ;
29271 PyObject * obj0 = 0 ;
29272 PyObject * obj1 = 0 ;
29273 char * kwnames[] = {
29274 (char *) "self",(char *) "diff", NULL
29275 };
29276
29277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29279 if (!SWIG_IsOK(res1)) {
29280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29281 }
29282 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29284 if (!SWIG_IsOK(res2)) {
29285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29286 }
29287 if (!argp2) {
29288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29289 }
29290 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 {
29294 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29295 result = (wxTimeSpan *) &_result_ref;
29296 }
29297 wxPyEndAllowThreads(__tstate);
29298 if (PyErr_Occurred()) SWIG_fail;
29299 }
29300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29301 return resultobj;
29302 fail:
29303 return NULL;
29304 }
29305
29306
29307 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29308 PyObject *resultobj = 0;
29309 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29310 wxTimeSpan *arg2 = 0 ;
29311 wxTimeSpan *result = 0 ;
29312 void *argp1 = 0 ;
29313 int res1 = 0 ;
29314 void *argp2 = 0 ;
29315 int res2 = 0 ;
29316 PyObject * obj0 = 0 ;
29317 PyObject * obj1 = 0 ;
29318 char * kwnames[] = {
29319 (char *) "self",(char *) "diff", NULL
29320 };
29321
29322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29324 if (!SWIG_IsOK(res1)) {
29325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29326 }
29327 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29329 if (!SWIG_IsOK(res2)) {
29330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29331 }
29332 if (!argp2) {
29333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29334 }
29335 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29336 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 {
29339 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29340 result = (wxTimeSpan *) &_result_ref;
29341 }
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29353 PyObject *resultobj = 0;
29354 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29355 int arg2 ;
29356 wxTimeSpan *result = 0 ;
29357 void *argp1 = 0 ;
29358 int res1 = 0 ;
29359 int val2 ;
29360 int ecode2 = 0 ;
29361 PyObject * obj0 = 0 ;
29362 PyObject * obj1 = 0 ;
29363 char * kwnames[] = {
29364 (char *) "self",(char *) "n", NULL
29365 };
29366
29367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29369 if (!SWIG_IsOK(res1)) {
29370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29371 }
29372 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29373 ecode2 = SWIG_AsVal_int(obj1, &val2);
29374 if (!SWIG_IsOK(ecode2)) {
29375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29376 }
29377 arg2 = static_cast< int >(val2);
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 {
29381 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29382 result = (wxTimeSpan *) &_result_ref;
29383 }
29384 wxPyEndAllowThreads(__tstate);
29385 if (PyErr_Occurred()) SWIG_fail;
29386 }
29387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29395 PyObject *resultobj = 0;
29396 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29397 wxTimeSpan *result = 0 ;
29398 void *argp1 = 0 ;
29399 int res1 = 0 ;
29400 PyObject *swig_obj[1] ;
29401
29402 if (!args) SWIG_fail;
29403 swig_obj[0] = args;
29404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29405 if (!SWIG_IsOK(res1)) {
29406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29407 }
29408 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29409 {
29410 PyThreadState* __tstate = wxPyBeginAllowThreads();
29411 {
29412 wxTimeSpan &_result_ref = (arg1)->operator -();
29413 result = (wxTimeSpan *) &_result_ref;
29414 }
29415 wxPyEndAllowThreads(__tstate);
29416 if (PyErr_Occurred()) SWIG_fail;
29417 }
29418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29426 PyObject *resultobj = 0;
29427 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29428 wxTimeSpan *arg2 = 0 ;
29429 wxTimeSpan result;
29430 void *argp1 = 0 ;
29431 int res1 = 0 ;
29432 void *argp2 = 0 ;
29433 int res2 = 0 ;
29434 PyObject * obj0 = 0 ;
29435 PyObject * obj1 = 0 ;
29436 char * kwnames[] = {
29437 (char *) "self",(char *) "other", NULL
29438 };
29439
29440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29442 if (!SWIG_IsOK(res1)) {
29443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29444 }
29445 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29447 if (!SWIG_IsOK(res2)) {
29448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29449 }
29450 if (!argp2) {
29451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29452 }
29453 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29454 {
29455 PyThreadState* __tstate = wxPyBeginAllowThreads();
29456 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29457 wxPyEndAllowThreads(__tstate);
29458 if (PyErr_Occurred()) SWIG_fail;
29459 }
29460 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29461 return resultobj;
29462 fail:
29463 return NULL;
29464 }
29465
29466
29467 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29468 PyObject *resultobj = 0;
29469 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29470 wxTimeSpan *arg2 = 0 ;
29471 wxTimeSpan result;
29472 void *argp1 = 0 ;
29473 int res1 = 0 ;
29474 void *argp2 = 0 ;
29475 int res2 = 0 ;
29476 PyObject * obj0 = 0 ;
29477 PyObject * obj1 = 0 ;
29478 char * kwnames[] = {
29479 (char *) "self",(char *) "other", NULL
29480 };
29481
29482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29484 if (!SWIG_IsOK(res1)) {
29485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29486 }
29487 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29488 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29489 if (!SWIG_IsOK(res2)) {
29490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29491 }
29492 if (!argp2) {
29493 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29494 }
29495 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29499 wxPyEndAllowThreads(__tstate);
29500 if (PyErr_Occurred()) SWIG_fail;
29501 }
29502 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29510 PyObject *resultobj = 0;
29511 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29512 int arg2 ;
29513 wxTimeSpan result;
29514 void *argp1 = 0 ;
29515 int res1 = 0 ;
29516 int val2 ;
29517 int ecode2 = 0 ;
29518 PyObject * obj0 = 0 ;
29519 PyObject * obj1 = 0 ;
29520 char * kwnames[] = {
29521 (char *) "self",(char *) "n", NULL
29522 };
29523
29524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29526 if (!SWIG_IsOK(res1)) {
29527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29528 }
29529 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29530 ecode2 = SWIG_AsVal_int(obj1, &val2);
29531 if (!SWIG_IsOK(ecode2)) {
29532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29533 }
29534 arg2 = static_cast< int >(val2);
29535 {
29536 PyThreadState* __tstate = wxPyBeginAllowThreads();
29537 result = wxTimeSpan___mul__(arg1,arg2);
29538 wxPyEndAllowThreads(__tstate);
29539 if (PyErr_Occurred()) SWIG_fail;
29540 }
29541 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29549 PyObject *resultobj = 0;
29550 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29551 int arg2 ;
29552 wxTimeSpan result;
29553 void *argp1 = 0 ;
29554 int res1 = 0 ;
29555 int val2 ;
29556 int ecode2 = 0 ;
29557 PyObject * obj0 = 0 ;
29558 PyObject * obj1 = 0 ;
29559 char * kwnames[] = {
29560 (char *) "self",(char *) "n", NULL
29561 };
29562
29563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29565 if (!SWIG_IsOK(res1)) {
29566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29567 }
29568 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29569 ecode2 = SWIG_AsVal_int(obj1, &val2);
29570 if (!SWIG_IsOK(ecode2)) {
29571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29572 }
29573 arg2 = static_cast< int >(val2);
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = wxTimeSpan___rmul__(arg1,arg2);
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29588 PyObject *resultobj = 0;
29589 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29590 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29591 bool result;
29592 void *argp1 = 0 ;
29593 int res1 = 0 ;
29594 void *argp2 = 0 ;
29595 int res2 = 0 ;
29596 PyObject * obj0 = 0 ;
29597 PyObject * obj1 = 0 ;
29598 char * kwnames[] = {
29599 (char *) "self",(char *) "other", NULL
29600 };
29601
29602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29604 if (!SWIG_IsOK(res1)) {
29605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29606 }
29607 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29609 if (!SWIG_IsOK(res2)) {
29610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29611 }
29612 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29613 {
29614 PyThreadState* __tstate = wxPyBeginAllowThreads();
29615 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29616 wxPyEndAllowThreads(__tstate);
29617 if (PyErr_Occurred()) SWIG_fail;
29618 }
29619 {
29620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29621 }
29622 return resultobj;
29623 fail:
29624 return NULL;
29625 }
29626
29627
29628 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29629 PyObject *resultobj = 0;
29630 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29631 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29632 bool result;
29633 void *argp1 = 0 ;
29634 int res1 = 0 ;
29635 void *argp2 = 0 ;
29636 int res2 = 0 ;
29637 PyObject * obj0 = 0 ;
29638 PyObject * obj1 = 0 ;
29639 char * kwnames[] = {
29640 (char *) "self",(char *) "other", NULL
29641 };
29642
29643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29645 if (!SWIG_IsOK(res1)) {
29646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29647 }
29648 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29650 if (!SWIG_IsOK(res2)) {
29651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29652 }
29653 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29654 {
29655 PyThreadState* __tstate = wxPyBeginAllowThreads();
29656 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29657 wxPyEndAllowThreads(__tstate);
29658 if (PyErr_Occurred()) SWIG_fail;
29659 }
29660 {
29661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29662 }
29663 return resultobj;
29664 fail:
29665 return NULL;
29666 }
29667
29668
29669 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29670 PyObject *resultobj = 0;
29671 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29672 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29673 bool result;
29674 void *argp1 = 0 ;
29675 int res1 = 0 ;
29676 void *argp2 = 0 ;
29677 int res2 = 0 ;
29678 PyObject * obj0 = 0 ;
29679 PyObject * obj1 = 0 ;
29680 char * kwnames[] = {
29681 (char *) "self",(char *) "other", NULL
29682 };
29683
29684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29686 if (!SWIG_IsOK(res1)) {
29687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29688 }
29689 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29691 if (!SWIG_IsOK(res2)) {
29692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29693 }
29694 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29695 {
29696 PyThreadState* __tstate = wxPyBeginAllowThreads();
29697 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29698 wxPyEndAllowThreads(__tstate);
29699 if (PyErr_Occurred()) SWIG_fail;
29700 }
29701 {
29702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29703 }
29704 return resultobj;
29705 fail:
29706 return NULL;
29707 }
29708
29709
29710 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29711 PyObject *resultobj = 0;
29712 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29713 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29714 bool result;
29715 void *argp1 = 0 ;
29716 int res1 = 0 ;
29717 void *argp2 = 0 ;
29718 int res2 = 0 ;
29719 PyObject * obj0 = 0 ;
29720 PyObject * obj1 = 0 ;
29721 char * kwnames[] = {
29722 (char *) "self",(char *) "other", NULL
29723 };
29724
29725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29727 if (!SWIG_IsOK(res1)) {
29728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29729 }
29730 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29732 if (!SWIG_IsOK(res2)) {
29733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29734 }
29735 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 {
29743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29744 }
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29752 PyObject *resultobj = 0;
29753 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29754 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29755 bool result;
29756 void *argp1 = 0 ;
29757 int res1 = 0 ;
29758 void *argp2 = 0 ;
29759 int res2 = 0 ;
29760 PyObject * obj0 = 0 ;
29761 PyObject * obj1 = 0 ;
29762 char * kwnames[] = {
29763 (char *) "self",(char *) "other", NULL
29764 };
29765
29766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29768 if (!SWIG_IsOK(res1)) {
29769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29770 }
29771 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29773 if (!SWIG_IsOK(res2)) {
29774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29775 }
29776 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29777 {
29778 PyThreadState* __tstate = wxPyBeginAllowThreads();
29779 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29780 wxPyEndAllowThreads(__tstate);
29781 if (PyErr_Occurred()) SWIG_fail;
29782 }
29783 {
29784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29785 }
29786 return resultobj;
29787 fail:
29788 return NULL;
29789 }
29790
29791
29792 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29793 PyObject *resultobj = 0;
29794 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29795 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29796 bool result;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 void *argp2 = 0 ;
29800 int res2 = 0 ;
29801 PyObject * obj0 = 0 ;
29802 PyObject * obj1 = 0 ;
29803 char * kwnames[] = {
29804 (char *) "self",(char *) "other", NULL
29805 };
29806
29807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29809 if (!SWIG_IsOK(res1)) {
29810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29811 }
29812 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29814 if (!SWIG_IsOK(res2)) {
29815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29816 }
29817 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29818 {
29819 PyThreadState* __tstate = wxPyBeginAllowThreads();
29820 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29821 wxPyEndAllowThreads(__tstate);
29822 if (PyErr_Occurred()) SWIG_fail;
29823 }
29824 {
29825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29826 }
29827 return resultobj;
29828 fail:
29829 return NULL;
29830 }
29831
29832
29833 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29834 PyObject *resultobj = 0;
29835 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29836 bool result;
29837 void *argp1 = 0 ;
29838 int res1 = 0 ;
29839 PyObject *swig_obj[1] ;
29840
29841 if (!args) SWIG_fail;
29842 swig_obj[0] = args;
29843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29846 }
29847 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 {
29855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29856 }
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29864 PyObject *resultobj = 0;
29865 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29866 bool result;
29867 void *argp1 = 0 ;
29868 int res1 = 0 ;
29869 PyObject *swig_obj[1] ;
29870
29871 if (!args) SWIG_fail;
29872 swig_obj[0] = args;
29873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29874 if (!SWIG_IsOK(res1)) {
29875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29876 }
29877 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 {
29885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29886 }
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29894 PyObject *resultobj = 0;
29895 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29896 bool result;
29897 void *argp1 = 0 ;
29898 int res1 = 0 ;
29899 PyObject *swig_obj[1] ;
29900
29901 if (!args) SWIG_fail;
29902 swig_obj[0] = args;
29903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29904 if (!SWIG_IsOK(res1)) {
29905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29906 }
29907 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29908 {
29909 PyThreadState* __tstate = wxPyBeginAllowThreads();
29910 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29911 wxPyEndAllowThreads(__tstate);
29912 if (PyErr_Occurred()) SWIG_fail;
29913 }
29914 {
29915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29916 }
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29924 PyObject *resultobj = 0;
29925 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29926 wxTimeSpan *arg2 = 0 ;
29927 bool result;
29928 void *argp1 = 0 ;
29929 int res1 = 0 ;
29930 void *argp2 = 0 ;
29931 int res2 = 0 ;
29932 PyObject * obj0 = 0 ;
29933 PyObject * obj1 = 0 ;
29934 char * kwnames[] = {
29935 (char *) "self",(char *) "ts", NULL
29936 };
29937
29938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29940 if (!SWIG_IsOK(res1)) {
29941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29942 }
29943 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29944 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29945 if (!SWIG_IsOK(res2)) {
29946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29947 }
29948 if (!argp2) {
29949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29950 }
29951 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29952 {
29953 PyThreadState* __tstate = wxPyBeginAllowThreads();
29954 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29955 wxPyEndAllowThreads(__tstate);
29956 if (PyErr_Occurred()) SWIG_fail;
29957 }
29958 {
29959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29960 }
29961 return resultobj;
29962 fail:
29963 return NULL;
29964 }
29965
29966
29967 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29968 PyObject *resultobj = 0;
29969 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29970 wxTimeSpan *arg2 = 0 ;
29971 bool result;
29972 void *argp1 = 0 ;
29973 int res1 = 0 ;
29974 void *argp2 = 0 ;
29975 int res2 = 0 ;
29976 PyObject * obj0 = 0 ;
29977 PyObject * obj1 = 0 ;
29978 char * kwnames[] = {
29979 (char *) "self",(char *) "ts", NULL
29980 };
29981
29982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29986 }
29987 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29988 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29989 if (!SWIG_IsOK(res2)) {
29990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29991 }
29992 if (!argp2) {
29993 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29994 }
29995 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29996 {
29997 PyThreadState* __tstate = wxPyBeginAllowThreads();
29998 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29999 wxPyEndAllowThreads(__tstate);
30000 if (PyErr_Occurred()) SWIG_fail;
30001 }
30002 {
30003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30004 }
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30012 PyObject *resultobj = 0;
30013 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30014 wxTimeSpan *arg2 = 0 ;
30015 bool result;
30016 void *argp1 = 0 ;
30017 int res1 = 0 ;
30018 void *argp2 = 0 ;
30019 int res2 = 0 ;
30020 PyObject * obj0 = 0 ;
30021 PyObject * obj1 = 0 ;
30022 char * kwnames[] = {
30023 (char *) "self",(char *) "t", NULL
30024 };
30025
30026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
30027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30028 if (!SWIG_IsOK(res1)) {
30029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30030 }
30031 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30032 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30033 if (!SWIG_IsOK(res2)) {
30034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30035 }
30036 if (!argp2) {
30037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30038 }
30039 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30040 {
30041 PyThreadState* __tstate = wxPyBeginAllowThreads();
30042 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30043 wxPyEndAllowThreads(__tstate);
30044 if (PyErr_Occurred()) SWIG_fail;
30045 }
30046 {
30047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30048 }
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30056 PyObject *resultobj = 0;
30057 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30058 int result;
30059 void *argp1 = 0 ;
30060 int res1 = 0 ;
30061 PyObject *swig_obj[1] ;
30062
30063 if (!args) SWIG_fail;
30064 swig_obj[0] = args;
30065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30066 if (!SWIG_IsOK(res1)) {
30067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30068 }
30069 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30070 {
30071 PyThreadState* __tstate = wxPyBeginAllowThreads();
30072 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30073 wxPyEndAllowThreads(__tstate);
30074 if (PyErr_Occurred()) SWIG_fail;
30075 }
30076 resultobj = SWIG_From_int(static_cast< int >(result));
30077 return resultobj;
30078 fail:
30079 return NULL;
30080 }
30081
30082
30083 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30084 PyObject *resultobj = 0;
30085 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30086 int result;
30087 void *argp1 = 0 ;
30088 int res1 = 0 ;
30089 PyObject *swig_obj[1] ;
30090
30091 if (!args) SWIG_fail;
30092 swig_obj[0] = args;
30093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30094 if (!SWIG_IsOK(res1)) {
30095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30096 }
30097 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 resultobj = SWIG_From_int(static_cast< int >(result));
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30112 PyObject *resultobj = 0;
30113 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30114 int result;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 PyObject *swig_obj[1] ;
30118
30119 if (!args) SWIG_fail;
30120 swig_obj[0] = args;
30121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30122 if (!SWIG_IsOK(res1)) {
30123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30124 }
30125 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30126 {
30127 PyThreadState* __tstate = wxPyBeginAllowThreads();
30128 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 resultobj = SWIG_From_int(static_cast< int >(result));
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30140 PyObject *resultobj = 0;
30141 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30142 int result;
30143 void *argp1 = 0 ;
30144 int res1 = 0 ;
30145 PyObject *swig_obj[1] ;
30146
30147 if (!args) SWIG_fail;
30148 swig_obj[0] = args;
30149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30150 if (!SWIG_IsOK(res1)) {
30151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30152 }
30153 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30154 {
30155 PyThreadState* __tstate = wxPyBeginAllowThreads();
30156 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30157 wxPyEndAllowThreads(__tstate);
30158 if (PyErr_Occurred()) SWIG_fail;
30159 }
30160 resultobj = SWIG_From_int(static_cast< int >(result));
30161 return resultobj;
30162 fail:
30163 return NULL;
30164 }
30165
30166
30167 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30168 PyObject *resultobj = 0;
30169 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30170 wxLongLong result;
30171 void *argp1 = 0 ;
30172 int res1 = 0 ;
30173 PyObject *swig_obj[1] ;
30174
30175 if (!args) SWIG_fail;
30176 swig_obj[0] = args;
30177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30178 if (!SWIG_IsOK(res1)) {
30179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30180 }
30181 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 {
30189 PyObject *hi, *lo, *shifter, *shifted;
30190 hi = PyLong_FromLong( (&result)->GetHi() );
30191 lo = PyLong_FromLong( (&result)->GetLo() );
30192 shifter = PyLong_FromLong(32);
30193 shifted = PyNumber_Lshift(hi, shifter);
30194 resultobj = PyNumber_Or(shifted, lo);
30195 Py_DECREF(hi);
30196 Py_DECREF(lo);
30197 Py_DECREF(shifter);
30198 Py_DECREF(shifted);
30199 }
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30207 PyObject *resultobj = 0;
30208 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30209 wxLongLong result;
30210 void *argp1 = 0 ;
30211 int res1 = 0 ;
30212 PyObject *swig_obj[1] ;
30213
30214 if (!args) SWIG_fail;
30215 swig_obj[0] = args;
30216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30217 if (!SWIG_IsOK(res1)) {
30218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30219 }
30220 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30224 wxPyEndAllowThreads(__tstate);
30225 if (PyErr_Occurred()) SWIG_fail;
30226 }
30227 {
30228 PyObject *hi, *lo, *shifter, *shifted;
30229 hi = PyLong_FromLong( (&result)->GetHi() );
30230 lo = PyLong_FromLong( (&result)->GetLo() );
30231 shifter = PyLong_FromLong(32);
30232 shifted = PyNumber_Lshift(hi, shifter);
30233 resultobj = PyNumber_Or(shifted, lo);
30234 Py_DECREF(hi);
30235 Py_DECREF(lo);
30236 Py_DECREF(shifter);
30237 Py_DECREF(shifted);
30238 }
30239 return resultobj;
30240 fail:
30241 return NULL;
30242 }
30243
30244
30245 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30246 PyObject *resultobj = 0;
30247 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30248 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30249 wxString *arg2 = (wxString *) &arg2_defvalue ;
30250 wxString result;
30251 void *argp1 = 0 ;
30252 int res1 = 0 ;
30253 bool temp2 = false ;
30254 PyObject * obj0 = 0 ;
30255 PyObject * obj1 = 0 ;
30256 char * kwnames[] = {
30257 (char *) "self",(char *) "format", NULL
30258 };
30259
30260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30262 if (!SWIG_IsOK(res1)) {
30263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30264 }
30265 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30266 if (obj1) {
30267 {
30268 arg2 = wxString_in_helper(obj1);
30269 if (arg2 == NULL) SWIG_fail;
30270 temp2 = true;
30271 }
30272 }
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30276 wxPyEndAllowThreads(__tstate);
30277 if (PyErr_Occurred()) SWIG_fail;
30278 }
30279 {
30280 #if wxUSE_UNICODE
30281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30282 #else
30283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30284 #endif
30285 }
30286 {
30287 if (temp2)
30288 delete arg2;
30289 }
30290 return resultobj;
30291 fail:
30292 {
30293 if (temp2)
30294 delete arg2;
30295 }
30296 return NULL;
30297 }
30298
30299
30300 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30301 PyObject *obj;
30302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30303 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30304 return SWIG_Py_Void();
30305 }
30306
30307 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30308 return SWIG_Python_InitShadowInstance(args);
30309 }
30310
30311 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30312 PyObject *resultobj = 0;
30313 int arg1 = (int) 0 ;
30314 int arg2 = (int) 0 ;
30315 int arg3 = (int) 0 ;
30316 int arg4 = (int) 0 ;
30317 wxDateSpan *result = 0 ;
30318 int val1 ;
30319 int ecode1 = 0 ;
30320 int val2 ;
30321 int ecode2 = 0 ;
30322 int val3 ;
30323 int ecode3 = 0 ;
30324 int val4 ;
30325 int ecode4 = 0 ;
30326 PyObject * obj0 = 0 ;
30327 PyObject * obj1 = 0 ;
30328 PyObject * obj2 = 0 ;
30329 PyObject * obj3 = 0 ;
30330 char * kwnames[] = {
30331 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30332 };
30333
30334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30335 if (obj0) {
30336 ecode1 = SWIG_AsVal_int(obj0, &val1);
30337 if (!SWIG_IsOK(ecode1)) {
30338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30339 }
30340 arg1 = static_cast< int >(val1);
30341 }
30342 if (obj1) {
30343 ecode2 = SWIG_AsVal_int(obj1, &val2);
30344 if (!SWIG_IsOK(ecode2)) {
30345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30346 }
30347 arg2 = static_cast< int >(val2);
30348 }
30349 if (obj2) {
30350 ecode3 = SWIG_AsVal_int(obj2, &val3);
30351 if (!SWIG_IsOK(ecode3)) {
30352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30353 }
30354 arg3 = static_cast< int >(val3);
30355 }
30356 if (obj3) {
30357 ecode4 = SWIG_AsVal_int(obj3, &val4);
30358 if (!SWIG_IsOK(ecode4)) {
30359 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30360 }
30361 arg4 = static_cast< int >(val4);
30362 }
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30377 PyObject *resultobj = 0;
30378 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30379 void *argp1 = 0 ;
30380 int res1 = 0 ;
30381 PyObject *swig_obj[1] ;
30382
30383 if (!args) SWIG_fail;
30384 swig_obj[0] = args;
30385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30386 if (!SWIG_IsOK(res1)) {
30387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30388 }
30389 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30390 {
30391 PyThreadState* __tstate = wxPyBeginAllowThreads();
30392 delete arg1;
30393
30394 wxPyEndAllowThreads(__tstate);
30395 if (PyErr_Occurred()) SWIG_fail;
30396 }
30397 resultobj = SWIG_Py_Void();
30398 return resultobj;
30399 fail:
30400 return NULL;
30401 }
30402
30403
30404 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30405 PyObject *resultobj = 0;
30406 int arg1 ;
30407 wxDateSpan result;
30408 int val1 ;
30409 int ecode1 = 0 ;
30410 PyObject * obj0 = 0 ;
30411 char * kwnames[] = {
30412 (char *) "days", NULL
30413 };
30414
30415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30416 ecode1 = SWIG_AsVal_int(obj0, &val1);
30417 if (!SWIG_IsOK(ecode1)) {
30418 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30419 }
30420 arg1 = static_cast< int >(val1);
30421 {
30422 PyThreadState* __tstate = wxPyBeginAllowThreads();
30423 result = wxDateSpan::Days(arg1);
30424 wxPyEndAllowThreads(__tstate);
30425 if (PyErr_Occurred()) SWIG_fail;
30426 }
30427 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30435 PyObject *resultobj = 0;
30436 wxDateSpan result;
30437
30438 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30439 {
30440 PyThreadState* __tstate = wxPyBeginAllowThreads();
30441 result = wxDateSpan::Day();
30442 wxPyEndAllowThreads(__tstate);
30443 if (PyErr_Occurred()) SWIG_fail;
30444 }
30445 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30446 return resultobj;
30447 fail:
30448 return NULL;
30449 }
30450
30451
30452 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30453 PyObject *resultobj = 0;
30454 int arg1 ;
30455 wxDateSpan result;
30456 int val1 ;
30457 int ecode1 = 0 ;
30458 PyObject * obj0 = 0 ;
30459 char * kwnames[] = {
30460 (char *) "weeks", NULL
30461 };
30462
30463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30464 ecode1 = SWIG_AsVal_int(obj0, &val1);
30465 if (!SWIG_IsOK(ecode1)) {
30466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30467 }
30468 arg1 = static_cast< int >(val1);
30469 {
30470 PyThreadState* __tstate = wxPyBeginAllowThreads();
30471 result = wxDateSpan::Weeks(arg1);
30472 wxPyEndAllowThreads(__tstate);
30473 if (PyErr_Occurred()) SWIG_fail;
30474 }
30475 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30476 return resultobj;
30477 fail:
30478 return NULL;
30479 }
30480
30481
30482 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30483 PyObject *resultobj = 0;
30484 wxDateSpan result;
30485
30486 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30487 {
30488 PyThreadState* __tstate = wxPyBeginAllowThreads();
30489 result = wxDateSpan::Week();
30490 wxPyEndAllowThreads(__tstate);
30491 if (PyErr_Occurred()) SWIG_fail;
30492 }
30493 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30501 PyObject *resultobj = 0;
30502 int arg1 ;
30503 wxDateSpan result;
30504 int val1 ;
30505 int ecode1 = 0 ;
30506 PyObject * obj0 = 0 ;
30507 char * kwnames[] = {
30508 (char *) "mon", NULL
30509 };
30510
30511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30512 ecode1 = SWIG_AsVal_int(obj0, &val1);
30513 if (!SWIG_IsOK(ecode1)) {
30514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30515 }
30516 arg1 = static_cast< int >(val1);
30517 {
30518 PyThreadState* __tstate = wxPyBeginAllowThreads();
30519 result = wxDateSpan::Months(arg1);
30520 wxPyEndAllowThreads(__tstate);
30521 if (PyErr_Occurred()) SWIG_fail;
30522 }
30523 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30531 PyObject *resultobj = 0;
30532 wxDateSpan result;
30533
30534 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30535 {
30536 PyThreadState* __tstate = wxPyBeginAllowThreads();
30537 result = wxDateSpan::Month();
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj = 0;
30550 int arg1 ;
30551 wxDateSpan result;
30552 int val1 ;
30553 int ecode1 = 0 ;
30554 PyObject * obj0 = 0 ;
30555 char * kwnames[] = {
30556 (char *) "years", NULL
30557 };
30558
30559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30560 ecode1 = SWIG_AsVal_int(obj0, &val1);
30561 if (!SWIG_IsOK(ecode1)) {
30562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30563 }
30564 arg1 = static_cast< int >(val1);
30565 {
30566 PyThreadState* __tstate = wxPyBeginAllowThreads();
30567 result = wxDateSpan::Years(arg1);
30568 wxPyEndAllowThreads(__tstate);
30569 if (PyErr_Occurred()) SWIG_fail;
30570 }
30571 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30579 PyObject *resultobj = 0;
30580 wxDateSpan result;
30581
30582 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30583 {
30584 PyThreadState* __tstate = wxPyBeginAllowThreads();
30585 result = wxDateSpan::Year();
30586 wxPyEndAllowThreads(__tstate);
30587 if (PyErr_Occurred()) SWIG_fail;
30588 }
30589 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30590 return resultobj;
30591 fail:
30592 return NULL;
30593 }
30594
30595
30596 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30597 PyObject *resultobj = 0;
30598 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30599 int arg2 ;
30600 wxDateSpan *result = 0 ;
30601 void *argp1 = 0 ;
30602 int res1 = 0 ;
30603 int val2 ;
30604 int ecode2 = 0 ;
30605 PyObject * obj0 = 0 ;
30606 PyObject * obj1 = 0 ;
30607 char * kwnames[] = {
30608 (char *) "self",(char *) "n", NULL
30609 };
30610
30611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30613 if (!SWIG_IsOK(res1)) {
30614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30615 }
30616 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30617 ecode2 = SWIG_AsVal_int(obj1, &val2);
30618 if (!SWIG_IsOK(ecode2)) {
30619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30620 }
30621 arg2 = static_cast< int >(val2);
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 {
30625 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30626 result = (wxDateSpan *) &_result_ref;
30627 }
30628 wxPyEndAllowThreads(__tstate);
30629 if (PyErr_Occurred()) SWIG_fail;
30630 }
30631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30639 PyObject *resultobj = 0;
30640 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30641 int arg2 ;
30642 wxDateSpan *result = 0 ;
30643 void *argp1 = 0 ;
30644 int res1 = 0 ;
30645 int val2 ;
30646 int ecode2 = 0 ;
30647 PyObject * obj0 = 0 ;
30648 PyObject * obj1 = 0 ;
30649 char * kwnames[] = {
30650 (char *) "self",(char *) "n", NULL
30651 };
30652
30653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30657 }
30658 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30659 ecode2 = SWIG_AsVal_int(obj1, &val2);
30660 if (!SWIG_IsOK(ecode2)) {
30661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30662 }
30663 arg2 = static_cast< int >(val2);
30664 {
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 {
30667 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30668 result = (wxDateSpan *) &_result_ref;
30669 }
30670 wxPyEndAllowThreads(__tstate);
30671 if (PyErr_Occurred()) SWIG_fail;
30672 }
30673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30674 return resultobj;
30675 fail:
30676 return NULL;
30677 }
30678
30679
30680 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30681 PyObject *resultobj = 0;
30682 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30683 int arg2 ;
30684 wxDateSpan *result = 0 ;
30685 void *argp1 = 0 ;
30686 int res1 = 0 ;
30687 int val2 ;
30688 int ecode2 = 0 ;
30689 PyObject * obj0 = 0 ;
30690 PyObject * obj1 = 0 ;
30691 char * kwnames[] = {
30692 (char *) "self",(char *) "n", NULL
30693 };
30694
30695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30697 if (!SWIG_IsOK(res1)) {
30698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30699 }
30700 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30701 ecode2 = SWIG_AsVal_int(obj1, &val2);
30702 if (!SWIG_IsOK(ecode2)) {
30703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30704 }
30705 arg2 = static_cast< int >(val2);
30706 {
30707 PyThreadState* __tstate = wxPyBeginAllowThreads();
30708 {
30709 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30710 result = (wxDateSpan *) &_result_ref;
30711 }
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30716 return resultobj;
30717 fail:
30718 return NULL;
30719 }
30720
30721
30722 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30723 PyObject *resultobj = 0;
30724 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30725 int arg2 ;
30726 wxDateSpan *result = 0 ;
30727 void *argp1 = 0 ;
30728 int res1 = 0 ;
30729 int val2 ;
30730 int ecode2 = 0 ;
30731 PyObject * obj0 = 0 ;
30732 PyObject * obj1 = 0 ;
30733 char * kwnames[] = {
30734 (char *) "self",(char *) "n", NULL
30735 };
30736
30737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30739 if (!SWIG_IsOK(res1)) {
30740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30741 }
30742 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30743 ecode2 = SWIG_AsVal_int(obj1, &val2);
30744 if (!SWIG_IsOK(ecode2)) {
30745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30746 }
30747 arg2 = static_cast< int >(val2);
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 {
30751 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30752 result = (wxDateSpan *) &_result_ref;
30753 }
30754 wxPyEndAllowThreads(__tstate);
30755 if (PyErr_Occurred()) SWIG_fail;
30756 }
30757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30758 return resultobj;
30759 fail:
30760 return NULL;
30761 }
30762
30763
30764 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30765 PyObject *resultobj = 0;
30766 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30767 int result;
30768 void *argp1 = 0 ;
30769 int res1 = 0 ;
30770 PyObject *swig_obj[1] ;
30771
30772 if (!args) SWIG_fail;
30773 swig_obj[0] = args;
30774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30775 if (!SWIG_IsOK(res1)) {
30776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30777 }
30778 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30779 {
30780 PyThreadState* __tstate = wxPyBeginAllowThreads();
30781 result = (int)((wxDateSpan const *)arg1)->GetYears();
30782 wxPyEndAllowThreads(__tstate);
30783 if (PyErr_Occurred()) SWIG_fail;
30784 }
30785 resultobj = SWIG_From_int(static_cast< int >(result));
30786 return resultobj;
30787 fail:
30788 return NULL;
30789 }
30790
30791
30792 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30793 PyObject *resultobj = 0;
30794 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30795 int result;
30796 void *argp1 = 0 ;
30797 int res1 = 0 ;
30798 PyObject *swig_obj[1] ;
30799
30800 if (!args) SWIG_fail;
30801 swig_obj[0] = args;
30802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30803 if (!SWIG_IsOK(res1)) {
30804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30805 }
30806 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30807 {
30808 PyThreadState* __tstate = wxPyBeginAllowThreads();
30809 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30810 wxPyEndAllowThreads(__tstate);
30811 if (PyErr_Occurred()) SWIG_fail;
30812 }
30813 resultobj = SWIG_From_int(static_cast< int >(result));
30814 return resultobj;
30815 fail:
30816 return NULL;
30817 }
30818
30819
30820 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30821 PyObject *resultobj = 0;
30822 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30823 int result;
30824 void *argp1 = 0 ;
30825 int res1 = 0 ;
30826 PyObject *swig_obj[1] ;
30827
30828 if (!args) SWIG_fail;
30829 swig_obj[0] = args;
30830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30831 if (!SWIG_IsOK(res1)) {
30832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30833 }
30834 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 resultobj = SWIG_From_int(static_cast< int >(result));
30842 return resultobj;
30843 fail:
30844 return NULL;
30845 }
30846
30847
30848 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30849 PyObject *resultobj = 0;
30850 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30851 int result;
30852 void *argp1 = 0 ;
30853 int res1 = 0 ;
30854 PyObject *swig_obj[1] ;
30855
30856 if (!args) SWIG_fail;
30857 swig_obj[0] = args;
30858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30859 if (!SWIG_IsOK(res1)) {
30860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30861 }
30862 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30863 {
30864 PyThreadState* __tstate = wxPyBeginAllowThreads();
30865 result = (int)((wxDateSpan const *)arg1)->GetDays();
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 resultobj = SWIG_From_int(static_cast< int >(result));
30870 return resultobj;
30871 fail:
30872 return NULL;
30873 }
30874
30875
30876 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30877 PyObject *resultobj = 0;
30878 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30879 int result;
30880 void *argp1 = 0 ;
30881 int res1 = 0 ;
30882 PyObject *swig_obj[1] ;
30883
30884 if (!args) SWIG_fail;
30885 swig_obj[0] = args;
30886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30887 if (!SWIG_IsOK(res1)) {
30888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30889 }
30890 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 resultobj = SWIG_From_int(static_cast< int >(result));
30898 return resultobj;
30899 fail:
30900 return NULL;
30901 }
30902
30903
30904 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30905 PyObject *resultobj = 0;
30906 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30907 wxDateSpan *arg2 = 0 ;
30908 wxDateSpan *result = 0 ;
30909 void *argp1 = 0 ;
30910 int res1 = 0 ;
30911 void *argp2 = 0 ;
30912 int res2 = 0 ;
30913 PyObject * obj0 = 0 ;
30914 PyObject * obj1 = 0 ;
30915 char * kwnames[] = {
30916 (char *) "self",(char *) "other", NULL
30917 };
30918
30919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30923 }
30924 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30925 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30926 if (!SWIG_IsOK(res2)) {
30927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30928 }
30929 if (!argp2) {
30930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30931 }
30932 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 {
30936 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30937 result = (wxDateSpan *) &_result_ref;
30938 }
30939 wxPyEndAllowThreads(__tstate);
30940 if (PyErr_Occurred()) SWIG_fail;
30941 }
30942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj = 0;
30951 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30952 wxDateSpan *arg2 = 0 ;
30953 wxDateSpan *result = 0 ;
30954 void *argp1 = 0 ;
30955 int res1 = 0 ;
30956 void *argp2 = 0 ;
30957 int res2 = 0 ;
30958 PyObject * obj0 = 0 ;
30959 PyObject * obj1 = 0 ;
30960 char * kwnames[] = {
30961 (char *) "self",(char *) "other", NULL
30962 };
30963
30964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30966 if (!SWIG_IsOK(res1)) {
30967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30968 }
30969 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30971 if (!SWIG_IsOK(res2)) {
30972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30973 }
30974 if (!argp2) {
30975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30976 }
30977 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30978 {
30979 PyThreadState* __tstate = wxPyBeginAllowThreads();
30980 {
30981 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30982 result = (wxDateSpan *) &_result_ref;
30983 }
30984 wxPyEndAllowThreads(__tstate);
30985 if (PyErr_Occurred()) SWIG_fail;
30986 }
30987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30988 return resultobj;
30989 fail:
30990 return NULL;
30991 }
30992
30993
30994 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30995 PyObject *resultobj = 0;
30996 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30997 wxDateSpan *result = 0 ;
30998 void *argp1 = 0 ;
30999 int res1 = 0 ;
31000 PyObject *swig_obj[1] ;
31001
31002 if (!args) SWIG_fail;
31003 swig_obj[0] = args;
31004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31005 if (!SWIG_IsOK(res1)) {
31006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31007 }
31008 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 {
31012 wxDateSpan &_result_ref = (arg1)->Neg();
31013 result = (wxDateSpan *) &_result_ref;
31014 }
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31026 PyObject *resultobj = 0;
31027 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31028 int arg2 ;
31029 wxDateSpan *result = 0 ;
31030 void *argp1 = 0 ;
31031 int res1 = 0 ;
31032 int val2 ;
31033 int ecode2 = 0 ;
31034 PyObject * obj0 = 0 ;
31035 PyObject * obj1 = 0 ;
31036 char * kwnames[] = {
31037 (char *) "self",(char *) "factor", NULL
31038 };
31039
31040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31042 if (!SWIG_IsOK(res1)) {
31043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31044 }
31045 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31046 ecode2 = SWIG_AsVal_int(obj1, &val2);
31047 if (!SWIG_IsOK(ecode2)) {
31048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31049 }
31050 arg2 = static_cast< int >(val2);
31051 {
31052 PyThreadState* __tstate = wxPyBeginAllowThreads();
31053 {
31054 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31055 result = (wxDateSpan *) &_result_ref;
31056 }
31057 wxPyEndAllowThreads(__tstate);
31058 if (PyErr_Occurred()) SWIG_fail;
31059 }
31060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31061 return resultobj;
31062 fail:
31063 return NULL;
31064 }
31065
31066
31067 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31068 PyObject *resultobj = 0;
31069 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31070 wxDateSpan *arg2 = 0 ;
31071 wxDateSpan *result = 0 ;
31072 void *argp1 = 0 ;
31073 int res1 = 0 ;
31074 void *argp2 = 0 ;
31075 int res2 = 0 ;
31076 PyObject * obj0 = 0 ;
31077 PyObject * obj1 = 0 ;
31078 char * kwnames[] = {
31079 (char *) "self",(char *) "other", NULL
31080 };
31081
31082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31084 if (!SWIG_IsOK(res1)) {
31085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31086 }
31087 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31088 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31089 if (!SWIG_IsOK(res2)) {
31090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31091 }
31092 if (!argp2) {
31093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31094 }
31095 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31096 {
31097 PyThreadState* __tstate = wxPyBeginAllowThreads();
31098 {
31099 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31100 result = (wxDateSpan *) &_result_ref;
31101 }
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31106 return resultobj;
31107 fail:
31108 return NULL;
31109 }
31110
31111
31112 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31113 PyObject *resultobj = 0;
31114 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31115 wxDateSpan *arg2 = 0 ;
31116 wxDateSpan *result = 0 ;
31117 void *argp1 = 0 ;
31118 int res1 = 0 ;
31119 void *argp2 = 0 ;
31120 int res2 = 0 ;
31121 PyObject * obj0 = 0 ;
31122 PyObject * obj1 = 0 ;
31123 char * kwnames[] = {
31124 (char *) "self",(char *) "other", NULL
31125 };
31126
31127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31129 if (!SWIG_IsOK(res1)) {
31130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31131 }
31132 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31133 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31134 if (!SWIG_IsOK(res2)) {
31135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31136 }
31137 if (!argp2) {
31138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31139 }
31140 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31141 {
31142 PyThreadState* __tstate = wxPyBeginAllowThreads();
31143 {
31144 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31145 result = (wxDateSpan *) &_result_ref;
31146 }
31147 wxPyEndAllowThreads(__tstate);
31148 if (PyErr_Occurred()) SWIG_fail;
31149 }
31150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31151 return resultobj;
31152 fail:
31153 return NULL;
31154 }
31155
31156
31157 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31158 PyObject *resultobj = 0;
31159 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31160 wxDateSpan *result = 0 ;
31161 void *argp1 = 0 ;
31162 int res1 = 0 ;
31163 PyObject *swig_obj[1] ;
31164
31165 if (!args) SWIG_fail;
31166 swig_obj[0] = args;
31167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31168 if (!SWIG_IsOK(res1)) {
31169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31170 }
31171 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31172 {
31173 PyThreadState* __tstate = wxPyBeginAllowThreads();
31174 {
31175 wxDateSpan &_result_ref = (arg1)->operator -();
31176 result = (wxDateSpan *) &_result_ref;
31177 }
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31182 return resultobj;
31183 fail:
31184 return NULL;
31185 }
31186
31187
31188 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31189 PyObject *resultobj = 0;
31190 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31191 int arg2 ;
31192 wxDateSpan *result = 0 ;
31193 void *argp1 = 0 ;
31194 int res1 = 0 ;
31195 int val2 ;
31196 int ecode2 = 0 ;
31197 PyObject * obj0 = 0 ;
31198 PyObject * obj1 = 0 ;
31199 char * kwnames[] = {
31200 (char *) "self",(char *) "factor", NULL
31201 };
31202
31203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31205 if (!SWIG_IsOK(res1)) {
31206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31207 }
31208 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31209 ecode2 = SWIG_AsVal_int(obj1, &val2);
31210 if (!SWIG_IsOK(ecode2)) {
31211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31212 }
31213 arg2 = static_cast< int >(val2);
31214 {
31215 PyThreadState* __tstate = wxPyBeginAllowThreads();
31216 {
31217 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31218 result = (wxDateSpan *) &_result_ref;
31219 }
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31224 return resultobj;
31225 fail:
31226 return NULL;
31227 }
31228
31229
31230 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31231 PyObject *resultobj = 0;
31232 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31233 wxDateSpan *arg2 = 0 ;
31234 wxDateSpan result;
31235 void *argp1 = 0 ;
31236 int res1 = 0 ;
31237 void *argp2 = 0 ;
31238 int res2 = 0 ;
31239 PyObject * obj0 = 0 ;
31240 PyObject * obj1 = 0 ;
31241 char * kwnames[] = {
31242 (char *) "self",(char *) "other", NULL
31243 };
31244
31245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31247 if (!SWIG_IsOK(res1)) {
31248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31249 }
31250 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31251 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31252 if (!SWIG_IsOK(res2)) {
31253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31254 }
31255 if (!argp2) {
31256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31257 }
31258 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31259 {
31260 PyThreadState* __tstate = wxPyBeginAllowThreads();
31261 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31262 wxPyEndAllowThreads(__tstate);
31263 if (PyErr_Occurred()) SWIG_fail;
31264 }
31265 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31266 return resultobj;
31267 fail:
31268 return NULL;
31269 }
31270
31271
31272 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31273 PyObject *resultobj = 0;
31274 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31275 wxDateSpan *arg2 = 0 ;
31276 wxDateSpan result;
31277 void *argp1 = 0 ;
31278 int res1 = 0 ;
31279 void *argp2 = 0 ;
31280 int res2 = 0 ;
31281 PyObject * obj0 = 0 ;
31282 PyObject * obj1 = 0 ;
31283 char * kwnames[] = {
31284 (char *) "self",(char *) "other", NULL
31285 };
31286
31287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31289 if (!SWIG_IsOK(res1)) {
31290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31291 }
31292 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31293 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31294 if (!SWIG_IsOK(res2)) {
31295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31296 }
31297 if (!argp2) {
31298 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31299 }
31300 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31301 {
31302 PyThreadState* __tstate = wxPyBeginAllowThreads();
31303 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31304 wxPyEndAllowThreads(__tstate);
31305 if (PyErr_Occurred()) SWIG_fail;
31306 }
31307 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31308 return resultobj;
31309 fail:
31310 return NULL;
31311 }
31312
31313
31314 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31315 PyObject *resultobj = 0;
31316 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31317 int arg2 ;
31318 wxDateSpan result;
31319 void *argp1 = 0 ;
31320 int res1 = 0 ;
31321 int val2 ;
31322 int ecode2 = 0 ;
31323 PyObject * obj0 = 0 ;
31324 PyObject * obj1 = 0 ;
31325 char * kwnames[] = {
31326 (char *) "self",(char *) "n", NULL
31327 };
31328
31329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31331 if (!SWIG_IsOK(res1)) {
31332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31333 }
31334 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31335 ecode2 = SWIG_AsVal_int(obj1, &val2);
31336 if (!SWIG_IsOK(ecode2)) {
31337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31338 }
31339 arg2 = static_cast< int >(val2);
31340 {
31341 PyThreadState* __tstate = wxPyBeginAllowThreads();
31342 result = wxDateSpan___mul__(arg1,arg2);
31343 wxPyEndAllowThreads(__tstate);
31344 if (PyErr_Occurred()) SWIG_fail;
31345 }
31346 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31347 return resultobj;
31348 fail:
31349 return NULL;
31350 }
31351
31352
31353 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31354 PyObject *resultobj = 0;
31355 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31356 int arg2 ;
31357 wxDateSpan result;
31358 void *argp1 = 0 ;
31359 int res1 = 0 ;
31360 int val2 ;
31361 int ecode2 = 0 ;
31362 PyObject * obj0 = 0 ;
31363 PyObject * obj1 = 0 ;
31364 char * kwnames[] = {
31365 (char *) "self",(char *) "n", NULL
31366 };
31367
31368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31370 if (!SWIG_IsOK(res1)) {
31371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31372 }
31373 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31374 ecode2 = SWIG_AsVal_int(obj1, &val2);
31375 if (!SWIG_IsOK(ecode2)) {
31376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31377 }
31378 arg2 = static_cast< int >(val2);
31379 {
31380 PyThreadState* __tstate = wxPyBeginAllowThreads();
31381 result = wxDateSpan___rmul__(arg1,arg2);
31382 wxPyEndAllowThreads(__tstate);
31383 if (PyErr_Occurred()) SWIG_fail;
31384 }
31385 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31386 return resultobj;
31387 fail:
31388 return NULL;
31389 }
31390
31391
31392 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31393 PyObject *resultobj = 0;
31394 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31395 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31396 bool result;
31397 void *argp1 = 0 ;
31398 int res1 = 0 ;
31399 void *argp2 = 0 ;
31400 int res2 = 0 ;
31401 PyObject * obj0 = 0 ;
31402 PyObject * obj1 = 0 ;
31403 char * kwnames[] = {
31404 (char *) "self",(char *) "other", NULL
31405 };
31406
31407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31409 if (!SWIG_IsOK(res1)) {
31410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31411 }
31412 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31414 if (!SWIG_IsOK(res2)) {
31415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31416 }
31417 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 {
31425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31426 }
31427 return resultobj;
31428 fail:
31429 return NULL;
31430 }
31431
31432
31433 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31434 PyObject *resultobj = 0;
31435 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31436 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31437 bool result;
31438 void *argp1 = 0 ;
31439 int res1 = 0 ;
31440 void *argp2 = 0 ;
31441 int res2 = 0 ;
31442 PyObject * obj0 = 0 ;
31443 PyObject * obj1 = 0 ;
31444 char * kwnames[] = {
31445 (char *) "self",(char *) "other", NULL
31446 };
31447
31448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31450 if (!SWIG_IsOK(res1)) {
31451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31452 }
31453 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31455 if (!SWIG_IsOK(res2)) {
31456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31457 }
31458 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 {
31466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31467 }
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31475 PyObject *obj;
31476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31477 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31478 return SWIG_Py_Void();
31479 }
31480
31481 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 return SWIG_Python_InitShadowInstance(args);
31483 }
31484
31485 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31486 PyObject *resultobj = 0;
31487 long result;
31488
31489 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31490 {
31491 PyThreadState* __tstate = wxPyBeginAllowThreads();
31492 result = (long)wxGetLocalTime();
31493 wxPyEndAllowThreads(__tstate);
31494 if (PyErr_Occurred()) SWIG_fail;
31495 }
31496 resultobj = SWIG_From_long(static_cast< long >(result));
31497 return resultobj;
31498 fail:
31499 return NULL;
31500 }
31501
31502
31503 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31504 PyObject *resultobj = 0;
31505 long result;
31506
31507 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31508 {
31509 PyThreadState* __tstate = wxPyBeginAllowThreads();
31510 result = (long)wxGetUTCTime();
31511 wxPyEndAllowThreads(__tstate);
31512 if (PyErr_Occurred()) SWIG_fail;
31513 }
31514 resultobj = SWIG_From_long(static_cast< long >(result));
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31522 PyObject *resultobj = 0;
31523 long result;
31524
31525 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 result = (long)wxGetCurrentTime();
31529 wxPyEndAllowThreads(__tstate);
31530 if (PyErr_Occurred()) SWIG_fail;
31531 }
31532 resultobj = SWIG_From_long(static_cast< long >(result));
31533 return resultobj;
31534 fail:
31535 return NULL;
31536 }
31537
31538
31539 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31540 PyObject *resultobj = 0;
31541 wxLongLong result;
31542
31543 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31544 {
31545 PyThreadState* __tstate = wxPyBeginAllowThreads();
31546 result = wxGetLocalTimeMillis();
31547 wxPyEndAllowThreads(__tstate);
31548 if (PyErr_Occurred()) SWIG_fail;
31549 }
31550 {
31551 PyObject *hi, *lo, *shifter, *shifted;
31552 hi = PyLong_FromLong( (&result)->GetHi() );
31553 lo = PyLong_FromLong( (&result)->GetLo() );
31554 shifter = PyLong_FromLong(32);
31555 shifted = PyNumber_Lshift(hi, shifter);
31556 resultobj = PyNumber_Or(shifted, lo);
31557 Py_DECREF(hi);
31558 Py_DECREF(lo);
31559 Py_DECREF(shifter);
31560 Py_DECREF(shifted);
31561 }
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31569 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31570 return 1;
31571 }
31572
31573
31574 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31575 PyObject *pyobj = 0;
31576
31577 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31578 return pyobj;
31579 }
31580
31581
31582 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31583 PyObject *resultobj = 0;
31584 wxDataFormatId arg1 ;
31585 wxDataFormat *result = 0 ;
31586 int val1 ;
31587 int ecode1 = 0 ;
31588 PyObject * obj0 = 0 ;
31589 char * kwnames[] = {
31590 (char *) "type", NULL
31591 };
31592
31593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31594 ecode1 = SWIG_AsVal_int(obj0, &val1);
31595 if (!SWIG_IsOK(ecode1)) {
31596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31597 }
31598 arg1 = static_cast< wxDataFormatId >(val1);
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 result = (wxDataFormat *)new wxDataFormat(arg1);
31602 wxPyEndAllowThreads(__tstate);
31603 if (PyErr_Occurred()) SWIG_fail;
31604 }
31605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31606 return resultobj;
31607 fail:
31608 return NULL;
31609 }
31610
31611
31612 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31613 PyObject *resultobj = 0;
31614 wxString *arg1 = 0 ;
31615 wxDataFormat *result = 0 ;
31616 bool temp1 = false ;
31617 PyObject * obj0 = 0 ;
31618 char * kwnames[] = {
31619 (char *) "format", NULL
31620 };
31621
31622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31623 {
31624 arg1 = wxString_in_helper(obj0);
31625 if (arg1 == NULL) SWIG_fail;
31626 temp1 = true;
31627 }
31628 {
31629 PyThreadState* __tstate = wxPyBeginAllowThreads();
31630 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31631 wxPyEndAllowThreads(__tstate);
31632 if (PyErr_Occurred()) SWIG_fail;
31633 }
31634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31635 {
31636 if (temp1)
31637 delete arg1;
31638 }
31639 return resultobj;
31640 fail:
31641 {
31642 if (temp1)
31643 delete arg1;
31644 }
31645 return NULL;
31646 }
31647
31648
31649 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31650 PyObject *resultobj = 0;
31651 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31652 void *argp1 = 0 ;
31653 int res1 = 0 ;
31654 PyObject *swig_obj[1] ;
31655
31656 if (!args) SWIG_fail;
31657 swig_obj[0] = args;
31658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31659 if (!SWIG_IsOK(res1)) {
31660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31661 }
31662 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 delete arg1;
31666
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_Py_Void();
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31678 PyObject *resultobj = 0;
31679 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31680 wxDataFormatId arg2 ;
31681 bool result;
31682 void *argp1 = 0 ;
31683 int res1 = 0 ;
31684 int val2 ;
31685 int ecode2 = 0 ;
31686
31687 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31689 if (!SWIG_IsOK(res1)) {
31690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31691 }
31692 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31693 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31694 if (!SWIG_IsOK(ecode2)) {
31695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31696 }
31697 arg2 = static_cast< wxDataFormatId >(val2);
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31701 wxPyEndAllowThreads(__tstate);
31702 if (PyErr_Occurred()) SWIG_fail;
31703 }
31704 {
31705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31706 }
31707 return resultobj;
31708 fail:
31709 return NULL;
31710 }
31711
31712
31713 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31714 PyObject *resultobj = 0;
31715 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31716 wxDataFormatId arg2 ;
31717 bool result;
31718 void *argp1 = 0 ;
31719 int res1 = 0 ;
31720 int val2 ;
31721 int ecode2 = 0 ;
31722
31723 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31725 if (!SWIG_IsOK(res1)) {
31726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31727 }
31728 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31729 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31730 if (!SWIG_IsOK(ecode2)) {
31731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31732 }
31733 arg2 = static_cast< wxDataFormatId >(val2);
31734 {
31735 PyThreadState* __tstate = wxPyBeginAllowThreads();
31736 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31737 wxPyEndAllowThreads(__tstate);
31738 if (PyErr_Occurred()) SWIG_fail;
31739 }
31740 {
31741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31742 }
31743 return resultobj;
31744 fail:
31745 return NULL;
31746 }
31747
31748
31749 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31750 PyObject *resultobj = 0;
31751 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31752 wxDataFormat *arg2 = 0 ;
31753 bool result;
31754 void *argp1 = 0 ;
31755 int res1 = 0 ;
31756 void *argp2 = 0 ;
31757 int res2 = 0 ;
31758
31759 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31763 }
31764 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31765 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31766 if (!SWIG_IsOK(res2)) {
31767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31768 }
31769 if (!argp2) {
31770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31771 }
31772 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31776 wxPyEndAllowThreads(__tstate);
31777 if (PyErr_Occurred()) SWIG_fail;
31778 }
31779 {
31780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31781 }
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31789 int argc;
31790 PyObject *argv[3];
31791
31792 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31793 --argc;
31794 if (argc == 2) {
31795 int _v = 0;
31796 {
31797 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31798 _v = SWIG_CheckState(res);
31799 }
31800 if (!_v) goto check_1;
31801 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31802 }
31803 check_1:
31804
31805 if (argc == 2) {
31806 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31807 }
31808
31809 fail:
31810 Py_INCREF(Py_NotImplemented);
31811 return Py_NotImplemented;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31816 PyObject *resultobj = 0;
31817 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31818 wxDataFormat *arg2 = 0 ;
31819 bool result;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 void *argp2 = 0 ;
31823 int res2 = 0 ;
31824
31825 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31827 if (!SWIG_IsOK(res1)) {
31828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31829 }
31830 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31831 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31832 if (!SWIG_IsOK(res2)) {
31833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31834 }
31835 if (!argp2) {
31836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31837 }
31838 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31839 {
31840 PyThreadState* __tstate = wxPyBeginAllowThreads();
31841 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31842 wxPyEndAllowThreads(__tstate);
31843 if (PyErr_Occurred()) SWIG_fail;
31844 }
31845 {
31846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31847 }
31848 return resultobj;
31849 fail:
31850 return NULL;
31851 }
31852
31853
31854 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31855 int argc;
31856 PyObject *argv[3];
31857
31858 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31859 --argc;
31860 if (argc == 2) {
31861 int _v = 0;
31862 {
31863 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31864 _v = SWIG_CheckState(res);
31865 }
31866 if (!_v) goto check_1;
31867 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31868 }
31869 check_1:
31870
31871 if (argc == 2) {
31872 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31873 }
31874
31875 fail:
31876 Py_INCREF(Py_NotImplemented);
31877 return Py_NotImplemented;
31878 }
31879
31880
31881 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31882 PyObject *resultobj = 0;
31883 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31884 wxDataFormatId arg2 ;
31885 void *argp1 = 0 ;
31886 int res1 = 0 ;
31887 int val2 ;
31888 int ecode2 = 0 ;
31889 PyObject * obj0 = 0 ;
31890 PyObject * obj1 = 0 ;
31891 char * kwnames[] = {
31892 (char *) "self",(char *) "format", NULL
31893 };
31894
31895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31897 if (!SWIG_IsOK(res1)) {
31898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31899 }
31900 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31901 ecode2 = SWIG_AsVal_int(obj1, &val2);
31902 if (!SWIG_IsOK(ecode2)) {
31903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31904 }
31905 arg2 = static_cast< wxDataFormatId >(val2);
31906 {
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 (arg1)->SetType(arg2);
31909 wxPyEndAllowThreads(__tstate);
31910 if (PyErr_Occurred()) SWIG_fail;
31911 }
31912 resultobj = SWIG_Py_Void();
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31920 PyObject *resultobj = 0;
31921 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31922 wxDataFormatId result;
31923 void *argp1 = 0 ;
31924 int res1 = 0 ;
31925 PyObject *swig_obj[1] ;
31926
31927 if (!args) SWIG_fail;
31928 swig_obj[0] = args;
31929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31930 if (!SWIG_IsOK(res1)) {
31931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31932 }
31933 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 resultobj = SWIG_From_int(static_cast< int >(result));
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 SWIGINTERN PyObject *_wrap_DataFormat__GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31948 PyObject *resultobj = 0;
31949 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31950 wxString result;
31951 void *argp1 = 0 ;
31952 int res1 = 0 ;
31953 PyObject *swig_obj[1] ;
31954
31955 if (!args) SWIG_fail;
31956 swig_obj[0] = args;
31957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31958 if (!SWIG_IsOK(res1)) {
31959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat__GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31960 }
31961 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31962 {
31963 PyThreadState* __tstate = wxPyBeginAllowThreads();
31964 result = ((wxDataFormat const *)arg1)->GetId();
31965 wxPyEndAllowThreads(__tstate);
31966 if (PyErr_Occurred()) SWIG_fail;
31967 }
31968 {
31969 #if wxUSE_UNICODE
31970 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31971 #else
31972 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31973 #endif
31974 }
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31982 PyObject *resultobj = 0;
31983 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31984 wxString *arg2 = 0 ;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 bool temp2 = false ;
31988 PyObject * obj0 = 0 ;
31989 PyObject * obj1 = 0 ;
31990 char * kwnames[] = {
31991 (char *) "self",(char *) "format", NULL
31992 };
31993
31994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31996 if (!SWIG_IsOK(res1)) {
31997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31998 }
31999 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32000 {
32001 arg2 = wxString_in_helper(obj1);
32002 if (arg2 == NULL) SWIG_fail;
32003 temp2 = true;
32004 }
32005 {
32006 PyThreadState* __tstate = wxPyBeginAllowThreads();
32007 (arg1)->SetId((wxString const &)*arg2);
32008 wxPyEndAllowThreads(__tstate);
32009 if (PyErr_Occurred()) SWIG_fail;
32010 }
32011 resultobj = SWIG_Py_Void();
32012 {
32013 if (temp2)
32014 delete arg2;
32015 }
32016 return resultobj;
32017 fail:
32018 {
32019 if (temp2)
32020 delete arg2;
32021 }
32022 return NULL;
32023 }
32024
32025
32026 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32027 PyObject *obj;
32028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32029 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32030 return SWIG_Py_Void();
32031 }
32032
32033 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32034 return SWIG_Python_InitShadowInstance(args);
32035 }
32036
32037 SWIGINTERN int FormatInvalid_set(PyObject *) {
32038 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32039 return 1;
32040 }
32041
32042
32043 SWIGINTERN PyObject *FormatInvalid_get(void) {
32044 PyObject *pyobj = 0;
32045
32046 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32047 return pyobj;
32048 }
32049
32050
32051 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32052 PyObject *resultobj = 0;
32053 wxDataObject *arg1 = (wxDataObject *) 0 ;
32054 void *argp1 = 0 ;
32055 int res1 = 0 ;
32056 PyObject *swig_obj[1] ;
32057
32058 if (!args) SWIG_fail;
32059 swig_obj[0] = args;
32060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32061 if (!SWIG_IsOK(res1)) {
32062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32063 }
32064 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32065 {
32066 PyThreadState* __tstate = wxPyBeginAllowThreads();
32067 delete arg1;
32068
32069 wxPyEndAllowThreads(__tstate);
32070 if (PyErr_Occurred()) SWIG_fail;
32071 }
32072 resultobj = SWIG_Py_Void();
32073 return resultobj;
32074 fail:
32075 return NULL;
32076 }
32077
32078
32079 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32080 PyObject *resultobj = 0;
32081 wxDataObject *arg1 = (wxDataObject *) 0 ;
32082 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32083 SwigValueWrapper<wxDataFormat > result;
32084 void *argp1 = 0 ;
32085 int res1 = 0 ;
32086 int val2 ;
32087 int ecode2 = 0 ;
32088 PyObject * obj0 = 0 ;
32089 PyObject * obj1 = 0 ;
32090 char * kwnames[] = {
32091 (char *) "self",(char *) "dir", NULL
32092 };
32093
32094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32096 if (!SWIG_IsOK(res1)) {
32097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32098 }
32099 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32100 if (obj1) {
32101 ecode2 = SWIG_AsVal_int(obj1, &val2);
32102 if (!SWIG_IsOK(ecode2)) {
32103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32104 }
32105 arg2 = static_cast< wxDataObject::Direction >(val2);
32106 }
32107 {
32108 PyThreadState* __tstate = wxPyBeginAllowThreads();
32109 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32110 wxPyEndAllowThreads(__tstate);
32111 if (PyErr_Occurred()) SWIG_fail;
32112 }
32113 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32114 return resultobj;
32115 fail:
32116 return NULL;
32117 }
32118
32119
32120 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32121 PyObject *resultobj = 0;
32122 wxDataObject *arg1 = (wxDataObject *) 0 ;
32123 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32124 size_t result;
32125 void *argp1 = 0 ;
32126 int res1 = 0 ;
32127 int val2 ;
32128 int ecode2 = 0 ;
32129 PyObject * obj0 = 0 ;
32130 PyObject * obj1 = 0 ;
32131 char * kwnames[] = {
32132 (char *) "self",(char *) "dir", NULL
32133 };
32134
32135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32137 if (!SWIG_IsOK(res1)) {
32138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32139 }
32140 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32141 if (obj1) {
32142 ecode2 = SWIG_AsVal_int(obj1, &val2);
32143 if (!SWIG_IsOK(ecode2)) {
32144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32145 }
32146 arg2 = static_cast< wxDataObject::Direction >(val2);
32147 }
32148 {
32149 PyThreadState* __tstate = wxPyBeginAllowThreads();
32150 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32151 wxPyEndAllowThreads(__tstate);
32152 if (PyErr_Occurred()) SWIG_fail;
32153 }
32154 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32155 return resultobj;
32156 fail:
32157 return NULL;
32158 }
32159
32160
32161 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32162 PyObject *resultobj = 0;
32163 wxDataObject *arg1 = (wxDataObject *) 0 ;
32164 wxDataFormat *arg2 = 0 ;
32165 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32166 bool result;
32167 void *argp1 = 0 ;
32168 int res1 = 0 ;
32169 void *argp2 = 0 ;
32170 int res2 = 0 ;
32171 int val3 ;
32172 int ecode3 = 0 ;
32173 PyObject * obj0 = 0 ;
32174 PyObject * obj1 = 0 ;
32175 PyObject * obj2 = 0 ;
32176 char * kwnames[] = {
32177 (char *) "self",(char *) "format",(char *) "dir", NULL
32178 };
32179
32180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32182 if (!SWIG_IsOK(res1)) {
32183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32184 }
32185 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32186 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32187 if (!SWIG_IsOK(res2)) {
32188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32189 }
32190 if (!argp2) {
32191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32192 }
32193 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32194 if (obj2) {
32195 ecode3 = SWIG_AsVal_int(obj2, &val3);
32196 if (!SWIG_IsOK(ecode3)) {
32197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32198 }
32199 arg3 = static_cast< wxDataObject::Direction >(val3);
32200 }
32201 {
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 {
32208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32209 }
32210 return resultobj;
32211 fail:
32212 return NULL;
32213 }
32214
32215
32216 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32217 PyObject *resultobj = 0;
32218 wxDataObject *arg1 = (wxDataObject *) 0 ;
32219 wxDataFormat *arg2 = 0 ;
32220 size_t result;
32221 void *argp1 = 0 ;
32222 int res1 = 0 ;
32223 void *argp2 = 0 ;
32224 int res2 = 0 ;
32225 PyObject * obj0 = 0 ;
32226 PyObject * obj1 = 0 ;
32227 char * kwnames[] = {
32228 (char *) "self",(char *) "format", NULL
32229 };
32230
32231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32233 if (!SWIG_IsOK(res1)) {
32234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32235 }
32236 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32237 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32238 if (!SWIG_IsOK(res2)) {
32239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32240 }
32241 if (!argp2) {
32242 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32243 }
32244 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj = 0;
32260 wxDataObject *arg1 = (wxDataObject *) 0 ;
32261 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32262 PyObject *result = 0 ;
32263 void *argp1 = 0 ;
32264 int res1 = 0 ;
32265 int val2 ;
32266 int ecode2 = 0 ;
32267 PyObject * obj0 = 0 ;
32268 PyObject * obj1 = 0 ;
32269 char * kwnames[] = {
32270 (char *) "self",(char *) "dir", NULL
32271 };
32272
32273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32275 if (!SWIG_IsOK(res1)) {
32276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32277 }
32278 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32279 if (obj1) {
32280 ecode2 = SWIG_AsVal_int(obj1, &val2);
32281 if (!SWIG_IsOK(ecode2)) {
32282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32283 }
32284 arg2 = static_cast< wxDataObject::Direction >(val2);
32285 }
32286 {
32287 PyThreadState* __tstate = wxPyBeginAllowThreads();
32288 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32289 wxPyEndAllowThreads(__tstate);
32290 if (PyErr_Occurred()) SWIG_fail;
32291 }
32292 resultobj = result;
32293 return resultobj;
32294 fail:
32295 return NULL;
32296 }
32297
32298
32299 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32300 PyObject *resultobj = 0;
32301 wxDataObject *arg1 = (wxDataObject *) 0 ;
32302 wxDataFormat *arg2 = 0 ;
32303 PyObject *result = 0 ;
32304 void *argp1 = 0 ;
32305 int res1 = 0 ;
32306 void *argp2 = 0 ;
32307 int res2 = 0 ;
32308 PyObject * obj0 = 0 ;
32309 PyObject * obj1 = 0 ;
32310 char * kwnames[] = {
32311 (char *) "self",(char *) "format", NULL
32312 };
32313
32314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32316 if (!SWIG_IsOK(res1)) {
32317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32318 }
32319 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32320 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32321 if (!SWIG_IsOK(res2)) {
32322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32323 }
32324 if (!argp2) {
32325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32326 }
32327 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32331 wxPyEndAllowThreads(__tstate);
32332 if (PyErr_Occurred()) SWIG_fail;
32333 }
32334 resultobj = result;
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj = 0;
32343 wxDataObject *arg1 = (wxDataObject *) 0 ;
32344 wxDataFormat *arg2 = 0 ;
32345 PyObject *arg3 = (PyObject *) 0 ;
32346 bool result;
32347 void *argp1 = 0 ;
32348 int res1 = 0 ;
32349 void *argp2 = 0 ;
32350 int res2 = 0 ;
32351 PyObject * obj0 = 0 ;
32352 PyObject * obj1 = 0 ;
32353 PyObject * obj2 = 0 ;
32354 char * kwnames[] = {
32355 (char *) "self",(char *) "format",(char *) "data", NULL
32356 };
32357
32358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32360 if (!SWIG_IsOK(res1)) {
32361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32362 }
32363 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32365 if (!SWIG_IsOK(res2)) {
32366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32367 }
32368 if (!argp2) {
32369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32370 }
32371 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32372 arg3 = obj2;
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32376 wxPyEndAllowThreads(__tstate);
32377 if (PyErr_Occurred()) SWIG_fail;
32378 }
32379 {
32380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32381 }
32382 return resultobj;
32383 fail:
32384 return NULL;
32385 }
32386
32387
32388 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32389 PyObject *obj;
32390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32391 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32392 return SWIG_Py_Void();
32393 }
32394
32395 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32396 PyObject *resultobj = 0;
32397 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32398 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32399 wxDataObjectSimple *result = 0 ;
32400 void *argp1 = 0 ;
32401 int res1 = 0 ;
32402 PyObject * obj0 = 0 ;
32403 char * kwnames[] = {
32404 (char *) "format", NULL
32405 };
32406
32407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32408 if (obj0) {
32409 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32412 }
32413 if (!argp1) {
32414 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32415 }
32416 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32417 }
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32421 wxPyEndAllowThreads(__tstate);
32422 if (PyErr_Occurred()) SWIG_fail;
32423 }
32424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32425 return resultobj;
32426 fail:
32427 return NULL;
32428 }
32429
32430
32431 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32432 PyObject *resultobj = 0;
32433 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32434 wxDataFormat *result = 0 ;
32435 void *argp1 = 0 ;
32436 int res1 = 0 ;
32437 PyObject *swig_obj[1] ;
32438
32439 if (!args) SWIG_fail;
32440 swig_obj[0] = args;
32441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32442 if (!SWIG_IsOK(res1)) {
32443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32444 }
32445 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 {
32449 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32450 result = (wxDataFormat *) &_result_ref;
32451 }
32452 wxPyEndAllowThreads(__tstate);
32453 if (PyErr_Occurred()) SWIG_fail;
32454 }
32455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32456 return resultobj;
32457 fail:
32458 return NULL;
32459 }
32460
32461
32462 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32463 PyObject *resultobj = 0;
32464 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32465 wxDataFormat *arg2 = 0 ;
32466 void *argp1 = 0 ;
32467 int res1 = 0 ;
32468 void *argp2 = 0 ;
32469 int res2 = 0 ;
32470 PyObject * obj0 = 0 ;
32471 PyObject * obj1 = 0 ;
32472 char * kwnames[] = {
32473 (char *) "self",(char *) "format", NULL
32474 };
32475
32476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32478 if (!SWIG_IsOK(res1)) {
32479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32480 }
32481 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32482 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32483 if (!SWIG_IsOK(res2)) {
32484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32485 }
32486 if (!argp2) {
32487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32488 }
32489 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32490 {
32491 PyThreadState* __tstate = wxPyBeginAllowThreads();
32492 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32493 wxPyEndAllowThreads(__tstate);
32494 if (PyErr_Occurred()) SWIG_fail;
32495 }
32496 resultobj = SWIG_Py_Void();
32497 return resultobj;
32498 fail:
32499 return NULL;
32500 }
32501
32502
32503 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32504 PyObject *resultobj = 0;
32505 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32506 size_t result;
32507 void *argp1 = 0 ;
32508 int res1 = 0 ;
32509 PyObject *swig_obj[1] ;
32510
32511 if (!args) SWIG_fail;
32512 swig_obj[0] = args;
32513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32514 if (!SWIG_IsOK(res1)) {
32515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32516 }
32517 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32518 {
32519 PyThreadState* __tstate = wxPyBeginAllowThreads();
32520 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32521 wxPyEndAllowThreads(__tstate);
32522 if (PyErr_Occurred()) SWIG_fail;
32523 }
32524 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32532 PyObject *resultobj = 0;
32533 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32534 PyObject *result = 0 ;
32535 void *argp1 = 0 ;
32536 int res1 = 0 ;
32537 PyObject *swig_obj[1] ;
32538
32539 if (!args) SWIG_fail;
32540 swig_obj[0] = args;
32541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32542 if (!SWIG_IsOK(res1)) {
32543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32544 }
32545 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32546 {
32547 PyThreadState* __tstate = wxPyBeginAllowThreads();
32548 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 resultobj = result;
32553 return resultobj;
32554 fail:
32555 return NULL;
32556 }
32557
32558
32559 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32560 PyObject *resultobj = 0;
32561 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32562 PyObject *arg2 = (PyObject *) 0 ;
32563 bool result;
32564 void *argp1 = 0 ;
32565 int res1 = 0 ;
32566 PyObject * obj0 = 0 ;
32567 PyObject * obj1 = 0 ;
32568 char * kwnames[] = {
32569 (char *) "self",(char *) "data", NULL
32570 };
32571
32572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32574 if (!SWIG_IsOK(res1)) {
32575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32576 }
32577 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32578 arg2 = obj1;
32579 {
32580 PyThreadState* __tstate = wxPyBeginAllowThreads();
32581 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32582 wxPyEndAllowThreads(__tstate);
32583 if (PyErr_Occurred()) SWIG_fail;
32584 }
32585 {
32586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32587 }
32588 return resultobj;
32589 fail:
32590 return NULL;
32591 }
32592
32593
32594 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32595 PyObject *obj;
32596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32597 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32598 return SWIG_Py_Void();
32599 }
32600
32601 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32602 return SWIG_Python_InitShadowInstance(args);
32603 }
32604
32605 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32606 PyObject *resultobj = 0;
32607 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32608 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32609 wxPyDataObjectSimple *result = 0 ;
32610 void *argp1 = 0 ;
32611 int res1 = 0 ;
32612 PyObject * obj0 = 0 ;
32613 char * kwnames[] = {
32614 (char *) "format", NULL
32615 };
32616
32617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32618 if (obj0) {
32619 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32620 if (!SWIG_IsOK(res1)) {
32621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32622 }
32623 if (!argp1) {
32624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32625 }
32626 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32627 }
32628 {
32629 PyThreadState* __tstate = wxPyBeginAllowThreads();
32630 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32631 wxPyEndAllowThreads(__tstate);
32632 if (PyErr_Occurred()) SWIG_fail;
32633 }
32634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32635 return resultobj;
32636 fail:
32637 return NULL;
32638 }
32639
32640
32641 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32642 PyObject *resultobj = 0;
32643 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32644 PyObject *arg2 = (PyObject *) 0 ;
32645 PyObject *arg3 = (PyObject *) 0 ;
32646 void *argp1 = 0 ;
32647 int res1 = 0 ;
32648 PyObject * obj0 = 0 ;
32649 PyObject * obj1 = 0 ;
32650 PyObject * obj2 = 0 ;
32651 char * kwnames[] = {
32652 (char *) "self",(char *) "self",(char *) "_class", NULL
32653 };
32654
32655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32657 if (!SWIG_IsOK(res1)) {
32658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32659 }
32660 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32661 arg2 = obj1;
32662 arg3 = obj2;
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 (arg1)->_setCallbackInfo(arg2,arg3);
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 resultobj = SWIG_Py_Void();
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 PyObject *obj;
32678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32679 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32680 return SWIG_Py_Void();
32681 }
32682
32683 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32684 return SWIG_Python_InitShadowInstance(args);
32685 }
32686
32687 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32688 PyObject *resultobj = 0;
32689 wxDataObjectComposite *result = 0 ;
32690
32691 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32692 {
32693 PyThreadState* __tstate = wxPyBeginAllowThreads();
32694 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32695 wxPyEndAllowThreads(__tstate);
32696 if (PyErr_Occurred()) SWIG_fail;
32697 }
32698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32699 return resultobj;
32700 fail:
32701 return NULL;
32702 }
32703
32704
32705 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32706 PyObject *resultobj = 0;
32707 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32708 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32709 bool arg3 = (bool) false ;
32710 void *argp1 = 0 ;
32711 int res1 = 0 ;
32712 int res2 = 0 ;
32713 bool val3 ;
32714 int ecode3 = 0 ;
32715 PyObject * obj0 = 0 ;
32716 PyObject * obj1 = 0 ;
32717 PyObject * obj2 = 0 ;
32718 char * kwnames[] = {
32719 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32720 };
32721
32722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32724 if (!SWIG_IsOK(res1)) {
32725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32726 }
32727 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32728 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32729 if (!SWIG_IsOK(res2)) {
32730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32731 }
32732 if (obj2) {
32733 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32734 if (!SWIG_IsOK(ecode3)) {
32735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32736 }
32737 arg3 = static_cast< bool >(val3);
32738 }
32739 {
32740 PyThreadState* __tstate = wxPyBeginAllowThreads();
32741 (arg1)->Add(arg2,arg3);
32742 wxPyEndAllowThreads(__tstate);
32743 if (PyErr_Occurred()) SWIG_fail;
32744 }
32745 resultobj = SWIG_Py_Void();
32746 return resultobj;
32747 fail:
32748 return NULL;
32749 }
32750
32751
32752 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32753 PyObject *resultobj = 0;
32754 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32755 SwigValueWrapper<wxDataFormat > result;
32756 void *argp1 = 0 ;
32757 int res1 = 0 ;
32758 PyObject *swig_obj[1] ;
32759
32760 if (!args) SWIG_fail;
32761 swig_obj[0] = args;
32762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32763 if (!SWIG_IsOK(res1)) {
32764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32765 }
32766 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32767 {
32768 PyThreadState* __tstate = wxPyBeginAllowThreads();
32769 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32770 wxPyEndAllowThreads(__tstate);
32771 if (PyErr_Occurred()) SWIG_fail;
32772 }
32773 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32781 PyObject *obj;
32782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32783 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32784 return SWIG_Py_Void();
32785 }
32786
32787 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32788 return SWIG_Python_InitShadowInstance(args);
32789 }
32790
32791 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32792 PyObject *resultobj = 0;
32793 wxString const &arg1_defvalue = wxPyEmptyString ;
32794 wxString *arg1 = (wxString *) &arg1_defvalue ;
32795 wxTextDataObject *result = 0 ;
32796 bool temp1 = false ;
32797 PyObject * obj0 = 0 ;
32798 char * kwnames[] = {
32799 (char *) "text", NULL
32800 };
32801
32802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32803 if (obj0) {
32804 {
32805 arg1 = wxString_in_helper(obj0);
32806 if (arg1 == NULL) SWIG_fail;
32807 temp1 = true;
32808 }
32809 }
32810 {
32811 PyThreadState* __tstate = wxPyBeginAllowThreads();
32812 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32813 wxPyEndAllowThreads(__tstate);
32814 if (PyErr_Occurred()) SWIG_fail;
32815 }
32816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32817 {
32818 if (temp1)
32819 delete arg1;
32820 }
32821 return resultobj;
32822 fail:
32823 {
32824 if (temp1)
32825 delete arg1;
32826 }
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32832 PyObject *resultobj = 0;
32833 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32834 size_t result;
32835 void *argp1 = 0 ;
32836 int res1 = 0 ;
32837 PyObject *swig_obj[1] ;
32838
32839 if (!args) SWIG_fail;
32840 swig_obj[0] = args;
32841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32842 if (!SWIG_IsOK(res1)) {
32843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32844 }
32845 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32846 {
32847 PyThreadState* __tstate = wxPyBeginAllowThreads();
32848 result = (size_t)(arg1)->GetTextLength();
32849 wxPyEndAllowThreads(__tstate);
32850 if (PyErr_Occurred()) SWIG_fail;
32851 }
32852 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32853 return resultobj;
32854 fail:
32855 return NULL;
32856 }
32857
32858
32859 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32860 PyObject *resultobj = 0;
32861 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32862 wxString result;
32863 void *argp1 = 0 ;
32864 int res1 = 0 ;
32865 PyObject *swig_obj[1] ;
32866
32867 if (!args) SWIG_fail;
32868 swig_obj[0] = args;
32869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32870 if (!SWIG_IsOK(res1)) {
32871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32872 }
32873 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32874 {
32875 PyThreadState* __tstate = wxPyBeginAllowThreads();
32876 result = (arg1)->GetText();
32877 wxPyEndAllowThreads(__tstate);
32878 if (PyErr_Occurred()) SWIG_fail;
32879 }
32880 {
32881 #if wxUSE_UNICODE
32882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32883 #else
32884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32885 #endif
32886 }
32887 return resultobj;
32888 fail:
32889 return NULL;
32890 }
32891
32892
32893 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32894 PyObject *resultobj = 0;
32895 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32896 wxString *arg2 = 0 ;
32897 void *argp1 = 0 ;
32898 int res1 = 0 ;
32899 bool temp2 = false ;
32900 PyObject * obj0 = 0 ;
32901 PyObject * obj1 = 0 ;
32902 char * kwnames[] = {
32903 (char *) "self",(char *) "text", NULL
32904 };
32905
32906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32908 if (!SWIG_IsOK(res1)) {
32909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32910 }
32911 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32912 {
32913 arg2 = wxString_in_helper(obj1);
32914 if (arg2 == NULL) SWIG_fail;
32915 temp2 = true;
32916 }
32917 {
32918 PyThreadState* __tstate = wxPyBeginAllowThreads();
32919 (arg1)->SetText((wxString const &)*arg2);
32920 wxPyEndAllowThreads(__tstate);
32921 if (PyErr_Occurred()) SWIG_fail;
32922 }
32923 resultobj = SWIG_Py_Void();
32924 {
32925 if (temp2)
32926 delete arg2;
32927 }
32928 return resultobj;
32929 fail:
32930 {
32931 if (temp2)
32932 delete arg2;
32933 }
32934 return NULL;
32935 }
32936
32937
32938 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32939 PyObject *obj;
32940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32941 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32942 return SWIG_Py_Void();
32943 }
32944
32945 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32946 return SWIG_Python_InitShadowInstance(args);
32947 }
32948
32949 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32950 PyObject *resultobj = 0;
32951 wxString const &arg1_defvalue = wxPyEmptyString ;
32952 wxString *arg1 = (wxString *) &arg1_defvalue ;
32953 wxPyTextDataObject *result = 0 ;
32954 bool temp1 = false ;
32955 PyObject * obj0 = 0 ;
32956 char * kwnames[] = {
32957 (char *) "text", NULL
32958 };
32959
32960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32961 if (obj0) {
32962 {
32963 arg1 = wxString_in_helper(obj0);
32964 if (arg1 == NULL) SWIG_fail;
32965 temp1 = true;
32966 }
32967 }
32968 {
32969 PyThreadState* __tstate = wxPyBeginAllowThreads();
32970 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32971 wxPyEndAllowThreads(__tstate);
32972 if (PyErr_Occurred()) SWIG_fail;
32973 }
32974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32975 {
32976 if (temp1)
32977 delete arg1;
32978 }
32979 return resultobj;
32980 fail:
32981 {
32982 if (temp1)
32983 delete arg1;
32984 }
32985 return NULL;
32986 }
32987
32988
32989 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32990 PyObject *resultobj = 0;
32991 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32992 PyObject *arg2 = (PyObject *) 0 ;
32993 PyObject *arg3 = (PyObject *) 0 ;
32994 void *argp1 = 0 ;
32995 int res1 = 0 ;
32996 PyObject * obj0 = 0 ;
32997 PyObject * obj1 = 0 ;
32998 PyObject * obj2 = 0 ;
32999 char * kwnames[] = {
33000 (char *) "self",(char *) "self",(char *) "_class", NULL
33001 };
33002
33003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
33007 }
33008 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
33009 arg2 = obj1;
33010 arg3 = obj2;
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 (arg1)->_setCallbackInfo(arg2,arg3);
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 resultobj = SWIG_Py_Void();
33018 return resultobj;
33019 fail:
33020 return NULL;
33021 }
33022
33023
33024 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33025 PyObject *obj;
33026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33027 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
33028 return SWIG_Py_Void();
33029 }
33030
33031 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33032 return SWIG_Python_InitShadowInstance(args);
33033 }
33034
33035 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33036 PyObject *resultobj = 0;
33037 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33038 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33039 wxBitmapDataObject *result = 0 ;
33040 void *argp1 = 0 ;
33041 int res1 = 0 ;
33042 PyObject * obj0 = 0 ;
33043 char * kwnames[] = {
33044 (char *) "bitmap", NULL
33045 };
33046
33047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33048 if (obj0) {
33049 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33050 if (!SWIG_IsOK(res1)) {
33051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33052 }
33053 if (!argp1) {
33054 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33055 }
33056 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33057 }
33058 {
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33061 wxPyEndAllowThreads(__tstate);
33062 if (PyErr_Occurred()) SWIG_fail;
33063 }
33064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33065 return resultobj;
33066 fail:
33067 return NULL;
33068 }
33069
33070
33071 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33072 PyObject *resultobj = 0;
33073 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33074 wxBitmap result;
33075 void *argp1 = 0 ;
33076 int res1 = 0 ;
33077 PyObject *swig_obj[1] ;
33078
33079 if (!args) SWIG_fail;
33080 swig_obj[0] = args;
33081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33082 if (!SWIG_IsOK(res1)) {
33083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33084 }
33085 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33086 {
33087 PyThreadState* __tstate = wxPyBeginAllowThreads();
33088 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33089 wxPyEndAllowThreads(__tstate);
33090 if (PyErr_Occurred()) SWIG_fail;
33091 }
33092 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33093 return resultobj;
33094 fail:
33095 return NULL;
33096 }
33097
33098
33099 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33100 PyObject *resultobj = 0;
33101 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33102 wxBitmap *arg2 = 0 ;
33103 void *argp1 = 0 ;
33104 int res1 = 0 ;
33105 void *argp2 = 0 ;
33106 int res2 = 0 ;
33107 PyObject * obj0 = 0 ;
33108 PyObject * obj1 = 0 ;
33109 char * kwnames[] = {
33110 (char *) "self",(char *) "bitmap", NULL
33111 };
33112
33113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33115 if (!SWIG_IsOK(res1)) {
33116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33117 }
33118 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33120 if (!SWIG_IsOK(res2)) {
33121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33122 }
33123 if (!argp2) {
33124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33125 }
33126 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 resultobj = SWIG_Py_Void();
33134 return resultobj;
33135 fail:
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33141 PyObject *obj;
33142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33143 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33144 return SWIG_Py_Void();
33145 }
33146
33147 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33148 return SWIG_Python_InitShadowInstance(args);
33149 }
33150
33151 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33152 PyObject *resultobj = 0;
33153 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33154 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33155 wxPyBitmapDataObject *result = 0 ;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 PyObject * obj0 = 0 ;
33159 char * kwnames[] = {
33160 (char *) "bitmap", NULL
33161 };
33162
33163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33164 if (obj0) {
33165 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33166 if (!SWIG_IsOK(res1)) {
33167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33168 }
33169 if (!argp1) {
33170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33171 }
33172 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33173 }
33174 {
33175 PyThreadState* __tstate = wxPyBeginAllowThreads();
33176 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33181 return resultobj;
33182 fail:
33183 return NULL;
33184 }
33185
33186
33187 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33188 PyObject *resultobj = 0;
33189 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33190 PyObject *arg2 = (PyObject *) 0 ;
33191 PyObject *arg3 = (PyObject *) 0 ;
33192 void *argp1 = 0 ;
33193 int res1 = 0 ;
33194 PyObject * obj0 = 0 ;
33195 PyObject * obj1 = 0 ;
33196 PyObject * obj2 = 0 ;
33197 char * kwnames[] = {
33198 (char *) "self",(char *) "self",(char *) "_class", NULL
33199 };
33200
33201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33203 if (!SWIG_IsOK(res1)) {
33204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33205 }
33206 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33207 arg2 = obj1;
33208 arg3 = obj2;
33209 {
33210 PyThreadState* __tstate = wxPyBeginAllowThreads();
33211 (arg1)->_setCallbackInfo(arg2,arg3);
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 resultobj = SWIG_Py_Void();
33216 return resultobj;
33217 fail:
33218 return NULL;
33219 }
33220
33221
33222 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33223 PyObject *obj;
33224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33225 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33226 return SWIG_Py_Void();
33227 }
33228
33229 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33230 return SWIG_Python_InitShadowInstance(args);
33231 }
33232
33233 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33234 PyObject *resultobj = 0;
33235 wxFileDataObject *result = 0 ;
33236
33237 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33238 {
33239 PyThreadState* __tstate = wxPyBeginAllowThreads();
33240 result = (wxFileDataObject *)new wxFileDataObject();
33241 wxPyEndAllowThreads(__tstate);
33242 if (PyErr_Occurred()) SWIG_fail;
33243 }
33244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33245 return resultobj;
33246 fail:
33247 return NULL;
33248 }
33249
33250
33251 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33252 PyObject *resultobj = 0;
33253 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33254 wxArrayString *result = 0 ;
33255 void *argp1 = 0 ;
33256 int res1 = 0 ;
33257 PyObject *swig_obj[1] ;
33258
33259 if (!args) SWIG_fail;
33260 swig_obj[0] = args;
33261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33262 if (!SWIG_IsOK(res1)) {
33263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33264 }
33265 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33266 {
33267 PyThreadState* __tstate = wxPyBeginAllowThreads();
33268 {
33269 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33270 result = (wxArrayString *) &_result_ref;
33271 }
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 {
33276 resultobj = wxArrayString2PyList_helper(*result);
33277 }
33278 return resultobj;
33279 fail:
33280 return NULL;
33281 }
33282
33283
33284 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33285 PyObject *resultobj = 0;
33286 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33287 wxString *arg2 = 0 ;
33288 void *argp1 = 0 ;
33289 int res1 = 0 ;
33290 bool temp2 = false ;
33291 PyObject * obj0 = 0 ;
33292 PyObject * obj1 = 0 ;
33293 char * kwnames[] = {
33294 (char *) "self",(char *) "filename", NULL
33295 };
33296
33297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33299 if (!SWIG_IsOK(res1)) {
33300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33301 }
33302 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33303 {
33304 arg2 = wxString_in_helper(obj1);
33305 if (arg2 == NULL) SWIG_fail;
33306 temp2 = true;
33307 }
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 (arg1)->AddFile((wxString const &)*arg2);
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 resultobj = SWIG_Py_Void();
33315 {
33316 if (temp2)
33317 delete arg2;
33318 }
33319 return resultobj;
33320 fail:
33321 {
33322 if (temp2)
33323 delete arg2;
33324 }
33325 return NULL;
33326 }
33327
33328
33329 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33330 PyObject *obj;
33331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33332 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33333 return SWIG_Py_Void();
33334 }
33335
33336 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33337 return SWIG_Python_InitShadowInstance(args);
33338 }
33339
33340 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33341 PyObject *resultobj = 0;
33342 wxDataFormat *arg1 = 0 ;
33343 wxCustomDataObject *result = 0 ;
33344 void *argp1 = 0 ;
33345 int res1 = 0 ;
33346
33347 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33349 if (!SWIG_IsOK(res1)) {
33350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33351 }
33352 if (!argp1) {
33353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33354 }
33355 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33356 {
33357 PyThreadState* __tstate = wxPyBeginAllowThreads();
33358 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33359 wxPyEndAllowThreads(__tstate);
33360 if (PyErr_Occurred()) SWIG_fail;
33361 }
33362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33370 PyObject *resultobj = 0;
33371 wxString *arg1 = 0 ;
33372 wxCustomDataObject *result = 0 ;
33373 bool temp1 = false ;
33374
33375 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33376 {
33377 arg1 = wxString_in_helper(swig_obj[0]);
33378 if (arg1 == NULL) SWIG_fail;
33379 temp1 = true;
33380 }
33381 {
33382 PyThreadState* __tstate = wxPyBeginAllowThreads();
33383 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33384 wxPyEndAllowThreads(__tstate);
33385 if (PyErr_Occurred()) SWIG_fail;
33386 }
33387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33388 {
33389 if (temp1)
33390 delete arg1;
33391 }
33392 return resultobj;
33393 fail:
33394 {
33395 if (temp1)
33396 delete arg1;
33397 }
33398 return NULL;
33399 }
33400
33401
33402 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33403 PyObject *resultobj = 0;
33404 wxCustomDataObject *result = 0 ;
33405
33406 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (wxCustomDataObject *)new wxCustomDataObject();
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33414 return resultobj;
33415 fail:
33416 return NULL;
33417 }
33418
33419
33420 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33421 int argc;
33422 PyObject *argv[2];
33423
33424 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33425 --argc;
33426 if (argc == 0) {
33427 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33428 }
33429 if (argc == 1) {
33430 int _v = 0;
33431 {
33432 {
33433 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33434 }
33435 }
33436 if (!_v) goto check_2;
33437 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33438 }
33439 check_2:
33440
33441 if (argc == 1) {
33442 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33443 }
33444
33445 fail:
33446 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33447 return NULL;
33448 }
33449
33450
33451 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33452 PyObject *resultobj = 0;
33453 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33454 PyObject *arg2 = (PyObject *) 0 ;
33455 bool result;
33456 void *argp1 = 0 ;
33457 int res1 = 0 ;
33458 PyObject * obj0 = 0 ;
33459 PyObject * obj1 = 0 ;
33460 char * kwnames[] = {
33461 (char *) "self",(char *) "data", NULL
33462 };
33463
33464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33466 if (!SWIG_IsOK(res1)) {
33467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33468 }
33469 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33470 arg2 = obj1;
33471 {
33472 PyThreadState* __tstate = wxPyBeginAllowThreads();
33473 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33474 wxPyEndAllowThreads(__tstate);
33475 if (PyErr_Occurred()) SWIG_fail;
33476 }
33477 {
33478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33479 }
33480 return resultobj;
33481 fail:
33482 return NULL;
33483 }
33484
33485
33486 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33487 PyObject *resultobj = 0;
33488 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33489 size_t result;
33490 void *argp1 = 0 ;
33491 int res1 = 0 ;
33492 PyObject *swig_obj[1] ;
33493
33494 if (!args) SWIG_fail;
33495 swig_obj[0] = args;
33496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33497 if (!SWIG_IsOK(res1)) {
33498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33499 }
33500 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33501 {
33502 PyThreadState* __tstate = wxPyBeginAllowThreads();
33503 result = (size_t)(arg1)->GetSize();
33504 wxPyEndAllowThreads(__tstate);
33505 if (PyErr_Occurred()) SWIG_fail;
33506 }
33507 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33508 return resultobj;
33509 fail:
33510 return NULL;
33511 }
33512
33513
33514 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33515 PyObject *resultobj = 0;
33516 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33517 PyObject *result = 0 ;
33518 void *argp1 = 0 ;
33519 int res1 = 0 ;
33520 PyObject *swig_obj[1] ;
33521
33522 if (!args) SWIG_fail;
33523 swig_obj[0] = args;
33524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33525 if (!SWIG_IsOK(res1)) {
33526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33527 }
33528 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33529 {
33530 PyThreadState* __tstate = wxPyBeginAllowThreads();
33531 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33532 wxPyEndAllowThreads(__tstate);
33533 if (PyErr_Occurred()) SWIG_fail;
33534 }
33535 resultobj = result;
33536 return resultobj;
33537 fail:
33538 return NULL;
33539 }
33540
33541
33542 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33543 PyObject *obj;
33544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33545 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33546 return SWIG_Py_Void();
33547 }
33548
33549 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33550 return SWIG_Python_InitShadowInstance(args);
33551 }
33552
33553 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33554 PyObject *resultobj = 0;
33555 wxString const &arg1_defvalue = wxPyEmptyString ;
33556 wxString *arg1 = (wxString *) &arg1_defvalue ;
33557 wxURLDataObject *result = 0 ;
33558 bool temp1 = false ;
33559 PyObject * obj0 = 0 ;
33560 char * kwnames[] = {
33561 (char *) "url", NULL
33562 };
33563
33564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33565 if (obj0) {
33566 {
33567 arg1 = wxString_in_helper(obj0);
33568 if (arg1 == NULL) SWIG_fail;
33569 temp1 = true;
33570 }
33571 }
33572 {
33573 PyThreadState* __tstate = wxPyBeginAllowThreads();
33574 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33575 wxPyEndAllowThreads(__tstate);
33576 if (PyErr_Occurred()) SWIG_fail;
33577 }
33578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33579 {
33580 if (temp1)
33581 delete arg1;
33582 }
33583 return resultobj;
33584 fail:
33585 {
33586 if (temp1)
33587 delete arg1;
33588 }
33589 return NULL;
33590 }
33591
33592
33593 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33594 PyObject *resultobj = 0;
33595 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33596 wxString result;
33597 void *argp1 = 0 ;
33598 int res1 = 0 ;
33599 PyObject *swig_obj[1] ;
33600
33601 if (!args) SWIG_fail;
33602 swig_obj[0] = args;
33603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33604 if (!SWIG_IsOK(res1)) {
33605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33606 }
33607 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33608 {
33609 PyThreadState* __tstate = wxPyBeginAllowThreads();
33610 result = (arg1)->GetURL();
33611 wxPyEndAllowThreads(__tstate);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 }
33614 {
33615 #if wxUSE_UNICODE
33616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33617 #else
33618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33619 #endif
33620 }
33621 return resultobj;
33622 fail:
33623 return NULL;
33624 }
33625
33626
33627 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33628 PyObject *resultobj = 0;
33629 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33630 wxString *arg2 = 0 ;
33631 void *argp1 = 0 ;
33632 int res1 = 0 ;
33633 bool temp2 = false ;
33634 PyObject * obj0 = 0 ;
33635 PyObject * obj1 = 0 ;
33636 char * kwnames[] = {
33637 (char *) "self",(char *) "url", NULL
33638 };
33639
33640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33642 if (!SWIG_IsOK(res1)) {
33643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33644 }
33645 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33646 {
33647 arg2 = wxString_in_helper(obj1);
33648 if (arg2 == NULL) SWIG_fail;
33649 temp2 = true;
33650 }
33651 {
33652 PyThreadState* __tstate = wxPyBeginAllowThreads();
33653 (arg1)->SetURL((wxString const &)*arg2);
33654 wxPyEndAllowThreads(__tstate);
33655 if (PyErr_Occurred()) SWIG_fail;
33656 }
33657 resultobj = SWIG_Py_Void();
33658 {
33659 if (temp2)
33660 delete arg2;
33661 }
33662 return resultobj;
33663 fail:
33664 {
33665 if (temp2)
33666 delete arg2;
33667 }
33668 return NULL;
33669 }
33670
33671
33672 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33673 PyObject *obj;
33674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33675 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33676 return SWIG_Py_Void();
33677 }
33678
33679 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33680 return SWIG_Python_InitShadowInstance(args);
33681 }
33682
33683 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33684 PyObject *resultobj = 0;
33685 wxMetafileDataObject *result = 0 ;
33686
33687 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33688 {
33689 PyThreadState* __tstate = wxPyBeginAllowThreads();
33690 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33691 wxPyEndAllowThreads(__tstate);
33692 if (PyErr_Occurred()) SWIG_fail;
33693 }
33694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33695 return resultobj;
33696 fail:
33697 return NULL;
33698 }
33699
33700
33701 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33702 PyObject *resultobj = 0;
33703 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33704 wxMetafile *arg2 = 0 ;
33705 void *argp1 = 0 ;
33706 int res1 = 0 ;
33707 void *argp2 = 0 ;
33708 int res2 = 0 ;
33709 PyObject * obj0 = 0 ;
33710 PyObject * obj1 = 0 ;
33711 char * kwnames[] = {
33712 (char *) "self",(char *) "metafile", NULL
33713 };
33714
33715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33717 if (!SWIG_IsOK(res1)) {
33718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33719 }
33720 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33722 if (!SWIG_IsOK(res2)) {
33723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33724 }
33725 if (!argp2) {
33726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33727 }
33728 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33729 {
33730 PyThreadState* __tstate = wxPyBeginAllowThreads();
33731 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33732 wxPyEndAllowThreads(__tstate);
33733 if (PyErr_Occurred()) SWIG_fail;
33734 }
33735 resultobj = SWIG_Py_Void();
33736 return resultobj;
33737 fail:
33738 return NULL;
33739 }
33740
33741
33742 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33743 PyObject *resultobj = 0;
33744 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33745 wxMetafile result;
33746 void *argp1 = 0 ;
33747 int res1 = 0 ;
33748 PyObject *swig_obj[1] ;
33749
33750 if (!args) SWIG_fail;
33751 swig_obj[0] = args;
33752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33753 if (!SWIG_IsOK(res1)) {
33754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33755 }
33756 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33757 {
33758 PyThreadState* __tstate = wxPyBeginAllowThreads();
33759 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33760 wxPyEndAllowThreads(__tstate);
33761 if (PyErr_Occurred()) SWIG_fail;
33762 }
33763 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33764 return resultobj;
33765 fail:
33766 return NULL;
33767 }
33768
33769
33770 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33771 PyObject *obj;
33772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33773 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33774 return SWIG_Py_Void();
33775 }
33776
33777 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33778 return SWIG_Python_InitShadowInstance(args);
33779 }
33780
33781 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33782 PyObject *resultobj = 0;
33783 wxDragResult arg1 ;
33784 bool result;
33785 int val1 ;
33786 int ecode1 = 0 ;
33787 PyObject * obj0 = 0 ;
33788 char * kwnames[] = {
33789 (char *) "res", NULL
33790 };
33791
33792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33793 ecode1 = SWIG_AsVal_int(obj0, &val1);
33794 if (!SWIG_IsOK(ecode1)) {
33795 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33796 }
33797 arg1 = static_cast< wxDragResult >(val1);
33798 {
33799 PyThreadState* __tstate = wxPyBeginAllowThreads();
33800 result = (bool)wxIsDragResultOk(arg1);
33801 wxPyEndAllowThreads(__tstate);
33802 if (PyErr_Occurred()) SWIG_fail;
33803 }
33804 {
33805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33806 }
33807 return resultobj;
33808 fail:
33809 return NULL;
33810 }
33811
33812
33813 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33814 PyObject *resultobj = 0;
33815 wxWindow *arg1 = (wxWindow *) 0 ;
33816 wxCursor const &arg2_defvalue = wxNullCursor ;
33817 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33818 wxCursor const &arg3_defvalue = wxNullCursor ;
33819 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33820 wxCursor const &arg4_defvalue = wxNullCursor ;
33821 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33822 wxPyDropSource *result = 0 ;
33823 void *argp1 = 0 ;
33824 int res1 = 0 ;
33825 void *argp2 = 0 ;
33826 int res2 = 0 ;
33827 void *argp3 = 0 ;
33828 int res3 = 0 ;
33829 void *argp4 = 0 ;
33830 int res4 = 0 ;
33831 PyObject * obj0 = 0 ;
33832 PyObject * obj1 = 0 ;
33833 PyObject * obj2 = 0 ;
33834 PyObject * obj3 = 0 ;
33835 char * kwnames[] = {
33836 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33837 };
33838
33839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33841 if (!SWIG_IsOK(res1)) {
33842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33843 }
33844 arg1 = reinterpret_cast< wxWindow * >(argp1);
33845 if (obj1) {
33846 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33847 if (!SWIG_IsOK(res2)) {
33848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33849 }
33850 if (!argp2) {
33851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33852 }
33853 arg2 = reinterpret_cast< wxCursor * >(argp2);
33854 }
33855 if (obj2) {
33856 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33857 if (!SWIG_IsOK(res3)) {
33858 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33859 }
33860 if (!argp3) {
33861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33862 }
33863 arg3 = reinterpret_cast< wxCursor * >(argp3);
33864 }
33865 if (obj3) {
33866 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33867 if (!SWIG_IsOK(res4)) {
33868 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33869 }
33870 if (!argp4) {
33871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33872 }
33873 arg4 = reinterpret_cast< wxCursor * >(argp4);
33874 }
33875 {
33876 PyThreadState* __tstate = wxPyBeginAllowThreads();
33877 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33878 wxPyEndAllowThreads(__tstate);
33879 if (PyErr_Occurred()) SWIG_fail;
33880 }
33881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33882 return resultobj;
33883 fail:
33884 return NULL;
33885 }
33886
33887
33888 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33889 PyObject *resultobj = 0;
33890 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33891 PyObject *arg2 = (PyObject *) 0 ;
33892 PyObject *arg3 = (PyObject *) 0 ;
33893 int arg4 = (int) 0 ;
33894 void *argp1 = 0 ;
33895 int res1 = 0 ;
33896 int val4 ;
33897 int ecode4 = 0 ;
33898 PyObject * obj0 = 0 ;
33899 PyObject * obj1 = 0 ;
33900 PyObject * obj2 = 0 ;
33901 PyObject * obj3 = 0 ;
33902 char * kwnames[] = {
33903 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33904 };
33905
33906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33908 if (!SWIG_IsOK(res1)) {
33909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33910 }
33911 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33912 arg2 = obj1;
33913 arg3 = obj2;
33914 if (obj3) {
33915 ecode4 = SWIG_AsVal_int(obj3, &val4);
33916 if (!SWIG_IsOK(ecode4)) {
33917 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33918 }
33919 arg4 = static_cast< int >(val4);
33920 }
33921 {
33922 PyThreadState* __tstate = wxPyBeginAllowThreads();
33923 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33924 wxPyEndAllowThreads(__tstate);
33925 if (PyErr_Occurred()) SWIG_fail;
33926 }
33927 resultobj = SWIG_Py_Void();
33928 return resultobj;
33929 fail:
33930 return NULL;
33931 }
33932
33933
33934 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33935 PyObject *resultobj = 0;
33936 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33937 void *argp1 = 0 ;
33938 int res1 = 0 ;
33939 PyObject *swig_obj[1] ;
33940
33941 if (!args) SWIG_fail;
33942 swig_obj[0] = args;
33943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33944 if (!SWIG_IsOK(res1)) {
33945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33946 }
33947 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33948 {
33949 PyThreadState* __tstate = wxPyBeginAllowThreads();
33950 delete arg1;
33951
33952 wxPyEndAllowThreads(__tstate);
33953 if (PyErr_Occurred()) SWIG_fail;
33954 }
33955 resultobj = SWIG_Py_Void();
33956 return resultobj;
33957 fail:
33958 return NULL;
33959 }
33960
33961
33962 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33963 PyObject *resultobj = 0;
33964 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33965 wxDataObject *arg2 = 0 ;
33966 void *argp1 = 0 ;
33967 int res1 = 0 ;
33968 void *argp2 = 0 ;
33969 int res2 = 0 ;
33970 PyObject * obj0 = 0 ;
33971 PyObject * obj1 = 0 ;
33972 char * kwnames[] = {
33973 (char *) "self",(char *) "data", NULL
33974 };
33975
33976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33978 if (!SWIG_IsOK(res1)) {
33979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33980 }
33981 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33982 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33983 if (!SWIG_IsOK(res2)) {
33984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33985 }
33986 if (!argp2) {
33987 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33988 }
33989 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33990 {
33991 PyThreadState* __tstate = wxPyBeginAllowThreads();
33992 (arg1)->SetData(*arg2);
33993 wxPyEndAllowThreads(__tstate);
33994 if (PyErr_Occurred()) SWIG_fail;
33995 }
33996 resultobj = SWIG_Py_Void();
33997 return resultobj;
33998 fail:
33999 return NULL;
34000 }
34001
34002
34003 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34004 PyObject *resultobj = 0;
34005 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34006 wxDataObject *result = 0 ;
34007 void *argp1 = 0 ;
34008 int res1 = 0 ;
34009 PyObject *swig_obj[1] ;
34010
34011 if (!args) SWIG_fail;
34012 swig_obj[0] = args;
34013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34014 if (!SWIG_IsOK(res1)) {
34015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34016 }
34017 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34018 {
34019 PyThreadState* __tstate = wxPyBeginAllowThreads();
34020 result = (wxDataObject *)(arg1)->GetDataObject();
34021 wxPyEndAllowThreads(__tstate);
34022 if (PyErr_Occurred()) SWIG_fail;
34023 }
34024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34025 return resultobj;
34026 fail:
34027 return NULL;
34028 }
34029
34030
34031 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34032 PyObject *resultobj = 0;
34033 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34034 wxDragResult arg2 ;
34035 wxCursor *arg3 = 0 ;
34036 void *argp1 = 0 ;
34037 int res1 = 0 ;
34038 int val2 ;
34039 int ecode2 = 0 ;
34040 void *argp3 = 0 ;
34041 int res3 = 0 ;
34042 PyObject * obj0 = 0 ;
34043 PyObject * obj1 = 0 ;
34044 PyObject * obj2 = 0 ;
34045 char * kwnames[] = {
34046 (char *) "self",(char *) "res",(char *) "cursor", NULL
34047 };
34048
34049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34051 if (!SWIG_IsOK(res1)) {
34052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34053 }
34054 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34055 ecode2 = SWIG_AsVal_int(obj1, &val2);
34056 if (!SWIG_IsOK(ecode2)) {
34057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34058 }
34059 arg2 = static_cast< wxDragResult >(val2);
34060 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34061 if (!SWIG_IsOK(res3)) {
34062 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34063 }
34064 if (!argp3) {
34065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34066 }
34067 arg3 = reinterpret_cast< wxCursor * >(argp3);
34068 {
34069 PyThreadState* __tstate = wxPyBeginAllowThreads();
34070 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34071 wxPyEndAllowThreads(__tstate);
34072 if (PyErr_Occurred()) SWIG_fail;
34073 }
34074 resultobj = SWIG_Py_Void();
34075 return resultobj;
34076 fail:
34077 return NULL;
34078 }
34079
34080
34081 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34082 PyObject *resultobj = 0;
34083 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34084 int arg2 = (int) wxDrag_CopyOnly ;
34085 wxDragResult result;
34086 void *argp1 = 0 ;
34087 int res1 = 0 ;
34088 int val2 ;
34089 int ecode2 = 0 ;
34090 PyObject * obj0 = 0 ;
34091 PyObject * obj1 = 0 ;
34092 char * kwnames[] = {
34093 (char *) "self",(char *) "flags", NULL
34094 };
34095
34096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34098 if (!SWIG_IsOK(res1)) {
34099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34100 }
34101 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34102 if (obj1) {
34103 ecode2 = SWIG_AsVal_int(obj1, &val2);
34104 if (!SWIG_IsOK(ecode2)) {
34105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34106 }
34107 arg2 = static_cast< int >(val2);
34108 }
34109 {
34110 PyThreadState* __tstate = wxPyBeginAllowThreads();
34111 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34112 wxPyEndAllowThreads(__tstate);
34113 if (PyErr_Occurred()) SWIG_fail;
34114 }
34115 resultobj = SWIG_From_int(static_cast< int >(result));
34116 return resultobj;
34117 fail:
34118 return NULL;
34119 }
34120
34121
34122 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34123 PyObject *resultobj = 0;
34124 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34125 wxDragResult arg2 ;
34126 bool result;
34127 void *argp1 = 0 ;
34128 int res1 = 0 ;
34129 int val2 ;
34130 int ecode2 = 0 ;
34131 PyObject * obj0 = 0 ;
34132 PyObject * obj1 = 0 ;
34133 char * kwnames[] = {
34134 (char *) "self",(char *) "effect", NULL
34135 };
34136
34137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34139 if (!SWIG_IsOK(res1)) {
34140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34141 }
34142 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34143 ecode2 = SWIG_AsVal_int(obj1, &val2);
34144 if (!SWIG_IsOK(ecode2)) {
34145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34146 }
34147 arg2 = static_cast< wxDragResult >(val2);
34148 {
34149 PyThreadState* __tstate = wxPyBeginAllowThreads();
34150 result = (bool)(arg1)->GiveFeedback(arg2);
34151 wxPyEndAllowThreads(__tstate);
34152 if (PyErr_Occurred()) SWIG_fail;
34153 }
34154 {
34155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34156 }
34157 return resultobj;
34158 fail:
34159 return NULL;
34160 }
34161
34162
34163 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34164 PyObject *obj;
34165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34166 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34167 return SWIG_Py_Void();
34168 }
34169
34170 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34171 return SWIG_Python_InitShadowInstance(args);
34172 }
34173
34174 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34175 PyObject *resultobj = 0;
34176 wxDataObject *arg1 = (wxDataObject *) NULL ;
34177 wxPyDropTarget *result = 0 ;
34178 int res1 = 0 ;
34179 PyObject * obj0 = 0 ;
34180 char * kwnames[] = {
34181 (char *) "dataObject", NULL
34182 };
34183
34184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34185 if (obj0) {
34186 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34187 if (!SWIG_IsOK(res1)) {
34188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34189 }
34190 }
34191 {
34192 PyThreadState* __tstate = wxPyBeginAllowThreads();
34193 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34194 wxPyEndAllowThreads(__tstate);
34195 if (PyErr_Occurred()) SWIG_fail;
34196 }
34197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34198 return resultobj;
34199 fail:
34200 return NULL;
34201 }
34202
34203
34204 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34205 PyObject *resultobj = 0;
34206 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34207 PyObject *arg2 = (PyObject *) 0 ;
34208 PyObject *arg3 = (PyObject *) 0 ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 PyObject * obj0 = 0 ;
34212 PyObject * obj1 = 0 ;
34213 PyObject * obj2 = 0 ;
34214 char * kwnames[] = {
34215 (char *) "self",(char *) "self",(char *) "_class", NULL
34216 };
34217
34218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34220 if (!SWIG_IsOK(res1)) {
34221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34222 }
34223 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34224 arg2 = obj1;
34225 arg3 = obj2;
34226 {
34227 PyThreadState* __tstate = wxPyBeginAllowThreads();
34228 (arg1)->_setCallbackInfo(arg2,arg3);
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 resultobj = SWIG_Py_Void();
34233 return resultobj;
34234 fail:
34235 return NULL;
34236 }
34237
34238
34239 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34240 PyObject *resultobj = 0;
34241 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34242 void *argp1 = 0 ;
34243 int res1 = 0 ;
34244 PyObject *swig_obj[1] ;
34245
34246 if (!args) SWIG_fail;
34247 swig_obj[0] = args;
34248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34251 }
34252 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34253 {
34254 PyThreadState* __tstate = wxPyBeginAllowThreads();
34255 delete arg1;
34256
34257 wxPyEndAllowThreads(__tstate);
34258 if (PyErr_Occurred()) SWIG_fail;
34259 }
34260 resultobj = SWIG_Py_Void();
34261 return resultobj;
34262 fail:
34263 return NULL;
34264 }
34265
34266
34267 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34268 PyObject *resultobj = 0;
34269 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34270 wxDataObject *result = 0 ;
34271 void *argp1 = 0 ;
34272 int res1 = 0 ;
34273 PyObject *swig_obj[1] ;
34274
34275 if (!args) SWIG_fail;
34276 swig_obj[0] = args;
34277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34278 if (!SWIG_IsOK(res1)) {
34279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34280 }
34281 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34282 {
34283 PyThreadState* __tstate = wxPyBeginAllowThreads();
34284 result = (wxDataObject *)(arg1)->GetDataObject();
34285 wxPyEndAllowThreads(__tstate);
34286 if (PyErr_Occurred()) SWIG_fail;
34287 }
34288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34289 return resultobj;
34290 fail:
34291 return NULL;
34292 }
34293
34294
34295 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34296 PyObject *resultobj = 0;
34297 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34298 wxDataObject *arg2 = (wxDataObject *) 0 ;
34299 void *argp1 = 0 ;
34300 int res1 = 0 ;
34301 int res2 = 0 ;
34302 PyObject * obj0 = 0 ;
34303 PyObject * obj1 = 0 ;
34304 char * kwnames[] = {
34305 (char *) "self",(char *) "dataObject", NULL
34306 };
34307
34308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34310 if (!SWIG_IsOK(res1)) {
34311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34312 }
34313 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34314 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34315 if (!SWIG_IsOK(res2)) {
34316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34317 }
34318 {
34319 PyThreadState* __tstate = wxPyBeginAllowThreads();
34320 (arg1)->SetDataObject(arg2);
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 resultobj = SWIG_Py_Void();
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34332 PyObject *resultobj = 0;
34333 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34334 int arg2 ;
34335 int arg3 ;
34336 wxDragResult arg4 ;
34337 wxDragResult result;
34338 void *argp1 = 0 ;
34339 int res1 = 0 ;
34340 int val2 ;
34341 int ecode2 = 0 ;
34342 int val3 ;
34343 int ecode3 = 0 ;
34344 int val4 ;
34345 int ecode4 = 0 ;
34346 PyObject * obj0 = 0 ;
34347 PyObject * obj1 = 0 ;
34348 PyObject * obj2 = 0 ;
34349 PyObject * obj3 = 0 ;
34350 char * kwnames[] = {
34351 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34352 };
34353
34354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_OnEnter" "', 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_OnEnter" "', 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_OnEnter" "', expected argument " "3"" of type '" "int""'");
34368 }
34369 arg3 = static_cast< int >(val3);
34370 ecode4 = SWIG_AsVal_int(obj3, &val4);
34371 if (!SWIG_IsOK(ecode4)) {
34372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34373 }
34374 arg4 = static_cast< wxDragResult >(val4);
34375 {
34376 PyThreadState* __tstate = wxPyBeginAllowThreads();
34377 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34378 wxPyEndAllowThreads(__tstate);
34379 if (PyErr_Occurred()) SWIG_fail;
34380 }
34381 resultobj = SWIG_From_int(static_cast< int >(result));
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34389 PyObject *resultobj = 0;
34390 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34391 int arg2 ;
34392 int arg3 ;
34393 wxDragResult arg4 ;
34394 wxDragResult result;
34395 void *argp1 = 0 ;
34396 int res1 = 0 ;
34397 int val2 ;
34398 int ecode2 = 0 ;
34399 int val3 ;
34400 int ecode3 = 0 ;
34401 int val4 ;
34402 int ecode4 = 0 ;
34403 PyObject * obj0 = 0 ;
34404 PyObject * obj1 = 0 ;
34405 PyObject * obj2 = 0 ;
34406 PyObject * obj3 = 0 ;
34407 char * kwnames[] = {
34408 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34409 };
34410
34411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34413 if (!SWIG_IsOK(res1)) {
34414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34415 }
34416 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34417 ecode2 = SWIG_AsVal_int(obj1, &val2);
34418 if (!SWIG_IsOK(ecode2)) {
34419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34420 }
34421 arg2 = static_cast< int >(val2);
34422 ecode3 = SWIG_AsVal_int(obj2, &val3);
34423 if (!SWIG_IsOK(ecode3)) {
34424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34425 }
34426 arg3 = static_cast< int >(val3);
34427 ecode4 = SWIG_AsVal_int(obj3, &val4);
34428 if (!SWIG_IsOK(ecode4)) {
34429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34430 }
34431 arg4 = static_cast< wxDragResult >(val4);
34432 {
34433 PyThreadState* __tstate = wxPyBeginAllowThreads();
34434 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34435 wxPyEndAllowThreads(__tstate);
34436 if (PyErr_Occurred()) SWIG_fail;
34437 }
34438 resultobj = SWIG_From_int(static_cast< int >(result));
34439 return resultobj;
34440 fail:
34441 return NULL;
34442 }
34443
34444
34445 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34446 PyObject *resultobj = 0;
34447 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34448 void *argp1 = 0 ;
34449 int res1 = 0 ;
34450 PyObject *swig_obj[1] ;
34451
34452 if (!args) SWIG_fail;
34453 swig_obj[0] = args;
34454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34455 if (!SWIG_IsOK(res1)) {
34456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34457 }
34458 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34459 {
34460 PyThreadState* __tstate = wxPyBeginAllowThreads();
34461 (arg1)->OnLeave();
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 resultobj = SWIG_Py_Void();
34466 return resultobj;
34467 fail:
34468 return NULL;
34469 }
34470
34471
34472 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34473 PyObject *resultobj = 0;
34474 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34475 int arg2 ;
34476 int arg3 ;
34477 bool result;
34478 void *argp1 = 0 ;
34479 int res1 = 0 ;
34480 int val2 ;
34481 int ecode2 = 0 ;
34482 int val3 ;
34483 int ecode3 = 0 ;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 PyObject * obj2 = 0 ;
34487 char * kwnames[] = {
34488 (char *) "self",(char *) "x",(char *) "y", NULL
34489 };
34490
34491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34493 if (!SWIG_IsOK(res1)) {
34494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34495 }
34496 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34497 ecode2 = SWIG_AsVal_int(obj1, &val2);
34498 if (!SWIG_IsOK(ecode2)) {
34499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34500 }
34501 arg2 = static_cast< int >(val2);
34502 ecode3 = SWIG_AsVal_int(obj2, &val3);
34503 if (!SWIG_IsOK(ecode3)) {
34504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34505 }
34506 arg3 = static_cast< int >(val3);
34507 {
34508 PyThreadState* __tstate = wxPyBeginAllowThreads();
34509 result = (bool)(arg1)->OnDrop(arg2,arg3);
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 {
34514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34515 }
34516 return resultobj;
34517 fail:
34518 return NULL;
34519 }
34520
34521
34522 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34523 PyObject *resultobj = 0;
34524 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34525 bool result;
34526 void *argp1 = 0 ;
34527 int res1 = 0 ;
34528 PyObject *swig_obj[1] ;
34529
34530 if (!args) SWIG_fail;
34531 swig_obj[0] = args;
34532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34533 if (!SWIG_IsOK(res1)) {
34534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34535 }
34536 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34537 {
34538 PyThreadState* __tstate = wxPyBeginAllowThreads();
34539 result = (bool)(arg1)->GetData();
34540 wxPyEndAllowThreads(__tstate);
34541 if (PyErr_Occurred()) SWIG_fail;
34542 }
34543 {
34544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34545 }
34546 return resultobj;
34547 fail:
34548 return NULL;
34549 }
34550
34551
34552 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34553 PyObject *resultobj = 0;
34554 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34555 wxDragResult arg2 ;
34556 void *argp1 = 0 ;
34557 int res1 = 0 ;
34558 int val2 ;
34559 int ecode2 = 0 ;
34560 PyObject * obj0 = 0 ;
34561 PyObject * obj1 = 0 ;
34562 char * kwnames[] = {
34563 (char *) "self",(char *) "action", NULL
34564 };
34565
34566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34568 if (!SWIG_IsOK(res1)) {
34569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34570 }
34571 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34572 ecode2 = SWIG_AsVal_int(obj1, &val2);
34573 if (!SWIG_IsOK(ecode2)) {
34574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34575 }
34576 arg2 = static_cast< wxDragResult >(val2);
34577 {
34578 PyThreadState* __tstate = wxPyBeginAllowThreads();
34579 (arg1)->SetDefaultAction(arg2);
34580 wxPyEndAllowThreads(__tstate);
34581 if (PyErr_Occurred()) SWIG_fail;
34582 }
34583 resultobj = SWIG_Py_Void();
34584 return resultobj;
34585 fail:
34586 return NULL;
34587 }
34588
34589
34590 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34591 PyObject *resultobj = 0;
34592 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34593 wxDragResult result;
34594 void *argp1 = 0 ;
34595 int res1 = 0 ;
34596 PyObject *swig_obj[1] ;
34597
34598 if (!args) SWIG_fail;
34599 swig_obj[0] = args;
34600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34601 if (!SWIG_IsOK(res1)) {
34602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34603 }
34604 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34605 {
34606 PyThreadState* __tstate = wxPyBeginAllowThreads();
34607 result = (wxDragResult)(arg1)->GetDefaultAction();
34608 wxPyEndAllowThreads(__tstate);
34609 if (PyErr_Occurred()) SWIG_fail;
34610 }
34611 resultobj = SWIG_From_int(static_cast< int >(result));
34612 return resultobj;
34613 fail:
34614 return NULL;
34615 }
34616
34617
34618 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34619 PyObject *obj;
34620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34621 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34622 return SWIG_Py_Void();
34623 }
34624
34625 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34626 return SWIG_Python_InitShadowInstance(args);
34627 }
34628
34629 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34630 PyObject *resultobj = 0;
34631 wxPyTextDropTarget *result = 0 ;
34632
34633 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34634 {
34635 PyThreadState* __tstate = wxPyBeginAllowThreads();
34636 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34637 wxPyEndAllowThreads(__tstate);
34638 if (PyErr_Occurred()) SWIG_fail;
34639 }
34640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34641 return resultobj;
34642 fail:
34643 return NULL;
34644 }
34645
34646
34647 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34648 PyObject *resultobj = 0;
34649 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34650 PyObject *arg2 = (PyObject *) 0 ;
34651 PyObject *arg3 = (PyObject *) 0 ;
34652 void *argp1 = 0 ;
34653 int res1 = 0 ;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 PyObject * obj2 = 0 ;
34657 char * kwnames[] = {
34658 (char *) "self",(char *) "self",(char *) "_class", NULL
34659 };
34660
34661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34663 if (!SWIG_IsOK(res1)) {
34664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34665 }
34666 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34667 arg2 = obj1;
34668 arg3 = obj2;
34669 {
34670 PyThreadState* __tstate = wxPyBeginAllowThreads();
34671 (arg1)->_setCallbackInfo(arg2,arg3);
34672 wxPyEndAllowThreads(__tstate);
34673 if (PyErr_Occurred()) SWIG_fail;
34674 }
34675 resultobj = SWIG_Py_Void();
34676 return resultobj;
34677 fail:
34678 return NULL;
34679 }
34680
34681
34682 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34683 PyObject *resultobj = 0;
34684 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34685 int arg2 ;
34686 int arg3 ;
34687 wxString *arg4 = 0 ;
34688 bool result;
34689 void *argp1 = 0 ;
34690 int res1 = 0 ;
34691 int val2 ;
34692 int ecode2 = 0 ;
34693 int val3 ;
34694 int ecode3 = 0 ;
34695 bool temp4 = false ;
34696 PyObject * obj0 = 0 ;
34697 PyObject * obj1 = 0 ;
34698 PyObject * obj2 = 0 ;
34699 PyObject * obj3 = 0 ;
34700 char * kwnames[] = {
34701 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34702 };
34703
34704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34706 if (!SWIG_IsOK(res1)) {
34707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34708 }
34709 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34710 ecode2 = SWIG_AsVal_int(obj1, &val2);
34711 if (!SWIG_IsOK(ecode2)) {
34712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34713 }
34714 arg2 = static_cast< int >(val2);
34715 ecode3 = SWIG_AsVal_int(obj2, &val3);
34716 if (!SWIG_IsOK(ecode3)) {
34717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34718 }
34719 arg3 = static_cast< int >(val3);
34720 {
34721 arg4 = wxString_in_helper(obj3);
34722 if (arg4 == NULL) SWIG_fail;
34723 temp4 = true;
34724 }
34725 {
34726 PyThreadState* __tstate = wxPyBeginAllowThreads();
34727 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34728 wxPyEndAllowThreads(__tstate);
34729 if (PyErr_Occurred()) SWIG_fail;
34730 }
34731 {
34732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34733 }
34734 {
34735 if (temp4)
34736 delete arg4;
34737 }
34738 return resultobj;
34739 fail:
34740 {
34741 if (temp4)
34742 delete arg4;
34743 }
34744 return NULL;
34745 }
34746
34747
34748 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34749 PyObject *resultobj = 0;
34750 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34751 int arg2 ;
34752 int arg3 ;
34753 wxDragResult arg4 ;
34754 wxDragResult result;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 int val2 ;
34758 int ecode2 = 0 ;
34759 int val3 ;
34760 int ecode3 = 0 ;
34761 int val4 ;
34762 int ecode4 = 0 ;
34763 PyObject * obj0 = 0 ;
34764 PyObject * obj1 = 0 ;
34765 PyObject * obj2 = 0 ;
34766 PyObject * obj3 = 0 ;
34767 char * kwnames[] = {
34768 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34769 };
34770
34771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_OnEnter" "', 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_OnEnter" "', 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_OnEnter" "', expected argument " "3"" of type '" "int""'");
34785 }
34786 arg3 = static_cast< int >(val3);
34787 ecode4 = SWIG_AsVal_int(obj3, &val4);
34788 if (!SWIG_IsOK(ecode4)) {
34789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34790 }
34791 arg4 = static_cast< wxDragResult >(val4);
34792 {
34793 PyThreadState* __tstate = wxPyBeginAllowThreads();
34794 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34795 wxPyEndAllowThreads(__tstate);
34796 if (PyErr_Occurred()) SWIG_fail;
34797 }
34798 resultobj = SWIG_From_int(static_cast< int >(result));
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34806 PyObject *resultobj = 0;
34807 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34808 int arg2 ;
34809 int arg3 ;
34810 wxDragResult arg4 ;
34811 wxDragResult result;
34812 void *argp1 = 0 ;
34813 int res1 = 0 ;
34814 int val2 ;
34815 int ecode2 = 0 ;
34816 int val3 ;
34817 int ecode3 = 0 ;
34818 int val4 ;
34819 int ecode4 = 0 ;
34820 PyObject * obj0 = 0 ;
34821 PyObject * obj1 = 0 ;
34822 PyObject * obj2 = 0 ;
34823 PyObject * obj3 = 0 ;
34824 char * kwnames[] = {
34825 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34826 };
34827
34828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34830 if (!SWIG_IsOK(res1)) {
34831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34832 }
34833 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34834 ecode2 = SWIG_AsVal_int(obj1, &val2);
34835 if (!SWIG_IsOK(ecode2)) {
34836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34837 }
34838 arg2 = static_cast< int >(val2);
34839 ecode3 = SWIG_AsVal_int(obj2, &val3);
34840 if (!SWIG_IsOK(ecode3)) {
34841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34842 }
34843 arg3 = static_cast< int >(val3);
34844 ecode4 = SWIG_AsVal_int(obj3, &val4);
34845 if (!SWIG_IsOK(ecode4)) {
34846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34847 }
34848 arg4 = static_cast< wxDragResult >(val4);
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34852 wxPyEndAllowThreads(__tstate);
34853 if (PyErr_Occurred()) SWIG_fail;
34854 }
34855 resultobj = SWIG_From_int(static_cast< int >(result));
34856 return resultobj;
34857 fail:
34858 return NULL;
34859 }
34860
34861
34862 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34863 PyObject *resultobj = 0;
34864 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34865 void *argp1 = 0 ;
34866 int res1 = 0 ;
34867 PyObject *swig_obj[1] ;
34868
34869 if (!args) SWIG_fail;
34870 swig_obj[0] = args;
34871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34872 if (!SWIG_IsOK(res1)) {
34873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34874 }
34875 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 (arg1)->OnLeave();
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 resultobj = SWIG_Py_Void();
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34890 PyObject *resultobj = 0;
34891 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34892 int arg2 ;
34893 int arg3 ;
34894 bool result;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 int val2 ;
34898 int ecode2 = 0 ;
34899 int val3 ;
34900 int ecode3 = 0 ;
34901 PyObject * obj0 = 0 ;
34902 PyObject * obj1 = 0 ;
34903 PyObject * obj2 = 0 ;
34904 char * kwnames[] = {
34905 (char *) "self",(char *) "x",(char *) "y", NULL
34906 };
34907
34908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34910 if (!SWIG_IsOK(res1)) {
34911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34912 }
34913 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34914 ecode2 = SWIG_AsVal_int(obj1, &val2);
34915 if (!SWIG_IsOK(ecode2)) {
34916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34917 }
34918 arg2 = static_cast< int >(val2);
34919 ecode3 = SWIG_AsVal_int(obj2, &val3);
34920 if (!SWIG_IsOK(ecode3)) {
34921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34922 }
34923 arg3 = static_cast< int >(val3);
34924 {
34925 PyThreadState* __tstate = wxPyBeginAllowThreads();
34926 result = (bool)(arg1)->OnDrop(arg2,arg3);
34927 wxPyEndAllowThreads(__tstate);
34928 if (PyErr_Occurred()) SWIG_fail;
34929 }
34930 {
34931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34932 }
34933 return resultobj;
34934 fail:
34935 return NULL;
34936 }
34937
34938
34939 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34940 PyObject *resultobj = 0;
34941 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34942 int arg2 ;
34943 int arg3 ;
34944 wxDragResult arg4 ;
34945 wxDragResult result;
34946 void *argp1 = 0 ;
34947 int res1 = 0 ;
34948 int val2 ;
34949 int ecode2 = 0 ;
34950 int val3 ;
34951 int ecode3 = 0 ;
34952 int val4 ;
34953 int ecode4 = 0 ;
34954 PyObject * obj0 = 0 ;
34955 PyObject * obj1 = 0 ;
34956 PyObject * obj2 = 0 ;
34957 PyObject * obj3 = 0 ;
34958 char * kwnames[] = {
34959 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34960 };
34961
34962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34964 if (!SWIG_IsOK(res1)) {
34965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34966 }
34967 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34968 ecode2 = SWIG_AsVal_int(obj1, &val2);
34969 if (!SWIG_IsOK(ecode2)) {
34970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34971 }
34972 arg2 = static_cast< int >(val2);
34973 ecode3 = SWIG_AsVal_int(obj2, &val3);
34974 if (!SWIG_IsOK(ecode3)) {
34975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34976 }
34977 arg3 = static_cast< int >(val3);
34978 ecode4 = SWIG_AsVal_int(obj3, &val4);
34979 if (!SWIG_IsOK(ecode4)) {
34980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34981 }
34982 arg4 = static_cast< wxDragResult >(val4);
34983 {
34984 PyThreadState* __tstate = wxPyBeginAllowThreads();
34985 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34986 wxPyEndAllowThreads(__tstate);
34987 if (PyErr_Occurred()) SWIG_fail;
34988 }
34989 resultobj = SWIG_From_int(static_cast< int >(result));
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34997 PyObject *obj;
34998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34999 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
35000 return SWIG_Py_Void();
35001 }
35002
35003 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35004 return SWIG_Python_InitShadowInstance(args);
35005 }
35006
35007 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35008 PyObject *resultobj = 0;
35009 wxPyFileDropTarget *result = 0 ;
35010
35011 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
35012 {
35013 PyThreadState* __tstate = wxPyBeginAllowThreads();
35014 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
35015 wxPyEndAllowThreads(__tstate);
35016 if (PyErr_Occurred()) SWIG_fail;
35017 }
35018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
35019 return resultobj;
35020 fail:
35021 return NULL;
35022 }
35023
35024
35025 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35026 PyObject *resultobj = 0;
35027 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35028 PyObject *arg2 = (PyObject *) 0 ;
35029 PyObject *arg3 = (PyObject *) 0 ;
35030 void *argp1 = 0 ;
35031 int res1 = 0 ;
35032 PyObject * obj0 = 0 ;
35033 PyObject * obj1 = 0 ;
35034 PyObject * obj2 = 0 ;
35035 char * kwnames[] = {
35036 (char *) "self",(char *) "self",(char *) "_class", NULL
35037 };
35038
35039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35041 if (!SWIG_IsOK(res1)) {
35042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35043 }
35044 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35045 arg2 = obj1;
35046 arg3 = obj2;
35047 {
35048 PyThreadState* __tstate = wxPyBeginAllowThreads();
35049 (arg1)->_setCallbackInfo(arg2,arg3);
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 resultobj = SWIG_Py_Void();
35054 return resultobj;
35055 fail:
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35061 PyObject *resultobj = 0;
35062 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35063 int arg2 ;
35064 int arg3 ;
35065 wxArrayString *arg4 = 0 ;
35066 bool result;
35067 void *argp1 = 0 ;
35068 int res1 = 0 ;
35069 int val2 ;
35070 int ecode2 = 0 ;
35071 int val3 ;
35072 int ecode3 = 0 ;
35073 bool temp4 = false ;
35074 PyObject * obj0 = 0 ;
35075 PyObject * obj1 = 0 ;
35076 PyObject * obj2 = 0 ;
35077 PyObject * obj3 = 0 ;
35078 char * kwnames[] = {
35079 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35080 };
35081
35082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35084 if (!SWIG_IsOK(res1)) {
35085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35086 }
35087 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35088 ecode2 = SWIG_AsVal_int(obj1, &val2);
35089 if (!SWIG_IsOK(ecode2)) {
35090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35091 }
35092 arg2 = static_cast< int >(val2);
35093 ecode3 = SWIG_AsVal_int(obj2, &val3);
35094 if (!SWIG_IsOK(ecode3)) {
35095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35096 }
35097 arg3 = static_cast< int >(val3);
35098 {
35099 if (! PySequence_Check(obj3)) {
35100 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35101 SWIG_fail;
35102 }
35103 arg4 = new wxArrayString;
35104 temp4 = true;
35105 int i, len=PySequence_Length(obj3);
35106 for (i=0; i<len; i++) {
35107 PyObject* item = PySequence_GetItem(obj3, i);
35108 wxString* s = wxString_in_helper(item);
35109 if (PyErr_Occurred()) SWIG_fail;
35110 arg4->Add(*s);
35111 delete s;
35112 Py_DECREF(item);
35113 }
35114 }
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 {
35122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35123 }
35124 {
35125 if (temp4) delete arg4;
35126 }
35127 return resultobj;
35128 fail:
35129 {
35130 if (temp4) delete arg4;
35131 }
35132 return NULL;
35133 }
35134
35135
35136 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35137 PyObject *resultobj = 0;
35138 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35139 int arg2 ;
35140 int arg3 ;
35141 wxDragResult arg4 ;
35142 wxDragResult result;
35143 void *argp1 = 0 ;
35144 int res1 = 0 ;
35145 int val2 ;
35146 int ecode2 = 0 ;
35147 int val3 ;
35148 int ecode3 = 0 ;
35149 int val4 ;
35150 int ecode4 = 0 ;
35151 PyObject * obj0 = 0 ;
35152 PyObject * obj1 = 0 ;
35153 PyObject * obj2 = 0 ;
35154 PyObject * obj3 = 0 ;
35155 char * kwnames[] = {
35156 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35157 };
35158
35159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_OnEnter" "', 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_OnEnter" "', 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_OnEnter" "', expected argument " "3"" of type '" "int""'");
35173 }
35174 arg3 = static_cast< int >(val3);
35175 ecode4 = SWIG_AsVal_int(obj3, &val4);
35176 if (!SWIG_IsOK(ecode4)) {
35177 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35178 }
35179 arg4 = static_cast< wxDragResult >(val4);
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35183 wxPyEndAllowThreads(__tstate);
35184 if (PyErr_Occurred()) SWIG_fail;
35185 }
35186 resultobj = SWIG_From_int(static_cast< int >(result));
35187 return resultobj;
35188 fail:
35189 return NULL;
35190 }
35191
35192
35193 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35194 PyObject *resultobj = 0;
35195 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35196 int arg2 ;
35197 int arg3 ;
35198 wxDragResult arg4 ;
35199 wxDragResult result;
35200 void *argp1 = 0 ;
35201 int res1 = 0 ;
35202 int val2 ;
35203 int ecode2 = 0 ;
35204 int val3 ;
35205 int ecode3 = 0 ;
35206 int val4 ;
35207 int ecode4 = 0 ;
35208 PyObject * obj0 = 0 ;
35209 PyObject * obj1 = 0 ;
35210 PyObject * obj2 = 0 ;
35211 PyObject * obj3 = 0 ;
35212 char * kwnames[] = {
35213 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35214 };
35215
35216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35218 if (!SWIG_IsOK(res1)) {
35219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35220 }
35221 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35222 ecode2 = SWIG_AsVal_int(obj1, &val2);
35223 if (!SWIG_IsOK(ecode2)) {
35224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35225 }
35226 arg2 = static_cast< int >(val2);
35227 ecode3 = SWIG_AsVal_int(obj2, &val3);
35228 if (!SWIG_IsOK(ecode3)) {
35229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35230 }
35231 arg3 = static_cast< int >(val3);
35232 ecode4 = SWIG_AsVal_int(obj3, &val4);
35233 if (!SWIG_IsOK(ecode4)) {
35234 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35235 }
35236 arg4 = static_cast< wxDragResult >(val4);
35237 {
35238 PyThreadState* __tstate = wxPyBeginAllowThreads();
35239 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 resultobj = SWIG_From_int(static_cast< int >(result));
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35251 PyObject *resultobj = 0;
35252 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35253 void *argp1 = 0 ;
35254 int res1 = 0 ;
35255 PyObject *swig_obj[1] ;
35256
35257 if (!args) SWIG_fail;
35258 swig_obj[0] = args;
35259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35260 if (!SWIG_IsOK(res1)) {
35261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35262 }
35263 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35264 {
35265 PyThreadState* __tstate = wxPyBeginAllowThreads();
35266 (arg1)->OnLeave();
35267 wxPyEndAllowThreads(__tstate);
35268 if (PyErr_Occurred()) SWIG_fail;
35269 }
35270 resultobj = SWIG_Py_Void();
35271 return resultobj;
35272 fail:
35273 return NULL;
35274 }
35275
35276
35277 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35278 PyObject *resultobj = 0;
35279 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35280 int arg2 ;
35281 int arg3 ;
35282 bool result;
35283 void *argp1 = 0 ;
35284 int res1 = 0 ;
35285 int val2 ;
35286 int ecode2 = 0 ;
35287 int val3 ;
35288 int ecode3 = 0 ;
35289 PyObject * obj0 = 0 ;
35290 PyObject * obj1 = 0 ;
35291 PyObject * obj2 = 0 ;
35292 char * kwnames[] = {
35293 (char *) "self",(char *) "x",(char *) "y", NULL
35294 };
35295
35296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35298 if (!SWIG_IsOK(res1)) {
35299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35300 }
35301 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35302 ecode2 = SWIG_AsVal_int(obj1, &val2);
35303 if (!SWIG_IsOK(ecode2)) {
35304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35305 }
35306 arg2 = static_cast< int >(val2);
35307 ecode3 = SWIG_AsVal_int(obj2, &val3);
35308 if (!SWIG_IsOK(ecode3)) {
35309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35310 }
35311 arg3 = static_cast< int >(val3);
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = (bool)(arg1)->OnDrop(arg2,arg3);
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 {
35319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35320 }
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35328 PyObject *resultobj = 0;
35329 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35330 int arg2 ;
35331 int arg3 ;
35332 wxDragResult arg4 ;
35333 wxDragResult result;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 int val2 ;
35337 int ecode2 = 0 ;
35338 int val3 ;
35339 int ecode3 = 0 ;
35340 int val4 ;
35341 int ecode4 = 0 ;
35342 PyObject * obj0 = 0 ;
35343 PyObject * obj1 = 0 ;
35344 PyObject * obj2 = 0 ;
35345 PyObject * obj3 = 0 ;
35346 char * kwnames[] = {
35347 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35348 };
35349
35350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35352 if (!SWIG_IsOK(res1)) {
35353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35354 }
35355 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35356 ecode2 = SWIG_AsVal_int(obj1, &val2);
35357 if (!SWIG_IsOK(ecode2)) {
35358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35359 }
35360 arg2 = static_cast< int >(val2);
35361 ecode3 = SWIG_AsVal_int(obj2, &val3);
35362 if (!SWIG_IsOK(ecode3)) {
35363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35364 }
35365 arg3 = static_cast< int >(val3);
35366 ecode4 = SWIG_AsVal_int(obj3, &val4);
35367 if (!SWIG_IsOK(ecode4)) {
35368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35369 }
35370 arg4 = static_cast< wxDragResult >(val4);
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_From_int(static_cast< int >(result));
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35385 PyObject *obj;
35386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35387 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35388 return SWIG_Py_Void();
35389 }
35390
35391 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35392 return SWIG_Python_InitShadowInstance(args);
35393 }
35394
35395 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35396 PyObject *resultobj = 0;
35397 wxClipboard *result = 0 ;
35398
35399 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35400 {
35401 PyThreadState* __tstate = wxPyBeginAllowThreads();
35402 result = (wxClipboard *)new wxClipboard();
35403 wxPyEndAllowThreads(__tstate);
35404 if (PyErr_Occurred()) SWIG_fail;
35405 }
35406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35407 return resultobj;
35408 fail:
35409 return NULL;
35410 }
35411
35412
35413 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35414 PyObject *resultobj = 0;
35415 wxClipboard *arg1 = (wxClipboard *) 0 ;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 PyObject *swig_obj[1] ;
35419
35420 if (!args) SWIG_fail;
35421 swig_obj[0] = args;
35422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35423 if (!SWIG_IsOK(res1)) {
35424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35425 }
35426 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 delete arg1;
35430
35431 wxPyEndAllowThreads(__tstate);
35432 if (PyErr_Occurred()) SWIG_fail;
35433 }
35434 resultobj = SWIG_Py_Void();
35435 return resultobj;
35436 fail:
35437 return NULL;
35438 }
35439
35440
35441 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35442 PyObject *resultobj = 0;
35443 wxClipboard *arg1 = (wxClipboard *) 0 ;
35444 bool result;
35445 void *argp1 = 0 ;
35446 int res1 = 0 ;
35447 PyObject *swig_obj[1] ;
35448
35449 if (!args) SWIG_fail;
35450 swig_obj[0] = args;
35451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35452 if (!SWIG_IsOK(res1)) {
35453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35454 }
35455 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35456 {
35457 PyThreadState* __tstate = wxPyBeginAllowThreads();
35458 result = (bool)(arg1)->Open();
35459 wxPyEndAllowThreads(__tstate);
35460 if (PyErr_Occurred()) SWIG_fail;
35461 }
35462 {
35463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35464 }
35465 return resultobj;
35466 fail:
35467 return NULL;
35468 }
35469
35470
35471 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35472 PyObject *resultobj = 0;
35473 wxClipboard *arg1 = (wxClipboard *) 0 ;
35474 void *argp1 = 0 ;
35475 int res1 = 0 ;
35476 PyObject *swig_obj[1] ;
35477
35478 if (!args) SWIG_fail;
35479 swig_obj[0] = args;
35480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35481 if (!SWIG_IsOK(res1)) {
35482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35483 }
35484 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35485 {
35486 PyThreadState* __tstate = wxPyBeginAllowThreads();
35487 (arg1)->Close();
35488 wxPyEndAllowThreads(__tstate);
35489 if (PyErr_Occurred()) SWIG_fail;
35490 }
35491 resultobj = SWIG_Py_Void();
35492 return resultobj;
35493 fail:
35494 return NULL;
35495 }
35496
35497
35498 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35499 PyObject *resultobj = 0;
35500 wxClipboard *arg1 = (wxClipboard *) 0 ;
35501 bool result;
35502 void *argp1 = 0 ;
35503 int res1 = 0 ;
35504 PyObject *swig_obj[1] ;
35505
35506 if (!args) SWIG_fail;
35507 swig_obj[0] = args;
35508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35509 if (!SWIG_IsOK(res1)) {
35510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35511 }
35512 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35513 {
35514 PyThreadState* __tstate = wxPyBeginAllowThreads();
35515 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35516 wxPyEndAllowThreads(__tstate);
35517 if (PyErr_Occurred()) SWIG_fail;
35518 }
35519 {
35520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35521 }
35522 return resultobj;
35523 fail:
35524 return NULL;
35525 }
35526
35527
35528 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35529 PyObject *resultobj = 0;
35530 wxClipboard *arg1 = (wxClipboard *) 0 ;
35531 wxDataObject *arg2 = (wxDataObject *) 0 ;
35532 bool result;
35533 void *argp1 = 0 ;
35534 int res1 = 0 ;
35535 int res2 = 0 ;
35536 PyObject * obj0 = 0 ;
35537 PyObject * obj1 = 0 ;
35538 char * kwnames[] = {
35539 (char *) "self",(char *) "data", NULL
35540 };
35541
35542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35544 if (!SWIG_IsOK(res1)) {
35545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35546 }
35547 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35548 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35549 if (!SWIG_IsOK(res2)) {
35550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35551 }
35552 {
35553 PyThreadState* __tstate = wxPyBeginAllowThreads();
35554 result = (bool)(arg1)->AddData(arg2);
35555 wxPyEndAllowThreads(__tstate);
35556 if (PyErr_Occurred()) SWIG_fail;
35557 }
35558 {
35559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35560 }
35561 return resultobj;
35562 fail:
35563 return NULL;
35564 }
35565
35566
35567 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35568 PyObject *resultobj = 0;
35569 wxClipboard *arg1 = (wxClipboard *) 0 ;
35570 wxDataObject *arg2 = (wxDataObject *) 0 ;
35571 bool result;
35572 void *argp1 = 0 ;
35573 int res1 = 0 ;
35574 int res2 = 0 ;
35575 PyObject * obj0 = 0 ;
35576 PyObject * obj1 = 0 ;
35577 char * kwnames[] = {
35578 (char *) "self",(char *) "data", NULL
35579 };
35580
35581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35583 if (!SWIG_IsOK(res1)) {
35584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35585 }
35586 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35587 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35588 if (!SWIG_IsOK(res2)) {
35589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35590 }
35591 {
35592 PyThreadState* __tstate = wxPyBeginAllowThreads();
35593 result = (bool)(arg1)->SetData(arg2);
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 {
35598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35599 }
35600 return resultobj;
35601 fail:
35602 return NULL;
35603 }
35604
35605
35606 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35607 PyObject *resultobj = 0;
35608 wxClipboard *arg1 = (wxClipboard *) 0 ;
35609 wxDataFormat *arg2 = 0 ;
35610 bool result;
35611 void *argp1 = 0 ;
35612 int res1 = 0 ;
35613 void *argp2 = 0 ;
35614 int res2 = 0 ;
35615 PyObject * obj0 = 0 ;
35616 PyObject * obj1 = 0 ;
35617 char * kwnames[] = {
35618 (char *) "self",(char *) "format", NULL
35619 };
35620
35621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35623 if (!SWIG_IsOK(res1)) {
35624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35625 }
35626 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35627 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35628 if (!SWIG_IsOK(res2)) {
35629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35630 }
35631 if (!argp2) {
35632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35633 }
35634 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35635 {
35636 PyThreadState* __tstate = wxPyBeginAllowThreads();
35637 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35638 wxPyEndAllowThreads(__tstate);
35639 if (PyErr_Occurred()) SWIG_fail;
35640 }
35641 {
35642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35643 }
35644 return resultobj;
35645 fail:
35646 return NULL;
35647 }
35648
35649
35650 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35651 PyObject *resultobj = 0;
35652 wxClipboard *arg1 = (wxClipboard *) 0 ;
35653 wxDataObject *arg2 = 0 ;
35654 bool result;
35655 void *argp1 = 0 ;
35656 int res1 = 0 ;
35657 void *argp2 = 0 ;
35658 int res2 = 0 ;
35659 PyObject * obj0 = 0 ;
35660 PyObject * obj1 = 0 ;
35661 char * kwnames[] = {
35662 (char *) "self",(char *) "data", NULL
35663 };
35664
35665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35667 if (!SWIG_IsOK(res1)) {
35668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35669 }
35670 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35672 if (!SWIG_IsOK(res2)) {
35673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35674 }
35675 if (!argp2) {
35676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35677 }
35678 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35679 {
35680 PyThreadState* __tstate = wxPyBeginAllowThreads();
35681 result = (bool)(arg1)->GetData(*arg2);
35682 wxPyEndAllowThreads(__tstate);
35683 if (PyErr_Occurred()) SWIG_fail;
35684 }
35685 {
35686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35687 }
35688 return resultobj;
35689 fail:
35690 return NULL;
35691 }
35692
35693
35694 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35695 PyObject *resultobj = 0;
35696 wxClipboard *arg1 = (wxClipboard *) 0 ;
35697 void *argp1 = 0 ;
35698 int res1 = 0 ;
35699 PyObject *swig_obj[1] ;
35700
35701 if (!args) SWIG_fail;
35702 swig_obj[0] = args;
35703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35704 if (!SWIG_IsOK(res1)) {
35705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35706 }
35707 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35708 {
35709 PyThreadState* __tstate = wxPyBeginAllowThreads();
35710 (arg1)->Clear();
35711 wxPyEndAllowThreads(__tstate);
35712 if (PyErr_Occurred()) SWIG_fail;
35713 }
35714 resultobj = SWIG_Py_Void();
35715 return resultobj;
35716 fail:
35717 return NULL;
35718 }
35719
35720
35721 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35722 PyObject *resultobj = 0;
35723 wxClipboard *arg1 = (wxClipboard *) 0 ;
35724 bool result;
35725 void *argp1 = 0 ;
35726 int res1 = 0 ;
35727 PyObject *swig_obj[1] ;
35728
35729 if (!args) SWIG_fail;
35730 swig_obj[0] = args;
35731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35732 if (!SWIG_IsOK(res1)) {
35733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35734 }
35735 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35736 {
35737 PyThreadState* __tstate = wxPyBeginAllowThreads();
35738 result = (bool)(arg1)->Flush();
35739 wxPyEndAllowThreads(__tstate);
35740 if (PyErr_Occurred()) SWIG_fail;
35741 }
35742 {
35743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35744 }
35745 return resultobj;
35746 fail:
35747 return NULL;
35748 }
35749
35750
35751 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35752 PyObject *resultobj = 0;
35753 wxClipboard *arg1 = (wxClipboard *) 0 ;
35754 bool arg2 = (bool) true ;
35755 void *argp1 = 0 ;
35756 int res1 = 0 ;
35757 bool val2 ;
35758 int ecode2 = 0 ;
35759 PyObject * obj0 = 0 ;
35760 PyObject * obj1 = 0 ;
35761 char * kwnames[] = {
35762 (char *) "self",(char *) "primary", NULL
35763 };
35764
35765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35767 if (!SWIG_IsOK(res1)) {
35768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35769 }
35770 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35771 if (obj1) {
35772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35773 if (!SWIG_IsOK(ecode2)) {
35774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35775 }
35776 arg2 = static_cast< bool >(val2);
35777 }
35778 {
35779 PyThreadState* __tstate = wxPyBeginAllowThreads();
35780 (arg1)->UsePrimarySelection(arg2);
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 resultobj = SWIG_Py_Void();
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35792 PyObject *resultobj = 0;
35793 wxClipboard *result = 0 ;
35794
35795 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35796 {
35797 PyThreadState* __tstate = wxPyBeginAllowThreads();
35798 result = (wxClipboard *)wxClipboard::Get();
35799 wxPyEndAllowThreads(__tstate);
35800 if (PyErr_Occurred()) SWIG_fail;
35801 }
35802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35803 return resultobj;
35804 fail:
35805 return NULL;
35806 }
35807
35808
35809 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35810 PyObject *obj;
35811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35812 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35813 return SWIG_Py_Void();
35814 }
35815
35816 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35817 return SWIG_Python_InitShadowInstance(args);
35818 }
35819
35820 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35821 PyObject *resultobj = 0;
35822 wxClipboard *arg1 = (wxClipboard *) NULL ;
35823 wxClipboardLocker *result = 0 ;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 PyObject * obj0 = 0 ;
35827 char * kwnames[] = {
35828 (char *) "clipboard", NULL
35829 };
35830
35831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35832 if (obj0) {
35833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35834 if (!SWIG_IsOK(res1)) {
35835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35836 }
35837 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35838 }
35839 {
35840 PyThreadState* __tstate = wxPyBeginAllowThreads();
35841 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35842 wxPyEndAllowThreads(__tstate);
35843 if (PyErr_Occurred()) SWIG_fail;
35844 }
35845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35846 return resultobj;
35847 fail:
35848 return NULL;
35849 }
35850
35851
35852 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35853 PyObject *resultobj = 0;
35854 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35855 void *argp1 = 0 ;
35856 int res1 = 0 ;
35857 PyObject *swig_obj[1] ;
35858
35859 if (!args) SWIG_fail;
35860 swig_obj[0] = args;
35861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35862 if (!SWIG_IsOK(res1)) {
35863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35864 }
35865 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 delete arg1;
35869
35870 wxPyEndAllowThreads(__tstate);
35871 if (PyErr_Occurred()) SWIG_fail;
35872 }
35873 resultobj = SWIG_Py_Void();
35874 return resultobj;
35875 fail:
35876 return NULL;
35877 }
35878
35879
35880 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35881 PyObject *resultobj = 0;
35882 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35883 bool result;
35884 void *argp1 = 0 ;
35885 int res1 = 0 ;
35886 PyObject *swig_obj[1] ;
35887
35888 if (!args) SWIG_fail;
35889 swig_obj[0] = args;
35890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35891 if (!SWIG_IsOK(res1)) {
35892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35893 }
35894 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35895 {
35896 PyThreadState* __tstate = wxPyBeginAllowThreads();
35897 result = (bool)wxClipboardLocker___nonzero__(arg1);
35898 wxPyEndAllowThreads(__tstate);
35899 if (PyErr_Occurred()) SWIG_fail;
35900 }
35901 {
35902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35903 }
35904 return resultobj;
35905 fail:
35906 return NULL;
35907 }
35908
35909
35910 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35911 PyObject *obj;
35912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35913 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35914 return SWIG_Py_Void();
35915 }
35916
35917 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35918 return SWIG_Python_InitShadowInstance(args);
35919 }
35920
35921 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35922 PyObject *resultobj = 0;
35923 int arg1 = (int) 0 ;
35924 int arg2 = (int) 0 ;
35925 int arg3 = (int) 0 ;
35926 int arg4 = (int) 0 ;
35927 wxVideoMode *result = 0 ;
35928 int val1 ;
35929 int ecode1 = 0 ;
35930 int val2 ;
35931 int ecode2 = 0 ;
35932 int val3 ;
35933 int ecode3 = 0 ;
35934 int val4 ;
35935 int ecode4 = 0 ;
35936 PyObject * obj0 = 0 ;
35937 PyObject * obj1 = 0 ;
35938 PyObject * obj2 = 0 ;
35939 PyObject * obj3 = 0 ;
35940 char * kwnames[] = {
35941 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35942 };
35943
35944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35945 if (obj0) {
35946 ecode1 = SWIG_AsVal_int(obj0, &val1);
35947 if (!SWIG_IsOK(ecode1)) {
35948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35949 }
35950 arg1 = static_cast< int >(val1);
35951 }
35952 if (obj1) {
35953 ecode2 = SWIG_AsVal_int(obj1, &val2);
35954 if (!SWIG_IsOK(ecode2)) {
35955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35956 }
35957 arg2 = static_cast< int >(val2);
35958 }
35959 if (obj2) {
35960 ecode3 = SWIG_AsVal_int(obj2, &val3);
35961 if (!SWIG_IsOK(ecode3)) {
35962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35963 }
35964 arg3 = static_cast< int >(val3);
35965 }
35966 if (obj3) {
35967 ecode4 = SWIG_AsVal_int(obj3, &val4);
35968 if (!SWIG_IsOK(ecode4)) {
35969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35970 }
35971 arg4 = static_cast< int >(val4);
35972 }
35973 {
35974 PyThreadState* __tstate = wxPyBeginAllowThreads();
35975 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35976 wxPyEndAllowThreads(__tstate);
35977 if (PyErr_Occurred()) SWIG_fail;
35978 }
35979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35980 return resultobj;
35981 fail:
35982 return NULL;
35983 }
35984
35985
35986 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35987 PyObject *resultobj = 0;
35988 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 PyObject *swig_obj[1] ;
35992
35993 if (!args) SWIG_fail;
35994 swig_obj[0] = args;
35995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35996 if (!SWIG_IsOK(res1)) {
35997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35998 }
35999 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36000 {
36001 PyThreadState* __tstate = wxPyBeginAllowThreads();
36002 delete arg1;
36003
36004 wxPyEndAllowThreads(__tstate);
36005 if (PyErr_Occurred()) SWIG_fail;
36006 }
36007 resultobj = SWIG_Py_Void();
36008 return resultobj;
36009 fail:
36010 return NULL;
36011 }
36012
36013
36014 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36015 PyObject *resultobj = 0;
36016 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36017 wxVideoMode *arg2 = 0 ;
36018 bool result;
36019 void *argp1 = 0 ;
36020 int res1 = 0 ;
36021 void *argp2 = 0 ;
36022 int res2 = 0 ;
36023 PyObject * obj0 = 0 ;
36024 PyObject * obj1 = 0 ;
36025 char * kwnames[] = {
36026 (char *) "self",(char *) "other", NULL
36027 };
36028
36029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
36030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36031 if (!SWIG_IsOK(res1)) {
36032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36033 }
36034 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36035 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36036 if (!SWIG_IsOK(res2)) {
36037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36038 }
36039 if (!argp2) {
36040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36041 }
36042 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36043 {
36044 PyThreadState* __tstate = wxPyBeginAllowThreads();
36045 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
36046 wxPyEndAllowThreads(__tstate);
36047 if (PyErr_Occurred()) SWIG_fail;
36048 }
36049 {
36050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36051 }
36052 return resultobj;
36053 fail:
36054 return NULL;
36055 }
36056
36057
36058 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36059 PyObject *resultobj = 0;
36060 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36061 int result;
36062 void *argp1 = 0 ;
36063 int res1 = 0 ;
36064 PyObject *swig_obj[1] ;
36065
36066 if (!args) SWIG_fail;
36067 swig_obj[0] = args;
36068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36069 if (!SWIG_IsOK(res1)) {
36070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36071 }
36072 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36073 {
36074 PyThreadState* __tstate = wxPyBeginAllowThreads();
36075 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36076 wxPyEndAllowThreads(__tstate);
36077 if (PyErr_Occurred()) SWIG_fail;
36078 }
36079 resultobj = SWIG_From_int(static_cast< int >(result));
36080 return resultobj;
36081 fail:
36082 return NULL;
36083 }
36084
36085
36086 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36087 PyObject *resultobj = 0;
36088 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36089 int result;
36090 void *argp1 = 0 ;
36091 int res1 = 0 ;
36092 PyObject *swig_obj[1] ;
36093
36094 if (!args) SWIG_fail;
36095 swig_obj[0] = args;
36096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36097 if (!SWIG_IsOK(res1)) {
36098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36099 }
36100 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36101 {
36102 PyThreadState* __tstate = wxPyBeginAllowThreads();
36103 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36104 wxPyEndAllowThreads(__tstate);
36105 if (PyErr_Occurred()) SWIG_fail;
36106 }
36107 resultobj = SWIG_From_int(static_cast< int >(result));
36108 return resultobj;
36109 fail:
36110 return NULL;
36111 }
36112
36113
36114 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36115 PyObject *resultobj = 0;
36116 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36117 int result;
36118 void *argp1 = 0 ;
36119 int res1 = 0 ;
36120 PyObject *swig_obj[1] ;
36121
36122 if (!args) SWIG_fail;
36123 swig_obj[0] = args;
36124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36125 if (!SWIG_IsOK(res1)) {
36126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36127 }
36128 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36129 {
36130 PyThreadState* __tstate = wxPyBeginAllowThreads();
36131 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36132 wxPyEndAllowThreads(__tstate);
36133 if (PyErr_Occurred()) SWIG_fail;
36134 }
36135 resultobj = SWIG_From_int(static_cast< int >(result));
36136 return resultobj;
36137 fail:
36138 return NULL;
36139 }
36140
36141
36142 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36143 PyObject *resultobj = 0;
36144 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36145 bool result;
36146 void *argp1 = 0 ;
36147 int res1 = 0 ;
36148 PyObject *swig_obj[1] ;
36149
36150 if (!args) SWIG_fail;
36151 swig_obj[0] = args;
36152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36153 if (!SWIG_IsOK(res1)) {
36154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36155 }
36156 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36157 {
36158 PyThreadState* __tstate = wxPyBeginAllowThreads();
36159 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36160 wxPyEndAllowThreads(__tstate);
36161 if (PyErr_Occurred()) SWIG_fail;
36162 }
36163 {
36164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36165 }
36166 return resultobj;
36167 fail:
36168 return NULL;
36169 }
36170
36171
36172 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36173 PyObject *resultobj = 0;
36174 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36175 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36176 bool result;
36177 void *argp1 = 0 ;
36178 int res1 = 0 ;
36179 void *argp2 = 0 ;
36180 int res2 = 0 ;
36181 PyObject * obj0 = 0 ;
36182 PyObject * obj1 = 0 ;
36183 char * kwnames[] = {
36184 (char *) "self",(char *) "other", NULL
36185 };
36186
36187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36189 if (!SWIG_IsOK(res1)) {
36190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36191 }
36192 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36193 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36194 if (!SWIG_IsOK(res2)) {
36195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36196 }
36197 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36198 {
36199 PyThreadState* __tstate = wxPyBeginAllowThreads();
36200 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36201 wxPyEndAllowThreads(__tstate);
36202 if (PyErr_Occurred()) SWIG_fail;
36203 }
36204 {
36205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36206 }
36207 return resultobj;
36208 fail:
36209 return NULL;
36210 }
36211
36212
36213 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36214 PyObject *resultobj = 0;
36215 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36216 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36217 bool result;
36218 void *argp1 = 0 ;
36219 int res1 = 0 ;
36220 void *argp2 = 0 ;
36221 int res2 = 0 ;
36222 PyObject * obj0 = 0 ;
36223 PyObject * obj1 = 0 ;
36224 char * kwnames[] = {
36225 (char *) "self",(char *) "other", NULL
36226 };
36227
36228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36230 if (!SWIG_IsOK(res1)) {
36231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36232 }
36233 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36235 if (!SWIG_IsOK(res2)) {
36236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36237 }
36238 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36239 {
36240 PyThreadState* __tstate = wxPyBeginAllowThreads();
36241 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36242 wxPyEndAllowThreads(__tstate);
36243 if (PyErr_Occurred()) SWIG_fail;
36244 }
36245 {
36246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36247 }
36248 return resultobj;
36249 fail:
36250 return NULL;
36251 }
36252
36253
36254 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36255 PyObject *resultobj = 0;
36256 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36257 int arg2 ;
36258 void *argp1 = 0 ;
36259 int res1 = 0 ;
36260 int val2 ;
36261 int ecode2 = 0 ;
36262 PyObject *swig_obj[2] ;
36263
36264 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36266 if (!SWIG_IsOK(res1)) {
36267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36268 }
36269 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36270 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36271 if (!SWIG_IsOK(ecode2)) {
36272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36273 }
36274 arg2 = static_cast< int >(val2);
36275 if (arg1) (arg1)->w = arg2;
36276
36277 resultobj = SWIG_Py_Void();
36278 return resultobj;
36279 fail:
36280 return NULL;
36281 }
36282
36283
36284 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36285 PyObject *resultobj = 0;
36286 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36287 int result;
36288 void *argp1 = 0 ;
36289 int res1 = 0 ;
36290 PyObject *swig_obj[1] ;
36291
36292 if (!args) SWIG_fail;
36293 swig_obj[0] = args;
36294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36295 if (!SWIG_IsOK(res1)) {
36296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36297 }
36298 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36299 result = (int) ((arg1)->w);
36300 resultobj = SWIG_From_int(static_cast< int >(result));
36301 return resultobj;
36302 fail:
36303 return NULL;
36304 }
36305
36306
36307 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36308 PyObject *resultobj = 0;
36309 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36310 int arg2 ;
36311 void *argp1 = 0 ;
36312 int res1 = 0 ;
36313 int val2 ;
36314 int ecode2 = 0 ;
36315 PyObject *swig_obj[2] ;
36316
36317 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36319 if (!SWIG_IsOK(res1)) {
36320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36321 }
36322 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36323 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36324 if (!SWIG_IsOK(ecode2)) {
36325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36326 }
36327 arg2 = static_cast< int >(val2);
36328 if (arg1) (arg1)->h = arg2;
36329
36330 resultobj = SWIG_Py_Void();
36331 return resultobj;
36332 fail:
36333 return NULL;
36334 }
36335
36336
36337 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36338 PyObject *resultobj = 0;
36339 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36340 int result;
36341 void *argp1 = 0 ;
36342 int res1 = 0 ;
36343 PyObject *swig_obj[1] ;
36344
36345 if (!args) SWIG_fail;
36346 swig_obj[0] = args;
36347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36348 if (!SWIG_IsOK(res1)) {
36349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36350 }
36351 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36352 result = (int) ((arg1)->h);
36353 resultobj = SWIG_From_int(static_cast< int >(result));
36354 return resultobj;
36355 fail:
36356 return NULL;
36357 }
36358
36359
36360 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36361 PyObject *resultobj = 0;
36362 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36363 int arg2 ;
36364 void *argp1 = 0 ;
36365 int res1 = 0 ;
36366 int val2 ;
36367 int ecode2 = 0 ;
36368 PyObject *swig_obj[2] ;
36369
36370 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36374 }
36375 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36376 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36377 if (!SWIG_IsOK(ecode2)) {
36378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36379 }
36380 arg2 = static_cast< int >(val2);
36381 if (arg1) (arg1)->bpp = arg2;
36382
36383 resultobj = SWIG_Py_Void();
36384 return resultobj;
36385 fail:
36386 return NULL;
36387 }
36388
36389
36390 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36391 PyObject *resultobj = 0;
36392 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36393 int result;
36394 void *argp1 = 0 ;
36395 int res1 = 0 ;
36396 PyObject *swig_obj[1] ;
36397
36398 if (!args) SWIG_fail;
36399 swig_obj[0] = args;
36400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36401 if (!SWIG_IsOK(res1)) {
36402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36403 }
36404 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36405 result = (int) ((arg1)->bpp);
36406 resultobj = SWIG_From_int(static_cast< int >(result));
36407 return resultobj;
36408 fail:
36409 return NULL;
36410 }
36411
36412
36413 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36414 PyObject *resultobj = 0;
36415 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36416 int arg2 ;
36417 void *argp1 = 0 ;
36418 int res1 = 0 ;
36419 int val2 ;
36420 int ecode2 = 0 ;
36421 PyObject *swig_obj[2] ;
36422
36423 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36425 if (!SWIG_IsOK(res1)) {
36426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36427 }
36428 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36429 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36430 if (!SWIG_IsOK(ecode2)) {
36431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36432 }
36433 arg2 = static_cast< int >(val2);
36434 if (arg1) (arg1)->refresh = arg2;
36435
36436 resultobj = SWIG_Py_Void();
36437 return resultobj;
36438 fail:
36439 return NULL;
36440 }
36441
36442
36443 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36444 PyObject *resultobj = 0;
36445 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36446 int result;
36447 void *argp1 = 0 ;
36448 int res1 = 0 ;
36449 PyObject *swig_obj[1] ;
36450
36451 if (!args) SWIG_fail;
36452 swig_obj[0] = args;
36453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36454 if (!SWIG_IsOK(res1)) {
36455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36456 }
36457 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36458 result = (int) ((arg1)->refresh);
36459 resultobj = SWIG_From_int(static_cast< int >(result));
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36467 PyObject *obj;
36468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36469 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36470 return SWIG_Py_Void();
36471 }
36472
36473 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36474 return SWIG_Python_InitShadowInstance(args);
36475 }
36476
36477 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36478 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36479 return 1;
36480 }
36481
36482
36483 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36484 PyObject *pyobj = 0;
36485
36486 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36487 return pyobj;
36488 }
36489
36490
36491 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36492 PyObject *resultobj = 0;
36493 unsigned int arg1 = (unsigned int) 0 ;
36494 wxDisplay *result = 0 ;
36495 unsigned int val1 ;
36496 int ecode1 = 0 ;
36497 PyObject * obj0 = 0 ;
36498 char * kwnames[] = {
36499 (char *) "index", NULL
36500 };
36501
36502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36503 if (obj0) {
36504 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36505 if (!SWIG_IsOK(ecode1)) {
36506 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36507 }
36508 arg1 = static_cast< unsigned int >(val1);
36509 }
36510 {
36511 PyThreadState* __tstate = wxPyBeginAllowThreads();
36512 result = (wxDisplay *)new wxDisplay(arg1);
36513 wxPyEndAllowThreads(__tstate);
36514 if (PyErr_Occurred()) SWIG_fail;
36515 }
36516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36517 return resultobj;
36518 fail:
36519 return NULL;
36520 }
36521
36522
36523 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36524 PyObject *resultobj = 0;
36525 wxDisplay *arg1 = (wxDisplay *) 0 ;
36526 void *argp1 = 0 ;
36527 int res1 = 0 ;
36528 PyObject *swig_obj[1] ;
36529
36530 if (!args) SWIG_fail;
36531 swig_obj[0] = args;
36532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36533 if (!SWIG_IsOK(res1)) {
36534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36535 }
36536 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36537 {
36538 PyThreadState* __tstate = wxPyBeginAllowThreads();
36539 delete arg1;
36540
36541 wxPyEndAllowThreads(__tstate);
36542 if (PyErr_Occurred()) SWIG_fail;
36543 }
36544 resultobj = SWIG_Py_Void();
36545 return resultobj;
36546 fail:
36547 return NULL;
36548 }
36549
36550
36551 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36552 PyObject *resultobj = 0;
36553 unsigned int result;
36554
36555 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36556 {
36557 PyThreadState* __tstate = wxPyBeginAllowThreads();
36558 result = (unsigned int)wxDisplay::GetCount();
36559 wxPyEndAllowThreads(__tstate);
36560 if (PyErr_Occurred()) SWIG_fail;
36561 }
36562 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36563 return resultobj;
36564 fail:
36565 return NULL;
36566 }
36567
36568
36569 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36570 PyObject *resultobj = 0;
36571 wxPoint *arg1 = 0 ;
36572 int result;
36573 wxPoint temp1 ;
36574 PyObject * obj0 = 0 ;
36575 char * kwnames[] = {
36576 (char *) "pt", NULL
36577 };
36578
36579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36580 {
36581 arg1 = &temp1;
36582 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36583 }
36584 {
36585 PyThreadState* __tstate = wxPyBeginAllowThreads();
36586 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 resultobj = SWIG_From_int(static_cast< int >(result));
36591 return resultobj;
36592 fail:
36593 return NULL;
36594 }
36595
36596
36597 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36598 PyObject *resultobj = 0;
36599 wxWindow *arg1 = (wxWindow *) 0 ;
36600 int result;
36601 void *argp1 = 0 ;
36602 int res1 = 0 ;
36603 PyObject * obj0 = 0 ;
36604 char * kwnames[] = {
36605 (char *) "window", NULL
36606 };
36607
36608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36610 if (!SWIG_IsOK(res1)) {
36611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36612 }
36613 arg1 = reinterpret_cast< wxWindow * >(argp1);
36614 {
36615 PyThreadState* __tstate = wxPyBeginAllowThreads();
36616 result = (int)wxDisplay::GetFromWindow(arg1);
36617 wxPyEndAllowThreads(__tstate);
36618 if (PyErr_Occurred()) SWIG_fail;
36619 }
36620 resultobj = SWIG_From_int(static_cast< int >(result));
36621 return resultobj;
36622 fail:
36623 return NULL;
36624 }
36625
36626
36627 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36628 PyObject *resultobj = 0;
36629 wxDisplay *arg1 = (wxDisplay *) 0 ;
36630 bool result;
36631 void *argp1 = 0 ;
36632 int res1 = 0 ;
36633 PyObject *swig_obj[1] ;
36634
36635 if (!args) SWIG_fail;
36636 swig_obj[0] = args;
36637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36638 if (!SWIG_IsOK(res1)) {
36639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36640 }
36641 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36642 {
36643 PyThreadState* __tstate = wxPyBeginAllowThreads();
36644 result = (bool)((wxDisplay const *)arg1)->IsOk();
36645 wxPyEndAllowThreads(__tstate);
36646 if (PyErr_Occurred()) SWIG_fail;
36647 }
36648 {
36649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36650 }
36651 return resultobj;
36652 fail:
36653 return NULL;
36654 }
36655
36656
36657 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36658 PyObject *resultobj = 0;
36659 wxDisplay *arg1 = (wxDisplay *) 0 ;
36660 wxRect result;
36661 void *argp1 = 0 ;
36662 int res1 = 0 ;
36663 PyObject *swig_obj[1] ;
36664
36665 if (!args) SWIG_fail;
36666 swig_obj[0] = args;
36667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36668 if (!SWIG_IsOK(res1)) {
36669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36670 }
36671 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 result = ((wxDisplay const *)arg1)->GetGeometry();
36675 wxPyEndAllowThreads(__tstate);
36676 if (PyErr_Occurred()) SWIG_fail;
36677 }
36678 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36686 PyObject *resultobj = 0;
36687 wxDisplay *arg1 = (wxDisplay *) 0 ;
36688 wxRect 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_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36698 }
36699 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 result = ((wxDisplay const *)arg1)->GetClientArea();
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36707 return resultobj;
36708 fail:
36709 return NULL;
36710 }
36711
36712
36713 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36714 PyObject *resultobj = 0;
36715 wxDisplay *arg1 = (wxDisplay *) 0 ;
36716 wxString result;
36717 void *argp1 = 0 ;
36718 int res1 = 0 ;
36719 PyObject *swig_obj[1] ;
36720
36721 if (!args) SWIG_fail;
36722 swig_obj[0] = args;
36723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36724 if (!SWIG_IsOK(res1)) {
36725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36726 }
36727 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36728 {
36729 PyThreadState* __tstate = wxPyBeginAllowThreads();
36730 result = ((wxDisplay const *)arg1)->GetName();
36731 wxPyEndAllowThreads(__tstate);
36732 if (PyErr_Occurred()) SWIG_fail;
36733 }
36734 {
36735 #if wxUSE_UNICODE
36736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36737 #else
36738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36739 #endif
36740 }
36741 return resultobj;
36742 fail:
36743 return NULL;
36744 }
36745
36746
36747 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36748 PyObject *resultobj = 0;
36749 wxDisplay *arg1 = (wxDisplay *) 0 ;
36750 bool result;
36751 void *argp1 = 0 ;
36752 int res1 = 0 ;
36753 PyObject *swig_obj[1] ;
36754
36755 if (!args) SWIG_fail;
36756 swig_obj[0] = args;
36757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36758 if (!SWIG_IsOK(res1)) {
36759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36760 }
36761 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36762 {
36763 PyThreadState* __tstate = wxPyBeginAllowThreads();
36764 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36765 wxPyEndAllowThreads(__tstate);
36766 if (PyErr_Occurred()) SWIG_fail;
36767 }
36768 {
36769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36770 }
36771 return resultobj;
36772 fail:
36773 return NULL;
36774 }
36775
36776
36777 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36778 PyObject *resultobj = 0;
36779 wxDisplay *arg1 = (wxDisplay *) 0 ;
36780 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36781 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36782 PyObject *result = 0 ;
36783 void *argp1 = 0 ;
36784 int res1 = 0 ;
36785 void *argp2 = 0 ;
36786 int res2 = 0 ;
36787 PyObject * obj0 = 0 ;
36788 PyObject * obj1 = 0 ;
36789 char * kwnames[] = {
36790 (char *) "self",(char *) "mode", NULL
36791 };
36792
36793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36795 if (!SWIG_IsOK(res1)) {
36796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36797 }
36798 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36799 if (obj1) {
36800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36801 if (!SWIG_IsOK(res2)) {
36802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36803 }
36804 if (!argp2) {
36805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36806 }
36807 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36808 }
36809 {
36810 PyThreadState* __tstate = wxPyBeginAllowThreads();
36811 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36812 wxPyEndAllowThreads(__tstate);
36813 if (PyErr_Occurred()) SWIG_fail;
36814 }
36815 resultobj = result;
36816 return resultobj;
36817 fail:
36818 return NULL;
36819 }
36820
36821
36822 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36823 PyObject *resultobj = 0;
36824 wxDisplay *arg1 = (wxDisplay *) 0 ;
36825 wxVideoMode result;
36826 void *argp1 = 0 ;
36827 int res1 = 0 ;
36828 PyObject *swig_obj[1] ;
36829
36830 if (!args) SWIG_fail;
36831 swig_obj[0] = args;
36832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36833 if (!SWIG_IsOK(res1)) {
36834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36835 }
36836 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36844 return resultobj;
36845 fail:
36846 return NULL;
36847 }
36848
36849
36850 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36851 PyObject *resultobj = 0;
36852 wxDisplay *arg1 = (wxDisplay *) 0 ;
36853 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36854 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36855 bool result;
36856 void *argp1 = 0 ;
36857 int res1 = 0 ;
36858 void *argp2 = 0 ;
36859 int res2 = 0 ;
36860 PyObject * obj0 = 0 ;
36861 PyObject * obj1 = 0 ;
36862 char * kwnames[] = {
36863 (char *) "self",(char *) "mode", NULL
36864 };
36865
36866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36868 if (!SWIG_IsOK(res1)) {
36869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36870 }
36871 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36872 if (obj1) {
36873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36874 if (!SWIG_IsOK(res2)) {
36875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36876 }
36877 if (!argp2) {
36878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36879 }
36880 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36881 }
36882 {
36883 PyThreadState* __tstate = wxPyBeginAllowThreads();
36884 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36885 wxPyEndAllowThreads(__tstate);
36886 if (PyErr_Occurred()) SWIG_fail;
36887 }
36888 {
36889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36890 }
36891 return resultobj;
36892 fail:
36893 return NULL;
36894 }
36895
36896
36897 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36898 PyObject *resultobj = 0;
36899 wxDisplay *arg1 = (wxDisplay *) 0 ;
36900 void *argp1 = 0 ;
36901 int res1 = 0 ;
36902 PyObject *swig_obj[1] ;
36903
36904 if (!args) SWIG_fail;
36905 swig_obj[0] = args;
36906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36907 if (!SWIG_IsOK(res1)) {
36908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36909 }
36910 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36911 {
36912 PyThreadState* __tstate = wxPyBeginAllowThreads();
36913 wxDisplay_ResetMode(arg1);
36914 wxPyEndAllowThreads(__tstate);
36915 if (PyErr_Occurred()) SWIG_fail;
36916 }
36917 resultobj = SWIG_Py_Void();
36918 return resultobj;
36919 fail:
36920 return NULL;
36921 }
36922
36923
36924 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36925 PyObject *obj;
36926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36927 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36928 return SWIG_Py_Void();
36929 }
36930
36931 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36932 return SWIG_Python_InitShadowInstance(args);
36933 }
36934
36935 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36936 PyObject *resultobj = 0;
36937 wxStandardPaths *result = 0 ;
36938
36939 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36940 {
36941 PyThreadState* __tstate = wxPyBeginAllowThreads();
36942 result = (wxStandardPaths *)wxStandardPaths_Get();
36943 wxPyEndAllowThreads(__tstate);
36944 if (PyErr_Occurred()) SWIG_fail;
36945 }
36946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36954 PyObject *resultobj = 0;
36955 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36956 wxString result;
36957 void *argp1 = 0 ;
36958 int res1 = 0 ;
36959 PyObject *swig_obj[1] ;
36960
36961 if (!args) SWIG_fail;
36962 swig_obj[0] = args;
36963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36964 if (!SWIG_IsOK(res1)) {
36965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36966 }
36967 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36968 {
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36971 wxPyEndAllowThreads(__tstate);
36972 if (PyErr_Occurred()) SWIG_fail;
36973 }
36974 {
36975 #if wxUSE_UNICODE
36976 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36977 #else
36978 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36979 #endif
36980 }
36981 return resultobj;
36982 fail:
36983 return NULL;
36984 }
36985
36986
36987 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36988 PyObject *resultobj = 0;
36989 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36990 wxString result;
36991 void *argp1 = 0 ;
36992 int res1 = 0 ;
36993 PyObject *swig_obj[1] ;
36994
36995 if (!args) SWIG_fail;
36996 swig_obj[0] = args;
36997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36998 if (!SWIG_IsOK(res1)) {
36999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37000 }
37001 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37002 {
37003 PyThreadState* __tstate = wxPyBeginAllowThreads();
37004 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
37005 wxPyEndAllowThreads(__tstate);
37006 if (PyErr_Occurred()) SWIG_fail;
37007 }
37008 {
37009 #if wxUSE_UNICODE
37010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37011 #else
37012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37013 #endif
37014 }
37015 return resultobj;
37016 fail:
37017 return NULL;
37018 }
37019
37020
37021 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37022 PyObject *resultobj = 0;
37023 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37024 wxString result;
37025 void *argp1 = 0 ;
37026 int res1 = 0 ;
37027 PyObject *swig_obj[1] ;
37028
37029 if (!args) SWIG_fail;
37030 swig_obj[0] = args;
37031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37032 if (!SWIG_IsOK(res1)) {
37033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37034 }
37035 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 {
37043 #if wxUSE_UNICODE
37044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37045 #else
37046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37047 #endif
37048 }
37049 return resultobj;
37050 fail:
37051 return NULL;
37052 }
37053
37054
37055 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37056 PyObject *resultobj = 0;
37057 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37058 wxString result;
37059 void *argp1 = 0 ;
37060 int res1 = 0 ;
37061 PyObject *swig_obj[1] ;
37062
37063 if (!args) SWIG_fail;
37064 swig_obj[0] = args;
37065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37066 if (!SWIG_IsOK(res1)) {
37067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37068 }
37069 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37070 {
37071 PyThreadState* __tstate = wxPyBeginAllowThreads();
37072 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37073 wxPyEndAllowThreads(__tstate);
37074 if (PyErr_Occurred()) SWIG_fail;
37075 }
37076 {
37077 #if wxUSE_UNICODE
37078 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37079 #else
37080 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37081 #endif
37082 }
37083 return resultobj;
37084 fail:
37085 return NULL;
37086 }
37087
37088
37089 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37090 PyObject *resultobj = 0;
37091 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37092 wxString result;
37093 void *argp1 = 0 ;
37094 int res1 = 0 ;
37095 PyObject *swig_obj[1] ;
37096
37097 if (!args) SWIG_fail;
37098 swig_obj[0] = args;
37099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37100 if (!SWIG_IsOK(res1)) {
37101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37102 }
37103 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37104 {
37105 PyThreadState* __tstate = wxPyBeginAllowThreads();
37106 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37107 wxPyEndAllowThreads(__tstate);
37108 if (PyErr_Occurred()) SWIG_fail;
37109 }
37110 {
37111 #if wxUSE_UNICODE
37112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37113 #else
37114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37115 #endif
37116 }
37117 return resultobj;
37118 fail:
37119 return NULL;
37120 }
37121
37122
37123 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37124 PyObject *resultobj = 0;
37125 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37126 wxString result;
37127 void *argp1 = 0 ;
37128 int res1 = 0 ;
37129 PyObject *swig_obj[1] ;
37130
37131 if (!args) SWIG_fail;
37132 swig_obj[0] = args;
37133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37134 if (!SWIG_IsOK(res1)) {
37135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37136 }
37137 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37138 {
37139 PyThreadState* __tstate = wxPyBeginAllowThreads();
37140 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37141 wxPyEndAllowThreads(__tstate);
37142 if (PyErr_Occurred()) SWIG_fail;
37143 }
37144 {
37145 #if wxUSE_UNICODE
37146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37147 #else
37148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37149 #endif
37150 }
37151 return resultobj;
37152 fail:
37153 return NULL;
37154 }
37155
37156
37157 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37158 PyObject *resultobj = 0;
37159 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37160 wxString result;
37161 void *argp1 = 0 ;
37162 int res1 = 0 ;
37163 PyObject *swig_obj[1] ;
37164
37165 if (!args) SWIG_fail;
37166 swig_obj[0] = args;
37167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37168 if (!SWIG_IsOK(res1)) {
37169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37170 }
37171 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37172 {
37173 PyThreadState* __tstate = wxPyBeginAllowThreads();
37174 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37175 wxPyEndAllowThreads(__tstate);
37176 if (PyErr_Occurred()) SWIG_fail;
37177 }
37178 {
37179 #if wxUSE_UNICODE
37180 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37181 #else
37182 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37183 #endif
37184 }
37185 return resultobj;
37186 fail:
37187 return NULL;
37188 }
37189
37190
37191 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37192 PyObject *resultobj = 0;
37193 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37194 wxString result;
37195 void *argp1 = 0 ;
37196 int res1 = 0 ;
37197 PyObject *swig_obj[1] ;
37198
37199 if (!args) SWIG_fail;
37200 swig_obj[0] = args;
37201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37202 if (!SWIG_IsOK(res1)) {
37203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37204 }
37205 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37206 {
37207 PyThreadState* __tstate = wxPyBeginAllowThreads();
37208 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37209 wxPyEndAllowThreads(__tstate);
37210 if (PyErr_Occurred()) SWIG_fail;
37211 }
37212 {
37213 #if wxUSE_UNICODE
37214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37215 #else
37216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37217 #endif
37218 }
37219 return resultobj;
37220 fail:
37221 return NULL;
37222 }
37223
37224
37225 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37226 PyObject *resultobj = 0;
37227 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37228 wxString result;
37229 void *argp1 = 0 ;
37230 int res1 = 0 ;
37231 PyObject *swig_obj[1] ;
37232
37233 if (!args) SWIG_fail;
37234 swig_obj[0] = args;
37235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37236 if (!SWIG_IsOK(res1)) {
37237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37238 }
37239 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37240 {
37241 PyThreadState* __tstate = wxPyBeginAllowThreads();
37242 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37243 wxPyEndAllowThreads(__tstate);
37244 if (PyErr_Occurred()) SWIG_fail;
37245 }
37246 {
37247 #if wxUSE_UNICODE
37248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37249 #else
37250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37251 #endif
37252 }
37253 return resultobj;
37254 fail:
37255 return NULL;
37256 }
37257
37258
37259 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37260 PyObject *resultobj = 0;
37261 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37262 wxString *arg2 = 0 ;
37263 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37264 wxString result;
37265 void *argp1 = 0 ;
37266 int res1 = 0 ;
37267 bool temp2 = false ;
37268 int val3 ;
37269 int ecode3 = 0 ;
37270 PyObject * obj0 = 0 ;
37271 PyObject * obj1 = 0 ;
37272 PyObject * obj2 = 0 ;
37273 char * kwnames[] = {
37274 (char *) "self",(char *) "lang",(char *) "category", NULL
37275 };
37276
37277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37279 if (!SWIG_IsOK(res1)) {
37280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37281 }
37282 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37283 {
37284 arg2 = wxString_in_helper(obj1);
37285 if (arg2 == NULL) SWIG_fail;
37286 temp2 = true;
37287 }
37288 if (obj2) {
37289 ecode3 = SWIG_AsVal_int(obj2, &val3);
37290 if (!SWIG_IsOK(ecode3)) {
37291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37292 }
37293 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37294 }
37295 {
37296 PyThreadState* __tstate = wxPyBeginAllowThreads();
37297 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37298 wxPyEndAllowThreads(__tstate);
37299 if (PyErr_Occurred()) SWIG_fail;
37300 }
37301 {
37302 #if wxUSE_UNICODE
37303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37304 #else
37305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37306 #endif
37307 }
37308 {
37309 if (temp2)
37310 delete arg2;
37311 }
37312 return resultobj;
37313 fail:
37314 {
37315 if (temp2)
37316 delete arg2;
37317 }
37318 return NULL;
37319 }
37320
37321
37322 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37323 PyObject *resultobj = 0;
37324 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37325 wxString result;
37326 void *argp1 = 0 ;
37327 int res1 = 0 ;
37328 PyObject *swig_obj[1] ;
37329
37330 if (!args) SWIG_fail;
37331 swig_obj[0] = args;
37332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37333 if (!SWIG_IsOK(res1)) {
37334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37335 }
37336 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37337 {
37338 PyThreadState* __tstate = wxPyBeginAllowThreads();
37339 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37340 wxPyEndAllowThreads(__tstate);
37341 if (PyErr_Occurred()) SWIG_fail;
37342 }
37343 {
37344 #if wxUSE_UNICODE
37345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37346 #else
37347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37348 #endif
37349 }
37350 return resultobj;
37351 fail:
37352 return NULL;
37353 }
37354
37355
37356 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37357 PyObject *resultobj = 0;
37358 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37359 wxString result;
37360 void *argp1 = 0 ;
37361 int res1 = 0 ;
37362 PyObject *swig_obj[1] ;
37363
37364 if (!args) SWIG_fail;
37365 swig_obj[0] = args;
37366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37367 if (!SWIG_IsOK(res1)) {
37368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37369 }
37370 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37371 {
37372 PyThreadState* __tstate = wxPyBeginAllowThreads();
37373 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37374 wxPyEndAllowThreads(__tstate);
37375 if (PyErr_Occurred()) SWIG_fail;
37376 }
37377 {
37378 #if wxUSE_UNICODE
37379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37380 #else
37381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37382 #endif
37383 }
37384 return resultobj;
37385 fail:
37386 return NULL;
37387 }
37388
37389
37390 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37391 PyObject *resultobj = 0;
37392 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37393 wxString *arg2 = 0 ;
37394 void *argp1 = 0 ;
37395 int res1 = 0 ;
37396 bool temp2 = false ;
37397 PyObject * obj0 = 0 ;
37398 PyObject * obj1 = 0 ;
37399 char * kwnames[] = {
37400 (char *) "self",(char *) "prefix", NULL
37401 };
37402
37403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37405 if (!SWIG_IsOK(res1)) {
37406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37407 }
37408 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37409 {
37410 arg2 = wxString_in_helper(obj1);
37411 if (arg2 == NULL) SWIG_fail;
37412 temp2 = true;
37413 }
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37417 wxPyEndAllowThreads(__tstate);
37418 if (PyErr_Occurred()) SWIG_fail;
37419 }
37420 resultobj = SWIG_Py_Void();
37421 {
37422 if (temp2)
37423 delete arg2;
37424 }
37425 return resultobj;
37426 fail:
37427 {
37428 if (temp2)
37429 delete arg2;
37430 }
37431 return NULL;
37432 }
37433
37434
37435 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37436 PyObject *resultobj = 0;
37437 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37438 wxString result;
37439 void *argp1 = 0 ;
37440 int res1 = 0 ;
37441 PyObject *swig_obj[1] ;
37442
37443 if (!args) SWIG_fail;
37444 swig_obj[0] = args;
37445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37446 if (!SWIG_IsOK(res1)) {
37447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37448 }
37449 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37450 {
37451 PyThreadState* __tstate = wxPyBeginAllowThreads();
37452 result = wxStandardPaths_GetInstallPrefix(arg1);
37453 wxPyEndAllowThreads(__tstate);
37454 if (PyErr_Occurred()) SWIG_fail;
37455 }
37456 {
37457 #if wxUSE_UNICODE
37458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37459 #else
37460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37461 #endif
37462 }
37463 return resultobj;
37464 fail:
37465 return NULL;
37466 }
37467
37468
37469 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37470 PyObject *obj;
37471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37472 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37473 return SWIG_Py_Void();
37474 }
37475
37476 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37477 PyObject *resultobj = 0;
37478 wxEventType arg1 ;
37479 wxPowerEvent *result = 0 ;
37480 int val1 ;
37481 int ecode1 = 0 ;
37482 PyObject * obj0 = 0 ;
37483 char * kwnames[] = {
37484 (char *) "evtType", NULL
37485 };
37486
37487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37488 ecode1 = SWIG_AsVal_int(obj0, &val1);
37489 if (!SWIG_IsOK(ecode1)) {
37490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37491 }
37492 arg1 = static_cast< wxEventType >(val1);
37493 {
37494 PyThreadState* __tstate = wxPyBeginAllowThreads();
37495 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37496 wxPyEndAllowThreads(__tstate);
37497 if (PyErr_Occurred()) SWIG_fail;
37498 }
37499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37500 return resultobj;
37501 fail:
37502 return NULL;
37503 }
37504
37505
37506 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37507 PyObject *resultobj = 0;
37508 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37509 void *argp1 = 0 ;
37510 int res1 = 0 ;
37511 PyObject *swig_obj[1] ;
37512
37513 if (!args) SWIG_fail;
37514 swig_obj[0] = args;
37515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37516 if (!SWIG_IsOK(res1)) {
37517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37518 }
37519 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37520 {
37521 PyThreadState* __tstate = wxPyBeginAllowThreads();
37522 (arg1)->Veto();
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 resultobj = SWIG_Py_Void();
37527 return resultobj;
37528 fail:
37529 return NULL;
37530 }
37531
37532
37533 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37534 PyObject *resultobj = 0;
37535 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37536 bool result;
37537 void *argp1 = 0 ;
37538 int res1 = 0 ;
37539 PyObject *swig_obj[1] ;
37540
37541 if (!args) SWIG_fail;
37542 swig_obj[0] = args;
37543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37544 if (!SWIG_IsOK(res1)) {
37545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37546 }
37547 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37548 {
37549 PyThreadState* __tstate = wxPyBeginAllowThreads();
37550 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37551 wxPyEndAllowThreads(__tstate);
37552 if (PyErr_Occurred()) SWIG_fail;
37553 }
37554 {
37555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37556 }
37557 return resultobj;
37558 fail:
37559 return NULL;
37560 }
37561
37562
37563 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37564 PyObject *obj;
37565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37566 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37567 return SWIG_Py_Void();
37568 }
37569
37570 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37571 return SWIG_Python_InitShadowInstance(args);
37572 }
37573
37574 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37575 PyObject *resultobj = 0;
37576 wxPowerType result;
37577
37578 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 result = (wxPowerType)wxGetPowerType();
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 resultobj = SWIG_From_int(static_cast< int >(result));
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37593 PyObject *resultobj = 0;
37594 wxBatteryState result;
37595
37596 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37597 {
37598 PyThreadState* __tstate = wxPyBeginAllowThreads();
37599 result = (wxBatteryState)wxGetBatteryState();
37600 wxPyEndAllowThreads(__tstate);
37601 if (PyErr_Occurred()) SWIG_fail;
37602 }
37603 resultobj = SWIG_From_int(static_cast< int >(result));
37604 return resultobj;
37605 fail:
37606 return NULL;
37607 }
37608
37609
37610 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37611 PyObject *resultobj = 0;
37612 wxAboutDialogInfo *result = 0 ;
37613
37614 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37615 {
37616 PyThreadState* __tstate = wxPyBeginAllowThreads();
37617 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37622 return resultobj;
37623 fail:
37624 return NULL;
37625 }
37626
37627
37628 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37629 PyObject *resultobj = 0;
37630 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37631 void *argp1 = 0 ;
37632 int res1 = 0 ;
37633 PyObject *swig_obj[1] ;
37634
37635 if (!args) SWIG_fail;
37636 swig_obj[0] = args;
37637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37638 if (!SWIG_IsOK(res1)) {
37639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37640 }
37641 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37642 {
37643 PyThreadState* __tstate = wxPyBeginAllowThreads();
37644 delete arg1;
37645
37646 wxPyEndAllowThreads(__tstate);
37647 if (PyErr_Occurred()) SWIG_fail;
37648 }
37649 resultobj = SWIG_Py_Void();
37650 return resultobj;
37651 fail:
37652 return NULL;
37653 }
37654
37655
37656 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37657 PyObject *resultobj = 0;
37658 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37659 wxString *arg2 = 0 ;
37660 void *argp1 = 0 ;
37661 int res1 = 0 ;
37662 bool temp2 = false ;
37663 PyObject * obj0 = 0 ;
37664 PyObject * obj1 = 0 ;
37665 char * kwnames[] = {
37666 (char *) "self",(char *) "name", NULL
37667 };
37668
37669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37671 if (!SWIG_IsOK(res1)) {
37672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37673 }
37674 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37675 {
37676 arg2 = wxString_in_helper(obj1);
37677 if (arg2 == NULL) SWIG_fail;
37678 temp2 = true;
37679 }
37680 {
37681 PyThreadState* __tstate = wxPyBeginAllowThreads();
37682 (arg1)->SetName((wxString const &)*arg2);
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 resultobj = SWIG_Py_Void();
37687 {
37688 if (temp2)
37689 delete arg2;
37690 }
37691 return resultobj;
37692 fail:
37693 {
37694 if (temp2)
37695 delete arg2;
37696 }
37697 return NULL;
37698 }
37699
37700
37701 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37702 PyObject *resultobj = 0;
37703 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37704 wxString result;
37705 void *argp1 = 0 ;
37706 int res1 = 0 ;
37707 PyObject *swig_obj[1] ;
37708
37709 if (!args) SWIG_fail;
37710 swig_obj[0] = args;
37711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37712 if (!SWIG_IsOK(res1)) {
37713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37714 }
37715 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37716 {
37717 PyThreadState* __tstate = wxPyBeginAllowThreads();
37718 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37719 wxPyEndAllowThreads(__tstate);
37720 if (PyErr_Occurred()) SWIG_fail;
37721 }
37722 {
37723 #if wxUSE_UNICODE
37724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37725 #else
37726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37727 #endif
37728 }
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37736 PyObject *resultobj = 0;
37737 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37738 wxString *arg2 = 0 ;
37739 void *argp1 = 0 ;
37740 int res1 = 0 ;
37741 bool temp2 = false ;
37742 PyObject * obj0 = 0 ;
37743 PyObject * obj1 = 0 ;
37744 char * kwnames[] = {
37745 (char *) "self",(char *) "version", NULL
37746 };
37747
37748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37750 if (!SWIG_IsOK(res1)) {
37751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37752 }
37753 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37754 {
37755 arg2 = wxString_in_helper(obj1);
37756 if (arg2 == NULL) SWIG_fail;
37757 temp2 = true;
37758 }
37759 {
37760 PyThreadState* __tstate = wxPyBeginAllowThreads();
37761 (arg1)->SetVersion((wxString const &)*arg2);
37762 wxPyEndAllowThreads(__tstate);
37763 if (PyErr_Occurred()) SWIG_fail;
37764 }
37765 resultobj = SWIG_Py_Void();
37766 {
37767 if (temp2)
37768 delete arg2;
37769 }
37770 return resultobj;
37771 fail:
37772 {
37773 if (temp2)
37774 delete arg2;
37775 }
37776 return NULL;
37777 }
37778
37779
37780 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37781 PyObject *resultobj = 0;
37782 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37783 bool result;
37784 void *argp1 = 0 ;
37785 int res1 = 0 ;
37786 PyObject *swig_obj[1] ;
37787
37788 if (!args) SWIG_fail;
37789 swig_obj[0] = args;
37790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37791 if (!SWIG_IsOK(res1)) {
37792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37793 }
37794 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37795 {
37796 PyThreadState* __tstate = wxPyBeginAllowThreads();
37797 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37798 wxPyEndAllowThreads(__tstate);
37799 if (PyErr_Occurred()) SWIG_fail;
37800 }
37801 {
37802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37803 }
37804 return resultobj;
37805 fail:
37806 return NULL;
37807 }
37808
37809
37810 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37811 PyObject *resultobj = 0;
37812 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37813 wxString result;
37814 void *argp1 = 0 ;
37815 int res1 = 0 ;
37816 PyObject *swig_obj[1] ;
37817
37818 if (!args) SWIG_fail;
37819 swig_obj[0] = args;
37820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37821 if (!SWIG_IsOK(res1)) {
37822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37823 }
37824 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37825 {
37826 PyThreadState* __tstate = wxPyBeginAllowThreads();
37827 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37828 wxPyEndAllowThreads(__tstate);
37829 if (PyErr_Occurred()) SWIG_fail;
37830 }
37831 {
37832 #if wxUSE_UNICODE
37833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37834 #else
37835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37836 #endif
37837 }
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37845 PyObject *resultobj = 0;
37846 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37847 wxString *arg2 = 0 ;
37848 void *argp1 = 0 ;
37849 int res1 = 0 ;
37850 bool temp2 = false ;
37851 PyObject * obj0 = 0 ;
37852 PyObject * obj1 = 0 ;
37853 char * kwnames[] = {
37854 (char *) "self",(char *) "desc", NULL
37855 };
37856
37857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37859 if (!SWIG_IsOK(res1)) {
37860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37861 }
37862 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37863 {
37864 arg2 = wxString_in_helper(obj1);
37865 if (arg2 == NULL) SWIG_fail;
37866 temp2 = true;
37867 }
37868 {
37869 PyThreadState* __tstate = wxPyBeginAllowThreads();
37870 (arg1)->SetDescription((wxString const &)*arg2);
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 resultobj = SWIG_Py_Void();
37875 {
37876 if (temp2)
37877 delete arg2;
37878 }
37879 return resultobj;
37880 fail:
37881 {
37882 if (temp2)
37883 delete arg2;
37884 }
37885 return NULL;
37886 }
37887
37888
37889 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37890 PyObject *resultobj = 0;
37891 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37892 bool result;
37893 void *argp1 = 0 ;
37894 int res1 = 0 ;
37895 PyObject *swig_obj[1] ;
37896
37897 if (!args) SWIG_fail;
37898 swig_obj[0] = args;
37899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37900 if (!SWIG_IsOK(res1)) {
37901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37902 }
37903 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37904 {
37905 PyThreadState* __tstate = wxPyBeginAllowThreads();
37906 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37907 wxPyEndAllowThreads(__tstate);
37908 if (PyErr_Occurred()) SWIG_fail;
37909 }
37910 {
37911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37912 }
37913 return resultobj;
37914 fail:
37915 return NULL;
37916 }
37917
37918
37919 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37920 PyObject *resultobj = 0;
37921 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37922 wxString result;
37923 void *argp1 = 0 ;
37924 int res1 = 0 ;
37925 PyObject *swig_obj[1] ;
37926
37927 if (!args) SWIG_fail;
37928 swig_obj[0] = args;
37929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37930 if (!SWIG_IsOK(res1)) {
37931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37932 }
37933 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37934 {
37935 PyThreadState* __tstate = wxPyBeginAllowThreads();
37936 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37937 wxPyEndAllowThreads(__tstate);
37938 if (PyErr_Occurred()) SWIG_fail;
37939 }
37940 {
37941 #if wxUSE_UNICODE
37942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37943 #else
37944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37945 #endif
37946 }
37947 return resultobj;
37948 fail:
37949 return NULL;
37950 }
37951
37952
37953 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37954 PyObject *resultobj = 0;
37955 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37956 wxString *arg2 = 0 ;
37957 void *argp1 = 0 ;
37958 int res1 = 0 ;
37959 bool temp2 = false ;
37960 PyObject * obj0 = 0 ;
37961 PyObject * obj1 = 0 ;
37962 char * kwnames[] = {
37963 (char *) "self",(char *) "copyright", NULL
37964 };
37965
37966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37968 if (!SWIG_IsOK(res1)) {
37969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37970 }
37971 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37972 {
37973 arg2 = wxString_in_helper(obj1);
37974 if (arg2 == NULL) SWIG_fail;
37975 temp2 = true;
37976 }
37977 {
37978 PyThreadState* __tstate = wxPyBeginAllowThreads();
37979 (arg1)->SetCopyright((wxString const &)*arg2);
37980 wxPyEndAllowThreads(__tstate);
37981 if (PyErr_Occurred()) SWIG_fail;
37982 }
37983 resultobj = SWIG_Py_Void();
37984 {
37985 if (temp2)
37986 delete arg2;
37987 }
37988 return resultobj;
37989 fail:
37990 {
37991 if (temp2)
37992 delete arg2;
37993 }
37994 return NULL;
37995 }
37996
37997
37998 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37999 PyObject *resultobj = 0;
38000 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38001 bool result;
38002 void *argp1 = 0 ;
38003 int res1 = 0 ;
38004 PyObject *swig_obj[1] ;
38005
38006 if (!args) SWIG_fail;
38007 swig_obj[0] = args;
38008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38009 if (!SWIG_IsOK(res1)) {
38010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38011 }
38012 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38013 {
38014 PyThreadState* __tstate = wxPyBeginAllowThreads();
38015 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
38016 wxPyEndAllowThreads(__tstate);
38017 if (PyErr_Occurred()) SWIG_fail;
38018 }
38019 {
38020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38021 }
38022 return resultobj;
38023 fail:
38024 return NULL;
38025 }
38026
38027
38028 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38029 PyObject *resultobj = 0;
38030 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38031 wxString result;
38032 void *argp1 = 0 ;
38033 int res1 = 0 ;
38034 PyObject *swig_obj[1] ;
38035
38036 if (!args) SWIG_fail;
38037 swig_obj[0] = args;
38038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38039 if (!SWIG_IsOK(res1)) {
38040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38041 }
38042 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38043 {
38044 PyThreadState* __tstate = wxPyBeginAllowThreads();
38045 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
38046 wxPyEndAllowThreads(__tstate);
38047 if (PyErr_Occurred()) SWIG_fail;
38048 }
38049 {
38050 #if wxUSE_UNICODE
38051 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38052 #else
38053 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38054 #endif
38055 }
38056 return resultobj;
38057 fail:
38058 return NULL;
38059 }
38060
38061
38062 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38063 PyObject *resultobj = 0;
38064 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38065 wxString *arg2 = 0 ;
38066 void *argp1 = 0 ;
38067 int res1 = 0 ;
38068 bool temp2 = false ;
38069 PyObject * obj0 = 0 ;
38070 PyObject * obj1 = 0 ;
38071 char * kwnames[] = {
38072 (char *) "self",(char *) "licence", NULL
38073 };
38074
38075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38077 if (!SWIG_IsOK(res1)) {
38078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38079 }
38080 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38081 {
38082 arg2 = wxString_in_helper(obj1);
38083 if (arg2 == NULL) SWIG_fail;
38084 temp2 = true;
38085 }
38086 {
38087 PyThreadState* __tstate = wxPyBeginAllowThreads();
38088 (arg1)->SetLicence((wxString const &)*arg2);
38089 wxPyEndAllowThreads(__tstate);
38090 if (PyErr_Occurred()) SWIG_fail;
38091 }
38092 resultobj = SWIG_Py_Void();
38093 {
38094 if (temp2)
38095 delete arg2;
38096 }
38097 return resultobj;
38098 fail:
38099 {
38100 if (temp2)
38101 delete arg2;
38102 }
38103 return NULL;
38104 }
38105
38106
38107 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38108 PyObject *resultobj = 0;
38109 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38110 wxString *arg2 = 0 ;
38111 void *argp1 = 0 ;
38112 int res1 = 0 ;
38113 bool temp2 = false ;
38114 PyObject * obj0 = 0 ;
38115 PyObject * obj1 = 0 ;
38116 char * kwnames[] = {
38117 (char *) "self",(char *) "licence", NULL
38118 };
38119
38120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38122 if (!SWIG_IsOK(res1)) {
38123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38124 }
38125 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38126 {
38127 arg2 = wxString_in_helper(obj1);
38128 if (arg2 == NULL) SWIG_fail;
38129 temp2 = true;
38130 }
38131 {
38132 PyThreadState* __tstate = wxPyBeginAllowThreads();
38133 (arg1)->SetLicense((wxString const &)*arg2);
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 resultobj = SWIG_Py_Void();
38138 {
38139 if (temp2)
38140 delete arg2;
38141 }
38142 return resultobj;
38143 fail:
38144 {
38145 if (temp2)
38146 delete arg2;
38147 }
38148 return NULL;
38149 }
38150
38151
38152 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38153 PyObject *resultobj = 0;
38154 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38155 bool result;
38156 void *argp1 = 0 ;
38157 int res1 = 0 ;
38158 PyObject *swig_obj[1] ;
38159
38160 if (!args) SWIG_fail;
38161 swig_obj[0] = args;
38162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38163 if (!SWIG_IsOK(res1)) {
38164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38165 }
38166 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38167 {
38168 PyThreadState* __tstate = wxPyBeginAllowThreads();
38169 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38170 wxPyEndAllowThreads(__tstate);
38171 if (PyErr_Occurred()) SWIG_fail;
38172 }
38173 {
38174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38175 }
38176 return resultobj;
38177 fail:
38178 return NULL;
38179 }
38180
38181
38182 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38183 PyObject *resultobj = 0;
38184 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38185 wxString result;
38186 void *argp1 = 0 ;
38187 int res1 = 0 ;
38188 PyObject *swig_obj[1] ;
38189
38190 if (!args) SWIG_fail;
38191 swig_obj[0] = args;
38192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38193 if (!SWIG_IsOK(res1)) {
38194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38195 }
38196 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38197 {
38198 PyThreadState* __tstate = wxPyBeginAllowThreads();
38199 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38200 wxPyEndAllowThreads(__tstate);
38201 if (PyErr_Occurred()) SWIG_fail;
38202 }
38203 {
38204 #if wxUSE_UNICODE
38205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38206 #else
38207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38208 #endif
38209 }
38210 return resultobj;
38211 fail:
38212 return NULL;
38213 }
38214
38215
38216 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38217 PyObject *resultobj = 0;
38218 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38219 wxIcon *arg2 = 0 ;
38220 void *argp1 = 0 ;
38221 int res1 = 0 ;
38222 void *argp2 = 0 ;
38223 int res2 = 0 ;
38224 PyObject * obj0 = 0 ;
38225 PyObject * obj1 = 0 ;
38226 char * kwnames[] = {
38227 (char *) "self",(char *) "icon", NULL
38228 };
38229
38230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38232 if (!SWIG_IsOK(res1)) {
38233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38234 }
38235 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38237 if (!SWIG_IsOK(res2)) {
38238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38239 }
38240 if (!argp2) {
38241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38242 }
38243 arg2 = reinterpret_cast< wxIcon * >(argp2);
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 (arg1)->SetIcon((wxIcon const &)*arg2);
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 resultobj = SWIG_Py_Void();
38251 return resultobj;
38252 fail:
38253 return NULL;
38254 }
38255
38256
38257 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38258 PyObject *resultobj = 0;
38259 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38260 bool result;
38261 void *argp1 = 0 ;
38262 int res1 = 0 ;
38263 PyObject *swig_obj[1] ;
38264
38265 if (!args) SWIG_fail;
38266 swig_obj[0] = args;
38267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38268 if (!SWIG_IsOK(res1)) {
38269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38270 }
38271 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38272 {
38273 PyThreadState* __tstate = wxPyBeginAllowThreads();
38274 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38275 wxPyEndAllowThreads(__tstate);
38276 if (PyErr_Occurred()) SWIG_fail;
38277 }
38278 {
38279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38280 }
38281 return resultobj;
38282 fail:
38283 return NULL;
38284 }
38285
38286
38287 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38288 PyObject *resultobj = 0;
38289 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38290 wxIcon result;
38291 void *argp1 = 0 ;
38292 int res1 = 0 ;
38293 PyObject *swig_obj[1] ;
38294
38295 if (!args) SWIG_fail;
38296 swig_obj[0] = args;
38297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38298 if (!SWIG_IsOK(res1)) {
38299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38300 }
38301 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38302 {
38303 PyThreadState* __tstate = wxPyBeginAllowThreads();
38304 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38305 wxPyEndAllowThreads(__tstate);
38306 if (PyErr_Occurred()) SWIG_fail;
38307 }
38308 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38309 return resultobj;
38310 fail:
38311 return NULL;
38312 }
38313
38314
38315 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38316 PyObject *resultobj = 0;
38317 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38318 wxString *arg2 = 0 ;
38319 wxString const &arg3_defvalue = wxEmptyString ;
38320 wxString *arg3 = (wxString *) &arg3_defvalue ;
38321 void *argp1 = 0 ;
38322 int res1 = 0 ;
38323 bool temp2 = false ;
38324 bool temp3 = false ;
38325 PyObject * obj0 = 0 ;
38326 PyObject * obj1 = 0 ;
38327 PyObject * obj2 = 0 ;
38328 char * kwnames[] = {
38329 (char *) "self",(char *) "url",(char *) "desc", NULL
38330 };
38331
38332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38334 if (!SWIG_IsOK(res1)) {
38335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38336 }
38337 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38338 {
38339 arg2 = wxString_in_helper(obj1);
38340 if (arg2 == NULL) SWIG_fail;
38341 temp2 = true;
38342 }
38343 if (obj2) {
38344 {
38345 arg3 = wxString_in_helper(obj2);
38346 if (arg3 == NULL) SWIG_fail;
38347 temp3 = true;
38348 }
38349 }
38350 {
38351 PyThreadState* __tstate = wxPyBeginAllowThreads();
38352 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38353 wxPyEndAllowThreads(__tstate);
38354 if (PyErr_Occurred()) SWIG_fail;
38355 }
38356 resultobj = SWIG_Py_Void();
38357 {
38358 if (temp2)
38359 delete arg2;
38360 }
38361 {
38362 if (temp3)
38363 delete arg3;
38364 }
38365 return resultobj;
38366 fail:
38367 {
38368 if (temp2)
38369 delete arg2;
38370 }
38371 {
38372 if (temp3)
38373 delete arg3;
38374 }
38375 return NULL;
38376 }
38377
38378
38379 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38380 PyObject *resultobj = 0;
38381 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38382 wxString result;
38383 void *argp1 = 0 ;
38384 int res1 = 0 ;
38385 PyObject *swig_obj[1] ;
38386
38387 if (!args) SWIG_fail;
38388 swig_obj[0] = args;
38389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38390 if (!SWIG_IsOK(res1)) {
38391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38392 }
38393 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38394 {
38395 PyThreadState* __tstate = wxPyBeginAllowThreads();
38396 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38397 wxPyEndAllowThreads(__tstate);
38398 if (PyErr_Occurred()) SWIG_fail;
38399 }
38400 {
38401 #if wxUSE_UNICODE
38402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38403 #else
38404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38405 #endif
38406 }
38407 return resultobj;
38408 fail:
38409 return NULL;
38410 }
38411
38412
38413 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38414 PyObject *resultobj = 0;
38415 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38416 wxString result;
38417 void *argp1 = 0 ;
38418 int res1 = 0 ;
38419 PyObject *swig_obj[1] ;
38420
38421 if (!args) SWIG_fail;
38422 swig_obj[0] = args;
38423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38424 if (!SWIG_IsOK(res1)) {
38425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38426 }
38427 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38428 {
38429 PyThreadState* __tstate = wxPyBeginAllowThreads();
38430 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38431 wxPyEndAllowThreads(__tstate);
38432 if (PyErr_Occurred()) SWIG_fail;
38433 }
38434 {
38435 #if wxUSE_UNICODE
38436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38437 #else
38438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38439 #endif
38440 }
38441 return resultobj;
38442 fail:
38443 return NULL;
38444 }
38445
38446
38447 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38448 PyObject *resultobj = 0;
38449 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38450 bool result;
38451 void *argp1 = 0 ;
38452 int res1 = 0 ;
38453 PyObject *swig_obj[1] ;
38454
38455 if (!args) SWIG_fail;
38456 swig_obj[0] = args;
38457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38458 if (!SWIG_IsOK(res1)) {
38459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38460 }
38461 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 {
38469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38470 }
38471 return resultobj;
38472 fail:
38473 return NULL;
38474 }
38475
38476
38477 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38478 PyObject *resultobj = 0;
38479 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38480 wxArrayString *arg2 = 0 ;
38481 void *argp1 = 0 ;
38482 int res1 = 0 ;
38483 bool temp2 = false ;
38484 PyObject * obj0 = 0 ;
38485 PyObject * obj1 = 0 ;
38486 char * kwnames[] = {
38487 (char *) "self",(char *) "developers", NULL
38488 };
38489
38490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38492 if (!SWIG_IsOK(res1)) {
38493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38494 }
38495 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38496 {
38497 if (! PySequence_Check(obj1)) {
38498 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38499 SWIG_fail;
38500 }
38501 arg2 = new wxArrayString;
38502 temp2 = true;
38503 int i, len=PySequence_Length(obj1);
38504 for (i=0; i<len; i++) {
38505 PyObject* item = PySequence_GetItem(obj1, i);
38506 wxString* s = wxString_in_helper(item);
38507 if (PyErr_Occurred()) SWIG_fail;
38508 arg2->Add(*s);
38509 delete s;
38510 Py_DECREF(item);
38511 }
38512 }
38513 {
38514 PyThreadState* __tstate = wxPyBeginAllowThreads();
38515 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38516 wxPyEndAllowThreads(__tstate);
38517 if (PyErr_Occurred()) SWIG_fail;
38518 }
38519 resultobj = SWIG_Py_Void();
38520 {
38521 if (temp2) delete arg2;
38522 }
38523 return resultobj;
38524 fail:
38525 {
38526 if (temp2) delete arg2;
38527 }
38528 return NULL;
38529 }
38530
38531
38532 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38533 PyObject *resultobj = 0;
38534 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38535 wxString *arg2 = 0 ;
38536 void *argp1 = 0 ;
38537 int res1 = 0 ;
38538 bool temp2 = false ;
38539 PyObject * obj0 = 0 ;
38540 PyObject * obj1 = 0 ;
38541 char * kwnames[] = {
38542 (char *) "self",(char *) "developer", NULL
38543 };
38544
38545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38547 if (!SWIG_IsOK(res1)) {
38548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38549 }
38550 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38551 {
38552 arg2 = wxString_in_helper(obj1);
38553 if (arg2 == NULL) SWIG_fail;
38554 temp2 = true;
38555 }
38556 {
38557 PyThreadState* __tstate = wxPyBeginAllowThreads();
38558 (arg1)->AddDeveloper((wxString const &)*arg2);
38559 wxPyEndAllowThreads(__tstate);
38560 if (PyErr_Occurred()) SWIG_fail;
38561 }
38562 resultobj = SWIG_Py_Void();
38563 {
38564 if (temp2)
38565 delete arg2;
38566 }
38567 return resultobj;
38568 fail:
38569 {
38570 if (temp2)
38571 delete arg2;
38572 }
38573 return NULL;
38574 }
38575
38576
38577 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38578 PyObject *resultobj = 0;
38579 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38580 bool result;
38581 void *argp1 = 0 ;
38582 int res1 = 0 ;
38583 PyObject *swig_obj[1] ;
38584
38585 if (!args) SWIG_fail;
38586 swig_obj[0] = args;
38587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38588 if (!SWIG_IsOK(res1)) {
38589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38590 }
38591 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38592 {
38593 PyThreadState* __tstate = wxPyBeginAllowThreads();
38594 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38595 wxPyEndAllowThreads(__tstate);
38596 if (PyErr_Occurred()) SWIG_fail;
38597 }
38598 {
38599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38600 }
38601 return resultobj;
38602 fail:
38603 return NULL;
38604 }
38605
38606
38607 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38608 PyObject *resultobj = 0;
38609 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38610 wxArrayString *result = 0 ;
38611 void *argp1 = 0 ;
38612 int res1 = 0 ;
38613 PyObject *swig_obj[1] ;
38614
38615 if (!args) SWIG_fail;
38616 swig_obj[0] = args;
38617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38618 if (!SWIG_IsOK(res1)) {
38619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38620 }
38621 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38622 {
38623 PyThreadState* __tstate = wxPyBeginAllowThreads();
38624 {
38625 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38626 result = (wxArrayString *) &_result_ref;
38627 }
38628 wxPyEndAllowThreads(__tstate);
38629 if (PyErr_Occurred()) SWIG_fail;
38630 }
38631 {
38632 resultobj = wxArrayString2PyList_helper(*result);
38633 }
38634 return resultobj;
38635 fail:
38636 return NULL;
38637 }
38638
38639
38640 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38641 PyObject *resultobj = 0;
38642 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38643 wxArrayString *arg2 = 0 ;
38644 void *argp1 = 0 ;
38645 int res1 = 0 ;
38646 bool temp2 = false ;
38647 PyObject * obj0 = 0 ;
38648 PyObject * obj1 = 0 ;
38649 char * kwnames[] = {
38650 (char *) "self",(char *) "docwriters", NULL
38651 };
38652
38653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38655 if (!SWIG_IsOK(res1)) {
38656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38657 }
38658 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38659 {
38660 if (! PySequence_Check(obj1)) {
38661 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38662 SWIG_fail;
38663 }
38664 arg2 = new wxArrayString;
38665 temp2 = true;
38666 int i, len=PySequence_Length(obj1);
38667 for (i=0; i<len; i++) {
38668 PyObject* item = PySequence_GetItem(obj1, i);
38669 wxString* s = wxString_in_helper(item);
38670 if (PyErr_Occurred()) SWIG_fail;
38671 arg2->Add(*s);
38672 delete s;
38673 Py_DECREF(item);
38674 }
38675 }
38676 {
38677 PyThreadState* __tstate = wxPyBeginAllowThreads();
38678 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38679 wxPyEndAllowThreads(__tstate);
38680 if (PyErr_Occurred()) SWIG_fail;
38681 }
38682 resultobj = SWIG_Py_Void();
38683 {
38684 if (temp2) delete arg2;
38685 }
38686 return resultobj;
38687 fail:
38688 {
38689 if (temp2) delete arg2;
38690 }
38691 return NULL;
38692 }
38693
38694
38695 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38696 PyObject *resultobj = 0;
38697 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38698 wxString *arg2 = 0 ;
38699 void *argp1 = 0 ;
38700 int res1 = 0 ;
38701 bool temp2 = false ;
38702 PyObject * obj0 = 0 ;
38703 PyObject * obj1 = 0 ;
38704 char * kwnames[] = {
38705 (char *) "self",(char *) "docwriter", NULL
38706 };
38707
38708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38710 if (!SWIG_IsOK(res1)) {
38711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38712 }
38713 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38714 {
38715 arg2 = wxString_in_helper(obj1);
38716 if (arg2 == NULL) SWIG_fail;
38717 temp2 = true;
38718 }
38719 {
38720 PyThreadState* __tstate = wxPyBeginAllowThreads();
38721 (arg1)->AddDocWriter((wxString const &)*arg2);
38722 wxPyEndAllowThreads(__tstate);
38723 if (PyErr_Occurred()) SWIG_fail;
38724 }
38725 resultobj = SWIG_Py_Void();
38726 {
38727 if (temp2)
38728 delete arg2;
38729 }
38730 return resultobj;
38731 fail:
38732 {
38733 if (temp2)
38734 delete arg2;
38735 }
38736 return NULL;
38737 }
38738
38739
38740 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38741 PyObject *resultobj = 0;
38742 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38743 bool result;
38744 void *argp1 = 0 ;
38745 int res1 = 0 ;
38746 PyObject *swig_obj[1] ;
38747
38748 if (!args) SWIG_fail;
38749 swig_obj[0] = args;
38750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38751 if (!SWIG_IsOK(res1)) {
38752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38753 }
38754 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38755 {
38756 PyThreadState* __tstate = wxPyBeginAllowThreads();
38757 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38758 wxPyEndAllowThreads(__tstate);
38759 if (PyErr_Occurred()) SWIG_fail;
38760 }
38761 {
38762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38763 }
38764 return resultobj;
38765 fail:
38766 return NULL;
38767 }
38768
38769
38770 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38771 PyObject *resultobj = 0;
38772 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38773 wxArrayString *result = 0 ;
38774 void *argp1 = 0 ;
38775 int res1 = 0 ;
38776 PyObject *swig_obj[1] ;
38777
38778 if (!args) SWIG_fail;
38779 swig_obj[0] = args;
38780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38781 if (!SWIG_IsOK(res1)) {
38782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38783 }
38784 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38785 {
38786 PyThreadState* __tstate = wxPyBeginAllowThreads();
38787 {
38788 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38789 result = (wxArrayString *) &_result_ref;
38790 }
38791 wxPyEndAllowThreads(__tstate);
38792 if (PyErr_Occurred()) SWIG_fail;
38793 }
38794 {
38795 resultobj = wxArrayString2PyList_helper(*result);
38796 }
38797 return resultobj;
38798 fail:
38799 return NULL;
38800 }
38801
38802
38803 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38804 PyObject *resultobj = 0;
38805 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38806 wxArrayString *arg2 = 0 ;
38807 void *argp1 = 0 ;
38808 int res1 = 0 ;
38809 bool temp2 = false ;
38810 PyObject * obj0 = 0 ;
38811 PyObject * obj1 = 0 ;
38812 char * kwnames[] = {
38813 (char *) "self",(char *) "artists", NULL
38814 };
38815
38816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38818 if (!SWIG_IsOK(res1)) {
38819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38820 }
38821 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38822 {
38823 if (! PySequence_Check(obj1)) {
38824 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38825 SWIG_fail;
38826 }
38827 arg2 = new wxArrayString;
38828 temp2 = true;
38829 int i, len=PySequence_Length(obj1);
38830 for (i=0; i<len; i++) {
38831 PyObject* item = PySequence_GetItem(obj1, i);
38832 wxString* s = wxString_in_helper(item);
38833 if (PyErr_Occurred()) SWIG_fail;
38834 arg2->Add(*s);
38835 delete s;
38836 Py_DECREF(item);
38837 }
38838 }
38839 {
38840 PyThreadState* __tstate = wxPyBeginAllowThreads();
38841 (arg1)->SetArtists((wxArrayString const &)*arg2);
38842 wxPyEndAllowThreads(__tstate);
38843 if (PyErr_Occurred()) SWIG_fail;
38844 }
38845 resultobj = SWIG_Py_Void();
38846 {
38847 if (temp2) delete arg2;
38848 }
38849 return resultobj;
38850 fail:
38851 {
38852 if (temp2) delete arg2;
38853 }
38854 return NULL;
38855 }
38856
38857
38858 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38859 PyObject *resultobj = 0;
38860 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38861 wxString *arg2 = 0 ;
38862 void *argp1 = 0 ;
38863 int res1 = 0 ;
38864 bool temp2 = false ;
38865 PyObject * obj0 = 0 ;
38866 PyObject * obj1 = 0 ;
38867 char * kwnames[] = {
38868 (char *) "self",(char *) "artist", NULL
38869 };
38870
38871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38873 if (!SWIG_IsOK(res1)) {
38874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38875 }
38876 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38877 {
38878 arg2 = wxString_in_helper(obj1);
38879 if (arg2 == NULL) SWIG_fail;
38880 temp2 = true;
38881 }
38882 {
38883 PyThreadState* __tstate = wxPyBeginAllowThreads();
38884 (arg1)->AddArtist((wxString const &)*arg2);
38885 wxPyEndAllowThreads(__tstate);
38886 if (PyErr_Occurred()) SWIG_fail;
38887 }
38888 resultobj = SWIG_Py_Void();
38889 {
38890 if (temp2)
38891 delete arg2;
38892 }
38893 return resultobj;
38894 fail:
38895 {
38896 if (temp2)
38897 delete arg2;
38898 }
38899 return NULL;
38900 }
38901
38902
38903 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38904 PyObject *resultobj = 0;
38905 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38906 bool result;
38907 void *argp1 = 0 ;
38908 int res1 = 0 ;
38909 PyObject *swig_obj[1] ;
38910
38911 if (!args) SWIG_fail;
38912 swig_obj[0] = args;
38913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38914 if (!SWIG_IsOK(res1)) {
38915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38916 }
38917 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38918 {
38919 PyThreadState* __tstate = wxPyBeginAllowThreads();
38920 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38921 wxPyEndAllowThreads(__tstate);
38922 if (PyErr_Occurred()) SWIG_fail;
38923 }
38924 {
38925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38926 }
38927 return resultobj;
38928 fail:
38929 return NULL;
38930 }
38931
38932
38933 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38934 PyObject *resultobj = 0;
38935 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38936 wxArrayString *result = 0 ;
38937 void *argp1 = 0 ;
38938 int res1 = 0 ;
38939 PyObject *swig_obj[1] ;
38940
38941 if (!args) SWIG_fail;
38942 swig_obj[0] = args;
38943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38944 if (!SWIG_IsOK(res1)) {
38945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38946 }
38947 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38948 {
38949 PyThreadState* __tstate = wxPyBeginAllowThreads();
38950 {
38951 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38952 result = (wxArrayString *) &_result_ref;
38953 }
38954 wxPyEndAllowThreads(__tstate);
38955 if (PyErr_Occurred()) SWIG_fail;
38956 }
38957 {
38958 resultobj = wxArrayString2PyList_helper(*result);
38959 }
38960 return resultobj;
38961 fail:
38962 return NULL;
38963 }
38964
38965
38966 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38967 PyObject *resultobj = 0;
38968 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38969 wxArrayString *arg2 = 0 ;
38970 void *argp1 = 0 ;
38971 int res1 = 0 ;
38972 bool temp2 = false ;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 char * kwnames[] = {
38976 (char *) "self",(char *) "translators", NULL
38977 };
38978
38979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38981 if (!SWIG_IsOK(res1)) {
38982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38983 }
38984 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38985 {
38986 if (! PySequence_Check(obj1)) {
38987 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38988 SWIG_fail;
38989 }
38990 arg2 = new wxArrayString;
38991 temp2 = true;
38992 int i, len=PySequence_Length(obj1);
38993 for (i=0; i<len; i++) {
38994 PyObject* item = PySequence_GetItem(obj1, i);
38995 wxString* s = wxString_in_helper(item);
38996 if (PyErr_Occurred()) SWIG_fail;
38997 arg2->Add(*s);
38998 delete s;
38999 Py_DECREF(item);
39000 }
39001 }
39002 {
39003 PyThreadState* __tstate = wxPyBeginAllowThreads();
39004 (arg1)->SetTranslators((wxArrayString const &)*arg2);
39005 wxPyEndAllowThreads(__tstate);
39006 if (PyErr_Occurred()) SWIG_fail;
39007 }
39008 resultobj = SWIG_Py_Void();
39009 {
39010 if (temp2) delete arg2;
39011 }
39012 return resultobj;
39013 fail:
39014 {
39015 if (temp2) delete arg2;
39016 }
39017 return NULL;
39018 }
39019
39020
39021 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39022 PyObject *resultobj = 0;
39023 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39024 wxString *arg2 = 0 ;
39025 void *argp1 = 0 ;
39026 int res1 = 0 ;
39027 bool temp2 = false ;
39028 PyObject * obj0 = 0 ;
39029 PyObject * obj1 = 0 ;
39030 char * kwnames[] = {
39031 (char *) "self",(char *) "translator", NULL
39032 };
39033
39034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
39035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39036 if (!SWIG_IsOK(res1)) {
39037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
39038 }
39039 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39040 {
39041 arg2 = wxString_in_helper(obj1);
39042 if (arg2 == NULL) SWIG_fail;
39043 temp2 = true;
39044 }
39045 {
39046 PyThreadState* __tstate = wxPyBeginAllowThreads();
39047 (arg1)->AddTranslator((wxString const &)*arg2);
39048 wxPyEndAllowThreads(__tstate);
39049 if (PyErr_Occurred()) SWIG_fail;
39050 }
39051 resultobj = SWIG_Py_Void();
39052 {
39053 if (temp2)
39054 delete arg2;
39055 }
39056 return resultobj;
39057 fail:
39058 {
39059 if (temp2)
39060 delete arg2;
39061 }
39062 return NULL;
39063 }
39064
39065
39066 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39067 PyObject *resultobj = 0;
39068 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39069 bool result;
39070 void *argp1 = 0 ;
39071 int res1 = 0 ;
39072 PyObject *swig_obj[1] ;
39073
39074 if (!args) SWIG_fail;
39075 swig_obj[0] = args;
39076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39077 if (!SWIG_IsOK(res1)) {
39078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39079 }
39080 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39081 {
39082 PyThreadState* __tstate = wxPyBeginAllowThreads();
39083 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39084 wxPyEndAllowThreads(__tstate);
39085 if (PyErr_Occurred()) SWIG_fail;
39086 }
39087 {
39088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39089 }
39090 return resultobj;
39091 fail:
39092 return NULL;
39093 }
39094
39095
39096 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39097 PyObject *resultobj = 0;
39098 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39099 wxArrayString *result = 0 ;
39100 void *argp1 = 0 ;
39101 int res1 = 0 ;
39102 PyObject *swig_obj[1] ;
39103
39104 if (!args) SWIG_fail;
39105 swig_obj[0] = args;
39106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39107 if (!SWIG_IsOK(res1)) {
39108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39109 }
39110 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39111 {
39112 PyThreadState* __tstate = wxPyBeginAllowThreads();
39113 {
39114 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39115 result = (wxArrayString *) &_result_ref;
39116 }
39117 wxPyEndAllowThreads(__tstate);
39118 if (PyErr_Occurred()) SWIG_fail;
39119 }
39120 {
39121 resultobj = wxArrayString2PyList_helper(*result);
39122 }
39123 return resultobj;
39124 fail:
39125 return NULL;
39126 }
39127
39128
39129 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39130 PyObject *resultobj = 0;
39131 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39132 bool result;
39133 void *argp1 = 0 ;
39134 int res1 = 0 ;
39135 PyObject *swig_obj[1] ;
39136
39137 if (!args) SWIG_fail;
39138 swig_obj[0] = args;
39139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39140 if (!SWIG_IsOK(res1)) {
39141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39142 }
39143 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39144 {
39145 PyThreadState* __tstate = wxPyBeginAllowThreads();
39146 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39147 wxPyEndAllowThreads(__tstate);
39148 if (PyErr_Occurred()) SWIG_fail;
39149 }
39150 {
39151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39152 }
39153 return resultobj;
39154 fail:
39155 return NULL;
39156 }
39157
39158
39159 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39160 PyObject *resultobj = 0;
39161 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39162 wxString result;
39163 void *argp1 = 0 ;
39164 int res1 = 0 ;
39165 PyObject *swig_obj[1] ;
39166
39167 if (!args) SWIG_fail;
39168 swig_obj[0] = args;
39169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39170 if (!SWIG_IsOK(res1)) {
39171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39172 }
39173 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39174 {
39175 PyThreadState* __tstate = wxPyBeginAllowThreads();
39176 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39177 wxPyEndAllowThreads(__tstate);
39178 if (PyErr_Occurred()) SWIG_fail;
39179 }
39180 {
39181 #if wxUSE_UNICODE
39182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39183 #else
39184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39185 #endif
39186 }
39187 return resultobj;
39188 fail:
39189 return NULL;
39190 }
39191
39192
39193 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39194 PyObject *obj;
39195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39196 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39197 return SWIG_Py_Void();
39198 }
39199
39200 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39201 return SWIG_Python_InitShadowInstance(args);
39202 }
39203
39204 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39205 PyObject *resultobj = 0;
39206 wxAboutDialogInfo *arg1 = 0 ;
39207 void *argp1 = 0 ;
39208 int res1 = 0 ;
39209 PyObject * obj0 = 0 ;
39210 char * kwnames[] = {
39211 (char *) "info", NULL
39212 };
39213
39214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39215 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39216 if (!SWIG_IsOK(res1)) {
39217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39218 }
39219 if (!argp1) {
39220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39221 }
39222 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39223 {
39224 PyThreadState* __tstate = wxPyBeginAllowThreads();
39225 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39226 wxPyEndAllowThreads(__tstate);
39227 if (PyErr_Occurred()) SWIG_fail;
39228 }
39229 resultobj = SWIG_Py_Void();
39230 return resultobj;
39231 fail:
39232 return NULL;
39233 }
39234
39235
39236 static PyMethodDef SwigMethods[] = {
39237 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39238 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39239 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39241 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39242 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39243 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39244 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39245 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39250 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39251 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39252 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39253 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39254 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39256 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39257 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39258 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39259 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39260 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39261 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39262 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39263 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39264 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39265 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39267 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39268 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39269 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39270 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39271 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39272 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39274 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39276 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39277 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39278 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39279 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39280 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39281 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39282 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39283 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39284 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39285 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39286 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39287 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39291 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39292 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39293 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39295 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39296 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39297 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39298 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39299 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39300 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39301 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39302 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39303 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39304 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39305 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39306 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39307 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39308 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39310 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39311 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39312 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39313 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39314 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39318 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39319 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39320 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39321 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39322 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39323 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39324 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39325 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39326 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39327 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39328 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39329 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39330 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39333 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39334 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39335 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39336 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39337 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39338 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39339 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39340 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39341 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39342 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39343 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39344 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39345 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39346 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39347 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39348 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39349 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39350 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39351 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39352 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39353 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39354 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39355 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39357 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39358 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39360 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39361 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39362 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39363 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39364 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39365 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39366 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39367 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39368 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39369 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39370 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39371 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39372 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39373 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39374 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39375 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39376 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39377 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39378 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39379 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39380 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39381 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39382 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39383 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39384 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39385 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39386 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39387 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39388 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39389 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39390 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39391 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39392 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39394 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39395 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39396 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39397 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39398 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39399 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39400 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39403 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39408 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39411 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39412 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39413 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39415 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39416 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39418 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39419 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39420 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39421 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39422 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39423 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39424 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39425 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39426 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39427 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39428 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39429 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39430 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39431 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39432 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39433 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39434 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39435 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39436 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39437 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39438 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39439 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39440 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39442 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39443 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39446 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39447 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39448 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39449 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39450 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39451 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39452 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39453 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39455 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39456 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39457 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39458 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39459 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39460 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39461 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39462 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39463 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39466 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39467 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39468 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39469 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39470 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39471 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39472 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39473 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39474 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39475 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39476 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39477 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39478 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39479 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39480 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39481 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39482 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39483 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39484 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39485 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39486 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39487 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39488 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39489 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39490 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39491 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39492 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39493 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39494 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39495 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39498 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39499 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39500 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39501 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39502 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39503 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39504 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39505 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39507 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39508 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39510 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39511 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39512 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39513 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39514 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39515 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39516 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39517 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39518 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39519 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39520 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39521 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39522 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39523 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39524 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39527 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39528 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39529 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39530 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39531 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39532 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39533 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39534 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39536 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39537 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39538 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39539 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39540 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39541 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39542 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39543 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39544 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39545 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39546 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39548 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39551 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39552 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39553 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39554 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39555 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39557 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39559 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39560 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39561 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39562 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39563 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39564 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39565 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39566 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39571 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39572 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39573 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39575 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39576 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39577 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39578 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39579 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39580 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39581 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39582 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39583 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39584 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39585 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39586 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39588 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39589 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39590 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39591 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39592 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39593 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39594 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39595 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39598 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39599 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39600 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39601 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39602 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39603 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39604 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39605 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39606 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39607 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39608 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39610 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39611 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39612 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39613 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39614 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39615 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39616 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39617 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39618 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39619 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39620 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39621 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39622 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39623 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39624 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39625 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39626 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39627 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39628 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39629 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39630 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39631 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39632 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39633 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39634 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39635 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39636 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39637 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39638 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39639 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39641 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39642 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39643 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39644 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39645 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39646 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39647 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39648 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39649 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39655 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39656 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39657 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39661 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39662 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39665 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39668 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39671 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39672 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39673 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39676 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39677 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39680 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39681 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39682 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39683 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39684 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39685 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39686 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39687 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39688 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39689 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39690 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39692 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39693 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39694 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39695 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39696 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39697 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39698 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39704 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39706 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39707 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39709 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39711 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39716 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39720 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39721 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39722 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39723 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39724 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39728 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39733 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39734 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39735 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39736 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39739 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39740 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39742 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39743 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39745 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39766 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39768 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39770 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39772 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39773 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39777 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39778 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39780 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39781 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39782 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39784 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39785 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39786 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39788 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39789 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39790 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39791 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39794 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39805 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39809 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39810 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39811 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39812 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39818 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39819 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39824 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39825 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39849 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39850 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39851 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39852 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39853 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39865 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39866 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39892 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39893 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39894 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39895 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39908 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39909 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39910 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39911 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39912 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39913 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39915 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39917 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39919 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39921 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39923 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39925 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39927 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39931 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39932 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39935 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39936 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39947 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39948 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39949 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39953 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39954 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39955 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39956 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39957 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39958 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39960 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39961 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39963 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39964 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39965 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39967 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39969 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39970 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39971 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39975 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39976 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39977 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39978 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39979 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39980 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39983 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39987 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39992 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39994 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39995 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39996 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39997 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39998 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39999 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
40000 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
40003 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
40004 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
40005 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
40007 { (char *)"DataFormat__GetId", (PyCFunction)_wrap_DataFormat__GetId, METH_O, NULL},
40008 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
40009 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
40010 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
40011 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
40012 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
40016 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40019 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
40020 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
40022 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40023 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
40024 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
40025 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
40027 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
40028 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
40031 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
40032 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
40033 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
40034 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
40035 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
40036 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
40037 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40038 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
40039 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
40040 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
40042 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
40043 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
40046 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
40047 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40048 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
40049 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
40051 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
40052 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40053 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40054 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
40055 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
40056 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
40057 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
40058 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
40059 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
40060 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40061 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40062 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40063 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40064 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40065 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40066 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40067 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40069 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40070 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40071 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40072 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40073 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
40074 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
40075 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40076 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40077 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40078 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40081 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40082 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40083 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40084 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40085 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40086 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40087 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40088 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40091 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40092 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40093 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40094 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40095 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40096 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40097 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40098 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40099 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40100 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40101 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40102 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40103 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40105 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40106 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40107 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40108 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40109 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40110 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40111 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40112 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40113 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40114 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40115 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40116 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40117 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40118 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40119 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40120 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40121 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40122 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40123 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40124 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40125 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40126 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40127 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40128 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40129 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40130 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40131 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40132 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40133 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40134 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40135 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40136 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40137 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40138 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40139 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40140 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40141 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40142 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40143 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40144 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40145 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40146 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40147 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40148 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40149 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40150 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40151 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40152 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40153 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40154 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40155 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40156 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40157 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40158 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40159 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40160 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40161 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40162 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40163 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40164 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40165 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40166 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40167 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40168 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40169 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40170 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40171 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40172 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40173 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40174 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40175 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40176 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40177 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40178 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40179 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40180 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40181 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40182 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40183 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40184 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40185 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40186 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40187 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40188 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40189 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40190 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40191 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40192 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40193 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40194 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40195 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40196 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40197 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40198 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40199 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40200 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40201 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40202 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40203 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40204 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40205 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40206 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40207 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40208 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40209 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40210 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40211 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40212 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40213 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40214 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40215 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40216 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40217 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40218 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40219 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40220 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40221 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40222 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40223 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40224 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40225 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40226 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40227 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40228 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40229 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40230 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40231 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40232 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40233 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40234 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40235 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40236 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40237 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40238 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40239 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40240 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40241 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40242 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40243 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40244 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40245 { NULL, NULL, 0, NULL }
40246 };
40247
40248
40249 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40250
40251 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40253 }
40254 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40255 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40256 }
40257 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40258 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40259 }
40260 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40261 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40262 }
40263 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40264 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40265 }
40266 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40267 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40268 }
40269 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40270 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40271 }
40272 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40273 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40274 }
40275 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40276 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40277 }
40278 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40280 }
40281 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40282 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40283 }
40284 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40285 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40286 }
40287 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40288 return (void *)((wxEvent *) ((wxPyEvent *) x));
40289 }
40290 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40291 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40292 }
40293 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40294 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40295 }
40296 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40297 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40298 }
40299 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40300 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40301 }
40302 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40303 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40304 }
40305 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40306 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40307 }
40308 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40309 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40310 }
40311 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40312 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40313 }
40314 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40315 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40316 }
40317 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40318 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40319 }
40320 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40321 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40322 }
40323 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40324 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40325 }
40326 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40327 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40328 }
40329 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40330 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40331 }
40332 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40333 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40334 }
40335 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40336 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40337 }
40338 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40339 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40340 }
40341 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40342 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40343 }
40344 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40345 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40346 }
40347 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40348 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40349 }
40350 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40351 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40352 }
40353 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40354 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40355 }
40356 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40357 return (void *)((wxEvent *) ((wxShowEvent *) x));
40358 }
40359 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40360 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40361 }
40362 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40363 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40364 }
40365 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40366 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40367 }
40368 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40369 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40370 }
40371 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40372 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40373 }
40374 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40375 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40376 }
40377 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40378 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40379 }
40380 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40381 return (void *)((wxConfigBase *) ((wxConfig *) x));
40382 }
40383 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40384 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40385 }
40386 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40387 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40388 }
40389 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40390 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40391 }
40392 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40393 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40394 }
40395 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40396 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40397 }
40398 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40399 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40400 }
40401 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40402 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40403 }
40404 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40405 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40406 }
40407 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40408 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40409 }
40410 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40411 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40412 }
40413 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40414 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40415 }
40416 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40417 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40418 }
40419 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40420 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40421 }
40422 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40423 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40424 }
40425 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40426 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40427 }
40428 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40429 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40430 }
40431 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40432 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40433 }
40434 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40435 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40436 }
40437 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40438 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40439 }
40440 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40441 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40442 }
40443 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40444 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40445 }
40446 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40447 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40448 }
40449 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40450 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40451 }
40452 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40453 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40454 }
40455 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40456 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40457 }
40458 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40459 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40460 }
40461 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40462 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40463 }
40464 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40465 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40466 }
40467 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40468 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40469 }
40470 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
40471 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
40472 }
40473 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40474 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40475 }
40476 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40477 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40478 }
40479 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40480 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40481 }
40482 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40483 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40484 }
40485 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
40486 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
40487 }
40488 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40489 return (void *)((wxObject *) ((wxSizerItem *) x));
40490 }
40491 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40492 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40493 }
40494 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40496 }
40497 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40498 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40499 }
40500 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40501 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40502 }
40503 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40504 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40505 }
40506 static void *_p_wxSizerTo_p_wxObject(void *x) {
40507 return (void *)((wxObject *) ((wxSizer *) x));
40508 }
40509 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40510 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40511 }
40512 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40513 return (void *)((wxObject *) ((wxFileHistory *) x));
40514 }
40515 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40517 }
40518 static void *_p_wxEventTo_p_wxObject(void *x) {
40519 return (void *)((wxObject *) ((wxEvent *) x));
40520 }
40521 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40522 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40523 }
40524 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40525 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40526 }
40527 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40528 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40529 }
40530 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40532 }
40533 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40534 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40535 }
40536 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40537 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40538 }
40539 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40540 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40541 }
40542 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40543 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40544 }
40545 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40546 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40547 }
40548 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40549 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40550 }
40551 static void *_p_wxControlTo_p_wxObject(void *x) {
40552 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40553 }
40554 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40555 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40556 }
40557 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40558 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40559 }
40560 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40561 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40562 }
40563 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40564 return (void *)((wxObject *) ((wxFSFile *) x));
40565 }
40566 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40567 return (void *)((wxObject *) ((wxClipboard *) x));
40568 }
40569 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40570 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40571 }
40572 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40573 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40574 }
40575 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40576 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40577 }
40578 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40579 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40580 }
40581 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40582 return (void *)((wxObject *) ((wxToolTip *) x));
40583 }
40584 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40585 return (void *)((wxObject *) ((wxMenuItem *) x));
40586 }
40587 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40588 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40589 }
40590 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40591 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40592 }
40593 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40594 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40595 }
40596 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40597 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40598 }
40599 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40600 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40601 }
40602 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40603 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40604 }
40605 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40606 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40607 }
40608 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40609 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40610 }
40611 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40612 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40613 }
40614 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40615 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40616 }
40617 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40618 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40619 }
40620 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40621 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40622 }
40623 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40624 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40625 }
40626 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40627 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40628 }
40629 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40630 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40631 }
40632 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40633 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40634 }
40635 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40636 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40637 }
40638 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40639 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40640 }
40641 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40642 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40643 }
40644 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40645 return (void *)((wxObject *) ((wxImageHandler *) x));
40646 }
40647 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40648 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40649 }
40650 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40651 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40652 }
40653 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40654 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40655 }
40656 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40657 return (void *)((wxObject *) ((wxEvtHandler *) x));
40658 }
40659 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40660 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40661 }
40662 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40663 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40664 }
40665 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40666 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40667 }
40668 static void *_p_wxImageTo_p_wxObject(void *x) {
40669 return (void *)((wxObject *) ((wxImage *) x));
40670 }
40671 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40672 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40673 }
40674 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40675 return (void *)((wxObject *) ((wxSystemOptions *) x));
40676 }
40677 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40678 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40679 }
40680 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40681 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40682 }
40683 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40684 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40685 }
40686 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40687 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40688 }
40689 static void *_p_wxWindowTo_p_wxObject(void *x) {
40690 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40691 }
40692 static void *_p_wxMenuTo_p_wxObject(void *x) {
40693 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40694 }
40695 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40696 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40697 }
40698 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40699 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40700 }
40701 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40702 return (void *)((wxObject *) ((wxFileSystem *) x));
40703 }
40704 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40705 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40706 }
40707 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40708 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40709 }
40710 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40711 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40712 }
40713 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40714 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40715 }
40716 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40717 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40718 }
40719 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40720 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40721 }
40722 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40723 return (void *)((wxObject *) ((wxBusyInfo *) x));
40724 }
40725 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40726 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40727 }
40728 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40729 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40730 }
40731 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40732 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40733 }
40734 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40735 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40736 }
40737 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40738 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40739 }
40740 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40741 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40742 }
40743 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40744 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40745 }
40746 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40747 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40748 }
40749 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40750 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40751 }
40752 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40753 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40754 }
40755 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40756 return (void *)((wxLog *) ((wxLogBuffer *) x));
40757 }
40758 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40759 return (void *)((wxLog *) ((wxLogStderr *) x));
40760 }
40761 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40762 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40763 }
40764 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40765 return (void *)((wxLog *) ((wxLogWindow *) x));
40766 }
40767 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40768 return (void *)((wxLog *) ((wxLogChain *) x));
40769 }
40770 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40771 return (void *)((wxLog *) ((wxLogGui *) x));
40772 }
40773 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40774 return (void *)((wxLog *) ((wxPyLog *) x));
40775 }
40776 static void *_p_wxControlTo_p_wxWindow(void *x) {
40777 return (void *)((wxWindow *) ((wxControl *) x));
40778 }
40779 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40780 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40781 }
40782 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40783 return (void *)((wxWindow *) ((wxMenuBar *) x));
40784 }
40785 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40786 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40787 }
40788 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40789 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40790 }
40791 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40792 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};
40793 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40812 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40813 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40814 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40815 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40816 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40818 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40819 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40820 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40821 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40822 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40823 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40824 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40825 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40828 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40832 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40833 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40835 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40836 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40837 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40838 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40839 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40840 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40841 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40842 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40843 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40844 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40845 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40846 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40847 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40848 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40849 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40850 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40851 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40852 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40853 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40854 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40855 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40856 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40857 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40858 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40859 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40860 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40861 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40862 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40863 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40865 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40866 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40867 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40868 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40869 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40870 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
40871 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40875 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40876 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40877 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40878 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40879 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40880 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40881 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40882 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40883 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40884 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40885 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40886 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40887 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40888 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40889 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40890 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40891 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40892 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40893 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40894 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40895 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40896 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40897 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40898 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40899 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40900 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40901 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40902 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40903 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40904 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40905 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40906 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40907 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40908 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40909 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40910 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40911 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40912 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40913 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40914 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40915 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40916 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40917 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40918 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40919 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40920 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40921 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40922 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40923 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40924 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40925 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40926 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40927 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40928 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40929 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40930 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40931 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40932 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40933 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40934 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40935 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40936 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40937 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40938 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40939 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40940 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40941 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40942 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40943 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40944 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40945 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40946 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40947 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40948 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40949 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40950 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40951 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40952 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40953 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40954 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40955 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40956 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40957 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40958 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40959 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40960 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40961 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40962 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40963 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40964 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40965 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40966 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40967
40968 static swig_type_info *swig_type_initial[] = {
40969 &_swigt__p_char,
40970 &_swigt__p_form_ops_t,
40971 &_swigt__p_int,
40972 &_swigt__p_unsigned_char,
40973 &_swigt__p_unsigned_int,
40974 &_swigt__p_unsigned_long,
40975 &_swigt__p_void,
40976 &_swigt__p_wxANIHandler,
40977 &_swigt__p_wxAboutDialogInfo,
40978 &_swigt__p_wxAcceleratorTable,
40979 &_swigt__p_wxActivateEvent,
40980 &_swigt__p_wxArrayString,
40981 &_swigt__p_wxBMPHandler,
40982 &_swigt__p_wxBitmap,
40983 &_swigt__p_wxBitmapDataObject,
40984 &_swigt__p_wxBoxSizer,
40985 &_swigt__p_wxBusyCursor,
40986 &_swigt__p_wxBusyInfo,
40987 &_swigt__p_wxCURHandler,
40988 &_swigt__p_wxCaret,
40989 &_swigt__p_wxChar,
40990 &_swigt__p_wxChildFocusEvent,
40991 &_swigt__p_wxClipboard,
40992 &_swigt__p_wxClipboardLocker,
40993 &_swigt__p_wxClipboardTextEvent,
40994 &_swigt__p_wxCloseEvent,
40995 &_swigt__p_wxColour,
40996 &_swigt__p_wxCommandEvent,
40997 &_swigt__p_wxConfig,
40998 &_swigt__p_wxConfigBase,
40999 &_swigt__p_wxConfigPathChanger,
41000 &_swigt__p_wxContextMenuEvent,
41001 &_swigt__p_wxControl,
41002 &_swigt__p_wxControlWithItems,
41003 &_swigt__p_wxCursor,
41004 &_swigt__p_wxCustomDataObject,
41005 &_swigt__p_wxDC,
41006 &_swigt__p_wxDataFormat,
41007 &_swigt__p_wxDataObject,
41008 &_swigt__p_wxDataObjectComposite,
41009 &_swigt__p_wxDataObjectSimple,
41010 &_swigt__p_wxDateEvent,
41011 &_swigt__p_wxDateSpan,
41012 &_swigt__p_wxDateTime,
41013 &_swigt__p_wxDateTime__TimeZone,
41014 &_swigt__p_wxDisplay,
41015 &_swigt__p_wxDisplayChangedEvent,
41016 &_swigt__p_wxDropFilesEvent,
41017 &_swigt__p_wxDuplexMode,
41018 &_swigt__p_wxEraseEvent,
41019 &_swigt__p_wxEvent,
41020 &_swigt__p_wxEventBlocker,
41021 &_swigt__p_wxEvtHandler,
41022 &_swigt__p_wxFSFile,
41023 &_swigt__p_wxFileConfig,
41024 &_swigt__p_wxFileDataObject,
41025 &_swigt__p_wxFileHistory,
41026 &_swigt__p_wxFileSystem,
41027 &_swigt__p_wxFileType,
41028 &_swigt__p_wxFileTypeInfo,
41029 &_swigt__p_wxFlexGridSizer,
41030 &_swigt__p_wxFocusEvent,
41031 &_swigt__p_wxFont,
41032 &_swigt__p_wxFrame,
41033 &_swigt__p_wxGBSizerItem,
41034 &_swigt__p_wxGIFHandler,
41035 &_swigt__p_wxGridBagSizer,
41036 &_swigt__p_wxGridSizer,
41037 &_swigt__p_wxICOHandler,
41038 &_swigt__p_wxIcon,
41039 &_swigt__p_wxIconizeEvent,
41040 &_swigt__p_wxIdleEvent,
41041 &_swigt__p_wxImage,
41042 &_swigt__p_wxImageHandler,
41043 &_swigt__p_wxIndividualLayoutConstraint,
41044 &_swigt__p_wxInitDialogEvent,
41045 &_swigt__p_wxJPEGHandler,
41046 &_swigt__p_wxJoystick,
41047 &_swigt__p_wxJoystickEvent,
41048 &_swigt__p_wxKeyEvent,
41049 &_swigt__p_wxKillError,
41050 &_swigt__p_wxLayoutConstraints,
41051 &_swigt__p_wxLog,
41052 &_swigt__p_wxLogBuffer,
41053 &_swigt__p_wxLogChain,
41054 &_swigt__p_wxLogGui,
41055 &_swigt__p_wxLogNull,
41056 &_swigt__p_wxLogStderr,
41057 &_swigt__p_wxLogTextCtrl,
41058 &_swigt__p_wxLogWindow,
41059 &_swigt__p_wxMaximizeEvent,
41060 &_swigt__p_wxMenu,
41061 &_swigt__p_wxMenuBar,
41062 &_swigt__p_wxMenuEvent,
41063 &_swigt__p_wxMenuItem,
41064 &_swigt__p_wxMetafile,
41065 &_swigt__p_wxMetafileDataObject,
41066 &_swigt__p_wxMimeTypesManager,
41067 &_swigt__p_wxMouseCaptureChangedEvent,
41068 &_swigt__p_wxMouseCaptureLostEvent,
41069 &_swigt__p_wxMouseEvent,
41070 &_swigt__p_wxMouseState,
41071 &_swigt__p_wxMoveEvent,
41072 &_swigt__p_wxMutexGuiLocker,
41073 &_swigt__p_wxNavigationKeyEvent,
41074 &_swigt__p_wxNcPaintEvent,
41075 &_swigt__p_wxNotifyEvent,
41076 &_swigt__p_wxObject,
41077 &_swigt__p_wxOutputStream,
41078 &_swigt__p_wxPCXHandler,
41079 &_swigt__p_wxPNGHandler,
41080 &_swigt__p_wxPNMHandler,
41081 &_swigt__p_wxPaintEvent,
41082 &_swigt__p_wxPaletteChangedEvent,
41083 &_swigt__p_wxPaperSize,
41084 &_swigt__p_wxPlatformInfo,
41085 &_swigt__p_wxPoint,
41086 &_swigt__p_wxPowerEvent,
41087 &_swigt__p_wxProcessEvent,
41088 &_swigt__p_wxPyApp,
41089 &_swigt__p_wxPyArtProvider,
41090 &_swigt__p_wxPyBitmapDataObject,
41091 &_swigt__p_wxPyCommandEvent,
41092 &_swigt__p_wxPyDataObjectSimple,
41093 &_swigt__p_wxPyDropSource,
41094 &_swigt__p_wxPyDropTarget,
41095 &_swigt__p_wxPyEvent,
41096 &_swigt__p_wxPyFileDropTarget,
41097 &_swigt__p_wxPyImageHandler,
41098 &_swigt__p_wxPyLog,
41099 &_swigt__p_wxPyProcess,
41100 &_swigt__p_wxPySizer,
41101 &_swigt__p_wxPyTextDataObject,
41102 &_swigt__p_wxPyTextDropTarget,
41103 &_swigt__p_wxPyTimer,
41104 &_swigt__p_wxPyTipProvider,
41105 &_swigt__p_wxPyValidator,
41106 &_swigt__p_wxQueryNewPaletteEvent,
41107 &_swigt__p_wxRect,
41108 &_swigt__p_wxScrollEvent,
41109 &_swigt__p_wxScrollWinEvent,
41110 &_swigt__p_wxSetCursorEvent,
41111 &_swigt__p_wxShowEvent,
41112 &_swigt__p_wxSingleInstanceChecker,
41113 &_swigt__p_wxSize,
41114 &_swigt__p_wxSizeEvent,
41115 &_swigt__p_wxSizer,
41116 &_swigt__p_wxSizerItem,
41117 &_swigt__p_wxSound,
41118 &_swigt__p_wxStandardPaths,
41119 &_swigt__p_wxStaticBoxSizer,
41120 &_swigt__p_wxStdDialogButtonSizer,
41121 &_swigt__p_wxStopWatch,
41122 &_swigt__p_wxString,
41123 &_swigt__p_wxSysColourChangedEvent,
41124 &_swigt__p_wxSystemOptions,
41125 &_swigt__p_wxSystemSettings,
41126 &_swigt__p_wxTGAHandler,
41127 &_swigt__p_wxTIFFHandler,
41128 &_swigt__p_wxTextCtrl,
41129 &_swigt__p_wxTextDataObject,
41130 &_swigt__p_wxTimeSpan,
41131 &_swigt__p_wxTimer,
41132 &_swigt__p_wxTimerEvent,
41133 &_swigt__p_wxTimerRunner,
41134 &_swigt__p_wxTipProvider,
41135 &_swigt__p_wxToolTip,
41136 &_swigt__p_wxURLDataObject,
41137 &_swigt__p_wxUpdateUIEvent,
41138 &_swigt__p_wxValidator,
41139 &_swigt__p_wxVideoMode,
41140 &_swigt__p_wxWindow,
41141 &_swigt__p_wxWindowCreateEvent,
41142 &_swigt__p_wxWindowDestroyEvent,
41143 &_swigt__p_wxWindowDisabler,
41144 &_swigt__p_wxXPMHandler,
41145 };
41146
41147 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41157 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}};
41158 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41166 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}};
41167 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41172 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}};
41173 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41174 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}};
41175 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41218 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}};
41219 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
41226 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}};
41227 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41232 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41233 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41237 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41238 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}};
41239 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41241 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41244 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41245 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41246 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41247 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41248 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41251 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41252 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41255 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41256 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41257 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41258 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41259 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41260 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41261 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41262 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41263 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41264 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41265 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41266 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41267 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41268 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41269 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41270 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41271 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41272 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41273 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41274 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41275 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41276 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41277 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41278 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41279 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41280 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41281 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41282 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41283 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}};
41284 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41285 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41286 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41287 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41288 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41289 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41290 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41291 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41292 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41293 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41294 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}};
41295 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41296 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41297 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41298 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41299 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41300 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41301 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41302 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41303 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41304 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41305 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41306 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41307 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41308 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41309 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41310 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41311 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41312 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}};
41313 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41314 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41315 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41316 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41317 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}};
41318 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41319 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41320 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41321 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}};
41322 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41323
41324 static swig_cast_info *swig_cast_initial[] = {
41325 _swigc__p_char,
41326 _swigc__p_form_ops_t,
41327 _swigc__p_int,
41328 _swigc__p_unsigned_char,
41329 _swigc__p_unsigned_int,
41330 _swigc__p_unsigned_long,
41331 _swigc__p_void,
41332 _swigc__p_wxANIHandler,
41333 _swigc__p_wxAboutDialogInfo,
41334 _swigc__p_wxAcceleratorTable,
41335 _swigc__p_wxActivateEvent,
41336 _swigc__p_wxArrayString,
41337 _swigc__p_wxBMPHandler,
41338 _swigc__p_wxBitmap,
41339 _swigc__p_wxBitmapDataObject,
41340 _swigc__p_wxBoxSizer,
41341 _swigc__p_wxBusyCursor,
41342 _swigc__p_wxBusyInfo,
41343 _swigc__p_wxCURHandler,
41344 _swigc__p_wxCaret,
41345 _swigc__p_wxChar,
41346 _swigc__p_wxChildFocusEvent,
41347 _swigc__p_wxClipboard,
41348 _swigc__p_wxClipboardLocker,
41349 _swigc__p_wxClipboardTextEvent,
41350 _swigc__p_wxCloseEvent,
41351 _swigc__p_wxColour,
41352 _swigc__p_wxCommandEvent,
41353 _swigc__p_wxConfig,
41354 _swigc__p_wxConfigBase,
41355 _swigc__p_wxConfigPathChanger,
41356 _swigc__p_wxContextMenuEvent,
41357 _swigc__p_wxControl,
41358 _swigc__p_wxControlWithItems,
41359 _swigc__p_wxCursor,
41360 _swigc__p_wxCustomDataObject,
41361 _swigc__p_wxDC,
41362 _swigc__p_wxDataFormat,
41363 _swigc__p_wxDataObject,
41364 _swigc__p_wxDataObjectComposite,
41365 _swigc__p_wxDataObjectSimple,
41366 _swigc__p_wxDateEvent,
41367 _swigc__p_wxDateSpan,
41368 _swigc__p_wxDateTime,
41369 _swigc__p_wxDateTime__TimeZone,
41370 _swigc__p_wxDisplay,
41371 _swigc__p_wxDisplayChangedEvent,
41372 _swigc__p_wxDropFilesEvent,
41373 _swigc__p_wxDuplexMode,
41374 _swigc__p_wxEraseEvent,
41375 _swigc__p_wxEvent,
41376 _swigc__p_wxEventBlocker,
41377 _swigc__p_wxEvtHandler,
41378 _swigc__p_wxFSFile,
41379 _swigc__p_wxFileConfig,
41380 _swigc__p_wxFileDataObject,
41381 _swigc__p_wxFileHistory,
41382 _swigc__p_wxFileSystem,
41383 _swigc__p_wxFileType,
41384 _swigc__p_wxFileTypeInfo,
41385 _swigc__p_wxFlexGridSizer,
41386 _swigc__p_wxFocusEvent,
41387 _swigc__p_wxFont,
41388 _swigc__p_wxFrame,
41389 _swigc__p_wxGBSizerItem,
41390 _swigc__p_wxGIFHandler,
41391 _swigc__p_wxGridBagSizer,
41392 _swigc__p_wxGridSizer,
41393 _swigc__p_wxICOHandler,
41394 _swigc__p_wxIcon,
41395 _swigc__p_wxIconizeEvent,
41396 _swigc__p_wxIdleEvent,
41397 _swigc__p_wxImage,
41398 _swigc__p_wxImageHandler,
41399 _swigc__p_wxIndividualLayoutConstraint,
41400 _swigc__p_wxInitDialogEvent,
41401 _swigc__p_wxJPEGHandler,
41402 _swigc__p_wxJoystick,
41403 _swigc__p_wxJoystickEvent,
41404 _swigc__p_wxKeyEvent,
41405 _swigc__p_wxKillError,
41406 _swigc__p_wxLayoutConstraints,
41407 _swigc__p_wxLog,
41408 _swigc__p_wxLogBuffer,
41409 _swigc__p_wxLogChain,
41410 _swigc__p_wxLogGui,
41411 _swigc__p_wxLogNull,
41412 _swigc__p_wxLogStderr,
41413 _swigc__p_wxLogTextCtrl,
41414 _swigc__p_wxLogWindow,
41415 _swigc__p_wxMaximizeEvent,
41416 _swigc__p_wxMenu,
41417 _swigc__p_wxMenuBar,
41418 _swigc__p_wxMenuEvent,
41419 _swigc__p_wxMenuItem,
41420 _swigc__p_wxMetafile,
41421 _swigc__p_wxMetafileDataObject,
41422 _swigc__p_wxMimeTypesManager,
41423 _swigc__p_wxMouseCaptureChangedEvent,
41424 _swigc__p_wxMouseCaptureLostEvent,
41425 _swigc__p_wxMouseEvent,
41426 _swigc__p_wxMouseState,
41427 _swigc__p_wxMoveEvent,
41428 _swigc__p_wxMutexGuiLocker,
41429 _swigc__p_wxNavigationKeyEvent,
41430 _swigc__p_wxNcPaintEvent,
41431 _swigc__p_wxNotifyEvent,
41432 _swigc__p_wxObject,
41433 _swigc__p_wxOutputStream,
41434 _swigc__p_wxPCXHandler,
41435 _swigc__p_wxPNGHandler,
41436 _swigc__p_wxPNMHandler,
41437 _swigc__p_wxPaintEvent,
41438 _swigc__p_wxPaletteChangedEvent,
41439 _swigc__p_wxPaperSize,
41440 _swigc__p_wxPlatformInfo,
41441 _swigc__p_wxPoint,
41442 _swigc__p_wxPowerEvent,
41443 _swigc__p_wxProcessEvent,
41444 _swigc__p_wxPyApp,
41445 _swigc__p_wxPyArtProvider,
41446 _swigc__p_wxPyBitmapDataObject,
41447 _swigc__p_wxPyCommandEvent,
41448 _swigc__p_wxPyDataObjectSimple,
41449 _swigc__p_wxPyDropSource,
41450 _swigc__p_wxPyDropTarget,
41451 _swigc__p_wxPyEvent,
41452 _swigc__p_wxPyFileDropTarget,
41453 _swigc__p_wxPyImageHandler,
41454 _swigc__p_wxPyLog,
41455 _swigc__p_wxPyProcess,
41456 _swigc__p_wxPySizer,
41457 _swigc__p_wxPyTextDataObject,
41458 _swigc__p_wxPyTextDropTarget,
41459 _swigc__p_wxPyTimer,
41460 _swigc__p_wxPyTipProvider,
41461 _swigc__p_wxPyValidator,
41462 _swigc__p_wxQueryNewPaletteEvent,
41463 _swigc__p_wxRect,
41464 _swigc__p_wxScrollEvent,
41465 _swigc__p_wxScrollWinEvent,
41466 _swigc__p_wxSetCursorEvent,
41467 _swigc__p_wxShowEvent,
41468 _swigc__p_wxSingleInstanceChecker,
41469 _swigc__p_wxSize,
41470 _swigc__p_wxSizeEvent,
41471 _swigc__p_wxSizer,
41472 _swigc__p_wxSizerItem,
41473 _swigc__p_wxSound,
41474 _swigc__p_wxStandardPaths,
41475 _swigc__p_wxStaticBoxSizer,
41476 _swigc__p_wxStdDialogButtonSizer,
41477 _swigc__p_wxStopWatch,
41478 _swigc__p_wxString,
41479 _swigc__p_wxSysColourChangedEvent,
41480 _swigc__p_wxSystemOptions,
41481 _swigc__p_wxSystemSettings,
41482 _swigc__p_wxTGAHandler,
41483 _swigc__p_wxTIFFHandler,
41484 _swigc__p_wxTextCtrl,
41485 _swigc__p_wxTextDataObject,
41486 _swigc__p_wxTimeSpan,
41487 _swigc__p_wxTimer,
41488 _swigc__p_wxTimerEvent,
41489 _swigc__p_wxTimerRunner,
41490 _swigc__p_wxTipProvider,
41491 _swigc__p_wxToolTip,
41492 _swigc__p_wxURLDataObject,
41493 _swigc__p_wxUpdateUIEvent,
41494 _swigc__p_wxValidator,
41495 _swigc__p_wxVideoMode,
41496 _swigc__p_wxWindow,
41497 _swigc__p_wxWindowCreateEvent,
41498 _swigc__p_wxWindowDestroyEvent,
41499 _swigc__p_wxWindowDisabler,
41500 _swigc__p_wxXPMHandler,
41501 };
41502
41503
41504 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41505
41506 static swig_const_info swig_const_table[] = {
41507 {0, 0, 0, 0.0, 0, 0}};
41508
41509 #ifdef __cplusplus
41510 }
41511 #endif
41512 /* -----------------------------------------------------------------------------
41513 * Type initialization:
41514 * This problem is tough by the requirement that no dynamic
41515 * memory is used. Also, since swig_type_info structures store pointers to
41516 * swig_cast_info structures and swig_cast_info structures store pointers back
41517 * to swig_type_info structures, we need some lookup code at initialization.
41518 * The idea is that swig generates all the structures that are needed.
41519 * The runtime then collects these partially filled structures.
41520 * The SWIG_InitializeModule function takes these initial arrays out of
41521 * swig_module, and does all the lookup, filling in the swig_module.types
41522 * array with the correct data and linking the correct swig_cast_info
41523 * structures together.
41524 *
41525 * The generated swig_type_info structures are assigned staticly to an initial
41526 * array. We just loop though that array, and handle each type individually.
41527 * First we lookup if this type has been already loaded, and if so, use the
41528 * loaded structure instead of the generated one. Then we have to fill in the
41529 * cast linked list. The cast data is initially stored in something like a
41530 * two-dimensional array. Each row corresponds to a type (there are the same
41531 * number of rows as there are in the swig_type_initial array). Each entry in
41532 * a column is one of the swig_cast_info structures for that type.
41533 * The cast_initial array is actually an array of arrays, because each row has
41534 * a variable number of columns. So to actually build the cast linked list,
41535 * we find the array of casts associated with the type, and loop through it
41536 * adding the casts to the list. The one last trick we need to do is making
41537 * sure the type pointer in the swig_cast_info struct is correct.
41538 *
41539 * First off, we lookup the cast->type name to see if it is already loaded.
41540 * There are three cases to handle:
41541 * 1) If the cast->type has already been loaded AND the type we are adding
41542 * casting info to has not been loaded (it is in this module), THEN we
41543 * replace the cast->type pointer with the type pointer that has already
41544 * been loaded.
41545 * 2) If BOTH types (the one we are adding casting info to, and the
41546 * cast->type) are loaded, THEN the cast info has already been loaded by
41547 * the previous module so we just ignore it.
41548 * 3) Finally, if cast->type has not already been loaded, then we add that
41549 * swig_cast_info to the linked list (because the cast->type) pointer will
41550 * be correct.
41551 * ----------------------------------------------------------------------------- */
41552
41553 #ifdef __cplusplus
41554 extern "C" {
41555 #if 0
41556 } /* c-mode */
41557 #endif
41558 #endif
41559
41560 #if 0
41561 #define SWIGRUNTIME_DEBUG
41562 #endif
41563
41564 SWIGRUNTIME void
41565 SWIG_InitializeModule(void *clientdata) {
41566 size_t i;
41567 swig_module_info *module_head;
41568 static int init_run = 0;
41569
41570 clientdata = clientdata;
41571
41572 if (init_run) return;
41573 init_run = 1;
41574
41575 /* Initialize the swig_module */
41576 swig_module.type_initial = swig_type_initial;
41577 swig_module.cast_initial = swig_cast_initial;
41578
41579 /* Try and load any already created modules */
41580 module_head = SWIG_GetModule(clientdata);
41581 if (module_head) {
41582 swig_module.next = module_head->next;
41583 module_head->next = &swig_module;
41584 } else {
41585 /* This is the first module loaded */
41586 swig_module.next = &swig_module;
41587 SWIG_SetModule(clientdata, &swig_module);
41588 }
41589
41590 /* Now work on filling in swig_module.types */
41591 #ifdef SWIGRUNTIME_DEBUG
41592 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41593 #endif
41594 for (i = 0; i < swig_module.size; ++i) {
41595 swig_type_info *type = 0;
41596 swig_type_info *ret;
41597 swig_cast_info *cast;
41598
41599 #ifdef SWIGRUNTIME_DEBUG
41600 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41601 #endif
41602
41603 /* if there is another module already loaded */
41604 if (swig_module.next != &swig_module) {
41605 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41606 }
41607 if (type) {
41608 /* Overwrite clientdata field */
41609 #ifdef SWIGRUNTIME_DEBUG
41610 printf("SWIG_InitializeModule: found type %s\n", type->name);
41611 #endif
41612 if (swig_module.type_initial[i]->clientdata) {
41613 type->clientdata = swig_module.type_initial[i]->clientdata;
41614 #ifdef SWIGRUNTIME_DEBUG
41615 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41616 #endif
41617 }
41618 } else {
41619 type = swig_module.type_initial[i];
41620 }
41621
41622 /* Insert casting types */
41623 cast = swig_module.cast_initial[i];
41624 while (cast->type) {
41625 /* Don't need to add information already in the list */
41626 ret = 0;
41627 #ifdef SWIGRUNTIME_DEBUG
41628 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41629 #endif
41630 if (swig_module.next != &swig_module) {
41631 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41632 #ifdef SWIGRUNTIME_DEBUG
41633 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41634 #endif
41635 }
41636 if (ret) {
41637 if (type == swig_module.type_initial[i]) {
41638 #ifdef SWIGRUNTIME_DEBUG
41639 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41640 #endif
41641 cast->type = ret;
41642 ret = 0;
41643 } else {
41644 /* Check for casting already in the list */
41645 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41646 #ifdef SWIGRUNTIME_DEBUG
41647 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41648 #endif
41649 if (!ocast) ret = 0;
41650 }
41651 }
41652
41653 if (!ret) {
41654 #ifdef SWIGRUNTIME_DEBUG
41655 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41656 #endif
41657 if (type->cast) {
41658 type->cast->prev = cast;
41659 cast->next = type->cast;
41660 }
41661 type->cast = cast;
41662 }
41663 cast++;
41664 }
41665 /* Set entry in modules->types array equal to the type */
41666 swig_module.types[i] = type;
41667 }
41668 swig_module.types[i] = 0;
41669
41670 #ifdef SWIGRUNTIME_DEBUG
41671 printf("**** SWIG_InitializeModule: Cast List ******\n");
41672 for (i = 0; i < swig_module.size; ++i) {
41673 int j = 0;
41674 swig_cast_info *cast = swig_module.cast_initial[i];
41675 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41676 while (cast->type) {
41677 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41678 cast++;
41679 ++j;
41680 }
41681 printf("---- Total casts: %d\n",j);
41682 }
41683 printf("**** SWIG_InitializeModule: Cast List ******\n");
41684 #endif
41685 }
41686
41687 /* This function will propagate the clientdata field of type to
41688 * any new swig_type_info structures that have been added into the list
41689 * of equivalent types. It is like calling
41690 * SWIG_TypeClientData(type, clientdata) a second time.
41691 */
41692 SWIGRUNTIME void
41693 SWIG_PropagateClientData(void) {
41694 size_t i;
41695 swig_cast_info *equiv;
41696 static int init_run = 0;
41697
41698 if (init_run) return;
41699 init_run = 1;
41700
41701 for (i = 0; i < swig_module.size; i++) {
41702 if (swig_module.types[i]->clientdata) {
41703 equiv = swig_module.types[i]->cast;
41704 while (equiv) {
41705 if (!equiv->converter) {
41706 if (equiv->type && !equiv->type->clientdata)
41707 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41708 }
41709 equiv = equiv->next;
41710 }
41711 }
41712 }
41713 }
41714
41715 #ifdef __cplusplus
41716 #if 0
41717 {
41718 /* c-mode */
41719 #endif
41720 }
41721 #endif
41722
41723
41724
41725 #ifdef __cplusplus
41726 extern "C" {
41727 #endif
41728
41729 /* Python-specific SWIG API */
41730 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41731 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41732 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41733
41734 /* -----------------------------------------------------------------------------
41735 * global variable support code.
41736 * ----------------------------------------------------------------------------- */
41737
41738 typedef struct swig_globalvar {
41739 char *name; /* Name of global variable */
41740 PyObject *(*get_attr)(void); /* Return the current value */
41741 int (*set_attr)(PyObject *); /* Set the value */
41742 struct swig_globalvar *next;
41743 } swig_globalvar;
41744
41745 typedef struct swig_varlinkobject {
41746 PyObject_HEAD
41747 swig_globalvar *vars;
41748 } swig_varlinkobject;
41749
41750 SWIGINTERN PyObject *
41751 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41752 return PyString_FromString("<Swig global variables>");
41753 }
41754
41755 SWIGINTERN PyObject *
41756 swig_varlink_str(swig_varlinkobject *v) {
41757 PyObject *str = PyString_FromString("(");
41758 swig_globalvar *var;
41759 for (var = v->vars; var; var=var->next) {
41760 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41761 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41762 }
41763 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41764 return str;
41765 }
41766
41767 SWIGINTERN int
41768 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41769 PyObject *str = swig_varlink_str(v);
41770 fprintf(fp,"Swig global variables ");
41771 fprintf(fp,"%s\n", PyString_AsString(str));
41772 Py_DECREF(str);
41773 return 0;
41774 }
41775
41776 SWIGINTERN void
41777 swig_varlink_dealloc(swig_varlinkobject *v) {
41778 swig_globalvar *var = v->vars;
41779 while (var) {
41780 swig_globalvar *n = var->next;
41781 free(var->name);
41782 free(var);
41783 var = n;
41784 }
41785 }
41786
41787 SWIGINTERN PyObject *
41788 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41789 PyObject *res = NULL;
41790 swig_globalvar *var = v->vars;
41791 while (var) {
41792 if (strcmp(var->name,n) == 0) {
41793 res = (*var->get_attr)();
41794 break;
41795 }
41796 var = var->next;
41797 }
41798 if (res == NULL && !PyErr_Occurred()) {
41799 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41800 }
41801 return res;
41802 }
41803
41804 SWIGINTERN int
41805 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41806 int res = 1;
41807 swig_globalvar *var = v->vars;
41808 while (var) {
41809 if (strcmp(var->name,n) == 0) {
41810 res = (*var->set_attr)(p);
41811 break;
41812 }
41813 var = var->next;
41814 }
41815 if (res == 1 && !PyErr_Occurred()) {
41816 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41817 }
41818 return res;
41819 }
41820
41821 SWIGINTERN PyTypeObject*
41822 swig_varlink_type(void) {
41823 static char varlink__doc__[] = "Swig var link object";
41824 static PyTypeObject varlink_type;
41825 static int type_init = 0;
41826 if (!type_init) {
41827 const PyTypeObject tmp
41828 = {
41829 PyObject_HEAD_INIT(NULL)
41830 0, /* Number of items in variable part (ob_size) */
41831 (char *)"swigvarlink", /* Type name (tp_name) */
41832 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41833 0, /* Itemsize (tp_itemsize) */
41834 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41835 (printfunc) swig_varlink_print, /* Print (tp_print) */
41836 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41837 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41838 0, /* tp_compare */
41839 (reprfunc) swig_varlink_repr, /* tp_repr */
41840 0, /* tp_as_number */
41841 0, /* tp_as_sequence */
41842 0, /* tp_as_mapping */
41843 0, /* tp_hash */
41844 0, /* tp_call */
41845 (reprfunc)swig_varlink_str, /* tp_str */
41846 0, /* tp_getattro */
41847 0, /* tp_setattro */
41848 0, /* tp_as_buffer */
41849 0, /* tp_flags */
41850 varlink__doc__, /* tp_doc */
41851 0, /* tp_traverse */
41852 0, /* tp_clear */
41853 0, /* tp_richcompare */
41854 0, /* tp_weaklistoffset */
41855 #if PY_VERSION_HEX >= 0x02020000
41856 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41857 #endif
41858 #if PY_VERSION_HEX >= 0x02030000
41859 0, /* tp_del */
41860 #endif
41861 #ifdef COUNT_ALLOCS
41862 0,0,0,0 /* tp_alloc -> tp_next */
41863 #endif
41864 };
41865 varlink_type = tmp;
41866 varlink_type.ob_type = &PyType_Type;
41867 type_init = 1;
41868 }
41869 return &varlink_type;
41870 }
41871
41872 /* Create a variable linking object for use later */
41873 SWIGINTERN PyObject *
41874 SWIG_Python_newvarlink(void) {
41875 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41876 if (result) {
41877 result->vars = 0;
41878 }
41879 return ((PyObject*) result);
41880 }
41881
41882 SWIGINTERN void
41883 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41884 swig_varlinkobject *v = (swig_varlinkobject *) p;
41885 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41886 if (gv) {
41887 size_t size = strlen(name)+1;
41888 gv->name = (char *)malloc(size);
41889 if (gv->name) {
41890 strncpy(gv->name,name,size);
41891 gv->get_attr = get_attr;
41892 gv->set_attr = set_attr;
41893 gv->next = v->vars;
41894 }
41895 }
41896 v->vars = gv;
41897 }
41898
41899 SWIGINTERN PyObject *
41900 SWIG_globals() {
41901 static PyObject *_SWIG_globals = 0;
41902 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41903 return _SWIG_globals;
41904 }
41905
41906 /* -----------------------------------------------------------------------------
41907 * constants/methods manipulation
41908 * ----------------------------------------------------------------------------- */
41909
41910 /* Install Constants */
41911 SWIGINTERN void
41912 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41913 PyObject *obj = 0;
41914 size_t i;
41915 for (i = 0; constants[i].type; ++i) {
41916 switch(constants[i].type) {
41917 case SWIG_PY_POINTER:
41918 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41919 break;
41920 case SWIG_PY_BINARY:
41921 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41922 break;
41923 default:
41924 obj = 0;
41925 break;
41926 }
41927 if (obj) {
41928 PyDict_SetItemString(d, constants[i].name, obj);
41929 Py_DECREF(obj);
41930 }
41931 }
41932 }
41933
41934 /* -----------------------------------------------------------------------------*/
41935 /* Fix SwigMethods to carry the callback ptrs when needed */
41936 /* -----------------------------------------------------------------------------*/
41937
41938 SWIGINTERN void
41939 SWIG_Python_FixMethods(PyMethodDef *methods,
41940 swig_const_info *const_table,
41941 swig_type_info **types,
41942 swig_type_info **types_initial) {
41943 size_t i;
41944 for (i = 0; methods[i].ml_name; ++i) {
41945 const char *c = methods[i].ml_doc;
41946 if (c && (c = strstr(c, "swig_ptr: "))) {
41947 int j;
41948 swig_const_info *ci = 0;
41949 const char *name = c + 10;
41950 for (j = 0; const_table[j].type; ++j) {
41951 if (strncmp(const_table[j].name, name,
41952 strlen(const_table[j].name)) == 0) {
41953 ci = &(const_table[j]);
41954 break;
41955 }
41956 }
41957 if (ci) {
41958 size_t shift = (ci->ptype) - types;
41959 swig_type_info *ty = types_initial[shift];
41960 size_t ldoc = (c - methods[i].ml_doc);
41961 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41962 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41963 if (ndoc) {
41964 char *buff = ndoc;
41965 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41966 if (ptr) {
41967 strncpy(buff, methods[i].ml_doc, ldoc);
41968 buff += ldoc;
41969 strncpy(buff, "swig_ptr: ", 10);
41970 buff += 10;
41971 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41972 methods[i].ml_doc = ndoc;
41973 }
41974 }
41975 }
41976 }
41977 }
41978 }
41979
41980 #ifdef __cplusplus
41981 }
41982 #endif
41983
41984 /* -----------------------------------------------------------------------------*
41985 * Partial Init method
41986 * -----------------------------------------------------------------------------*/
41987
41988 #ifdef __cplusplus
41989 extern "C"
41990 #endif
41991 SWIGEXPORT void SWIG_init(void) {
41992 PyObject *m, *d;
41993
41994 /* Fix SwigMethods to carry the callback ptrs when needed */
41995 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41996
41997 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41998 d = PyModule_GetDict(m);
41999
42000 SWIG_InitializeModule(0);
42001 SWIG_InstallConstants(d,swig_const_table);
42002
42003
42004 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
42005 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
42006 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
42007 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
42008 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
42009 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
42010 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
42011 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
42012 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
42013 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
42014 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
42015 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
42016 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
42017 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
42018 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
42019 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
42020 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
42021 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
42022 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
42023 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
42024 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
42025 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
42026 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
42027 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
42028 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
42029 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
42030 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
42031 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
42032 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
42033 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
42034 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
42035 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
42036 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
42037 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
42038 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
42039 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
42040 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
42041 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
42042 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
42043 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
42044 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
42045 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
42046 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
42047 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
42048 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
42049 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
42050 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
42051 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
42052 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
42053 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
42054 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
42055 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
42056 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
42057 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
42058 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
42059 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
42060 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
42061 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
42062 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
42063 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
42064 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
42065 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
42066 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42067 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42068 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42069 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42070 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42071 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42072 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42073 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42074 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42075 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42076 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42077 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42078 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42079 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42080 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42081 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42082 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42083 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42084 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42085 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42086 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42087 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42088 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42089 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42090 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42091 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42092 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42093 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42094 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42095 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42096 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42097 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42098 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42099 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42100 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42101 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42102 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42103 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42104 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42105 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42106 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42107 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42108 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42109 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42110 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42111 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42112 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42113 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42114 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42115 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42116 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42117 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42118 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42119 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42120 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42121 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42122 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42123 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42124 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42125 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42126 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42127 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42128 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42129 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42130 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42131 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42132 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42133 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42134 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42135 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42136 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42137 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42138 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42139 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42140 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42141 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42142 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42143 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42144 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42145 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42146 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42147 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42148 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42149 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42150 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42151 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42152
42153 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42154
42155 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42156 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42157 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42158 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42159 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42160 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42161 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42162 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42163 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42164 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42165 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42166 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42167 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42168 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42169 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42170 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42171 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42172 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42173 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42174 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42175 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42176 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42177 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42178 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42179 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42180 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42181 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42182 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42183 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42184 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42185 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42186 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42187 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42188 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42189 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42190 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42191 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42192 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42193 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42194 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42195 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42196 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42197 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42198 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42199 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42200 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42201 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42202 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42203 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42204 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42205 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42206 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42207 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42208
42209 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42210
42211 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42212 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42213 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42214 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42215 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42216 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42217 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42218 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42219 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42220 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42221 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42222 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42223 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42224 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42225 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42226 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42227 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42228 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42229 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42230 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42240 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42241 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42242 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42243 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42244 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42245 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42246 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42247 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42248 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42249 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42250 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42251 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42252 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42253 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42254 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42255 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42256 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42257 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42258 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42259 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42260 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42261 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42262 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42263 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42264 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42265 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42266 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42267 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42268 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42269 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42270 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42271 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42272 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42273 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42274 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42275 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42276 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42277 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42278 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42279 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42280 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42281 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42282 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42283 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42284 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42285 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42286 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42287
42288 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42289
42290 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42291 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42292 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42293 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42294 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42295 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42296 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42297 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42298 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42299 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42300 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42301 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42302 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42303 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42304 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42305 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42306 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42307 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42308 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42309 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42310 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42311 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42312 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42313 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42314 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42315 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42316 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42317 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42318 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42319 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42320 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42321 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42322 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42323 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42324 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42325 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42326 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42327 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42328 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42329 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42330 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42331 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42332 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42333 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42334 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42335 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42336 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42337 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42338 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42339 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42340 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42341 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42342 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42343 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42344 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42345 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42346 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42347 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42348 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42349 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42350 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42351 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42352 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42353 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42354 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42355 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42356 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42357 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42358 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42359 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42360 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42361 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42362 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42363 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42364 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42365 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42366 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42367 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42368 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42369 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42370 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42371 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42372 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42373 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42374 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42375 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42376 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42377 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42378 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42379 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42380 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42381 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42382 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42383 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42384 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42385 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42386 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42387 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42388 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42389 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42390 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42391 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42392 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42393 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42394 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42395 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42396 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42397 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42398 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42399 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42400 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42401 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42402 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42403 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42404 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42405 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42406 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42407 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42408 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42409 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42410 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42411 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42412 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42413 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42414 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42415 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42416 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42417 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42418 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42419 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42420 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42421 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42422 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42423 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42424 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42425 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42426 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42427 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42428 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42429 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42430 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42431 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42432 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42433 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42434 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42435 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42436 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42437 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42438 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42439 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42440 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42441 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42442 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42443 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42444 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42445 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42446 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42447 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42448 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42449 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42450 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42451 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42452 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42453 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42454 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42455 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42456 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42457 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42458 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42459 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42460 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42461 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42462 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42463 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42464 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42465 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42466 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42467 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42468 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42469 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42470 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42471 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42472 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42473 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42474 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42475 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42476 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42477 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42478 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42479 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42480 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42481 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42482 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42483 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42484 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42485 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42486 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42487 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42488 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42489 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42490 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42491 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42492 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42493
42494 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42495 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42496 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42497 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42498
42499 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42500 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42501 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42502 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42503 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42504 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42505 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42506 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42507 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42508 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42509 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42510 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42511 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42512 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42513 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42514 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42515 }
42516
wxWidgets (Impactor)