]> 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
reSWIGged
[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_wxArtClient swig_types[12]
2479 #define SWIGTYPE_p_wxArtID swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBitmapDataObject swig_types[16]
2483 #define SWIGTYPE_p_wxBoxSizer swig_types[17]
2484 #define SWIGTYPE_p_wxBusyCursor swig_types[18]
2485 #define SWIGTYPE_p_wxBusyInfo swig_types[19]
2486 #define SWIGTYPE_p_wxCURHandler swig_types[20]
2487 #define SWIGTYPE_p_wxCaret swig_types[21]
2488 #define SWIGTYPE_p_wxChar swig_types[22]
2489 #define SWIGTYPE_p_wxChildFocusEvent swig_types[23]
2490 #define SWIGTYPE_p_wxClipboard swig_types[24]
2491 #define SWIGTYPE_p_wxClipboardLocker swig_types[25]
2492 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[26]
2493 #define SWIGTYPE_p_wxCloseEvent swig_types[27]
2494 #define SWIGTYPE_p_wxColour swig_types[28]
2495 #define SWIGTYPE_p_wxCommandEvent swig_types[29]
2496 #define SWIGTYPE_p_wxConfig swig_types[30]
2497 #define SWIGTYPE_p_wxConfigBase swig_types[31]
2498 #define SWIGTYPE_p_wxConfigPathChanger swig_types[32]
2499 #define SWIGTYPE_p_wxContextMenuEvent swig_types[33]
2500 #define SWIGTYPE_p_wxControl swig_types[34]
2501 #define SWIGTYPE_p_wxControlWithItems swig_types[35]
2502 #define SWIGTYPE_p_wxCursor swig_types[36]
2503 #define SWIGTYPE_p_wxCustomDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDC swig_types[38]
2505 #define SWIGTYPE_p_wxDataFormat swig_types[39]
2506 #define SWIGTYPE_p_wxDataObject swig_types[40]
2507 #define SWIGTYPE_p_wxDataObjectComposite swig_types[41]
2508 #define SWIGTYPE_p_wxDataObjectSimple swig_types[42]
2509 #define SWIGTYPE_p_wxDateEvent swig_types[43]
2510 #define SWIGTYPE_p_wxDateSpan swig_types[44]
2511 #define SWIGTYPE_p_wxDateTime swig_types[45]
2512 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[46]
2513 #define SWIGTYPE_p_wxDisplay swig_types[47]
2514 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[48]
2515 #define SWIGTYPE_p_wxDropFilesEvent swig_types[49]
2516 #define SWIGTYPE_p_wxDuplexMode swig_types[50]
2517 #define SWIGTYPE_p_wxEraseEvent swig_types[51]
2518 #define SWIGTYPE_p_wxEvent swig_types[52]
2519 #define SWIGTYPE_p_wxEventBlocker swig_types[53]
2520 #define SWIGTYPE_p_wxEvtHandler swig_types[54]
2521 #define SWIGTYPE_p_wxFSFile swig_types[55]
2522 #define SWIGTYPE_p_wxFileConfig swig_types[56]
2523 #define SWIGTYPE_p_wxFileDataObject swig_types[57]
2524 #define SWIGTYPE_p_wxFileHistory swig_types[58]
2525 #define SWIGTYPE_p_wxFileSystem swig_types[59]
2526 #define SWIGTYPE_p_wxFileType swig_types[60]
2527 #define SWIGTYPE_p_wxFileTypeInfo swig_types[61]
2528 #define SWIGTYPE_p_wxFlexGridSizer swig_types[62]
2529 #define SWIGTYPE_p_wxFocusEvent swig_types[63]
2530 #define SWIGTYPE_p_wxFont swig_types[64]
2531 #define SWIGTYPE_p_wxFrame swig_types[65]
2532 #define SWIGTYPE_p_wxGBSizerItem swig_types[66]
2533 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
2534 #define SWIGTYPE_p_wxGridBagSizer swig_types[68]
2535 #define SWIGTYPE_p_wxGridSizer swig_types[69]
2536 #define SWIGTYPE_p_wxICOHandler swig_types[70]
2537 #define SWIGTYPE_p_wxIcon swig_types[71]
2538 #define SWIGTYPE_p_wxIconBundle swig_types[72]
2539 #define SWIGTYPE_p_wxIconizeEvent swig_types[73]
2540 #define SWIGTYPE_p_wxIdleEvent swig_types[74]
2541 #define SWIGTYPE_p_wxImage swig_types[75]
2542 #define SWIGTYPE_p_wxImageHandler swig_types[76]
2543 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[77]
2544 #define SWIGTYPE_p_wxInitDialogEvent swig_types[78]
2545 #define SWIGTYPE_p_wxJPEGHandler swig_types[79]
2546 #define SWIGTYPE_p_wxJoystick swig_types[80]
2547 #define SWIGTYPE_p_wxJoystickEvent swig_types[81]
2548 #define SWIGTYPE_p_wxKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxKillError swig_types[83]
2550 #define SWIGTYPE_p_wxLayoutConstraints swig_types[84]
2551 #define SWIGTYPE_p_wxLog swig_types[85]
2552 #define SWIGTYPE_p_wxLogBuffer swig_types[86]
2553 #define SWIGTYPE_p_wxLogChain swig_types[87]
2554 #define SWIGTYPE_p_wxLogGui swig_types[88]
2555 #define SWIGTYPE_p_wxLogNull swig_types[89]
2556 #define SWIGTYPE_p_wxLogStderr swig_types[90]
2557 #define SWIGTYPE_p_wxLogTextCtrl swig_types[91]
2558 #define SWIGTYPE_p_wxLogWindow swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMetafile swig_types[98]
2565 #define SWIGTYPE_p_wxMetafileDataObject swig_types[99]
2566 #define SWIGTYPE_p_wxMimeTypesManager swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMouseEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMouseState swig_types[104]
2571 #define SWIGTYPE_p_wxMoveEvent swig_types[105]
2572 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[106]
2573 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNcPaintEvent swig_types[108]
2575 #define SWIGTYPE_p_wxNotifyEvent swig_types[109]
2576 #define SWIGTYPE_p_wxObject swig_types[110]
2577 #define SWIGTYPE_p_wxOutputStream swig_types[111]
2578 #define SWIGTYPE_p_wxPCXHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPNGHandler swig_types[113]
2580 #define SWIGTYPE_p_wxPNMHandler swig_types[114]
2581 #define SWIGTYPE_p_wxPaintEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPaperSize swig_types[117]
2584 #define SWIGTYPE_p_wxPlatformInfo swig_types[118]
2585 #define SWIGTYPE_p_wxPoint swig_types[119]
2586 #define SWIGTYPE_p_wxPowerEvent swig_types[120]
2587 #define SWIGTYPE_p_wxProcessEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyApp swig_types[122]
2589 #define SWIGTYPE_p_wxPyArtProvider swig_types[123]
2590 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[124]
2591 #define SWIGTYPE_p_wxPyCommandEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[126]
2593 #define SWIGTYPE_p_wxPyDropSource swig_types[127]
2594 #define SWIGTYPE_p_wxPyDropTarget swig_types[128]
2595 #define SWIGTYPE_p_wxPyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[130]
2597 #define SWIGTYPE_p_wxPyImageHandler swig_types[131]
2598 #define SWIGTYPE_p_wxPyLog swig_types[132]
2599 #define SWIGTYPE_p_wxPyProcess swig_types[133]
2600 #define SWIGTYPE_p_wxPySizer swig_types[134]
2601 #define SWIGTYPE_p_wxPyTextDataObject swig_types[135]
2602 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[136]
2603 #define SWIGTYPE_p_wxPyTimer swig_types[137]
2604 #define SWIGTYPE_p_wxPyTipProvider swig_types[138]
2605 #define SWIGTYPE_p_wxPyValidator swig_types[139]
2606 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[140]
2607 #define SWIGTYPE_p_wxRect swig_types[141]
2608 #define SWIGTYPE_p_wxScrollEvent swig_types[142]
2609 #define SWIGTYPE_p_wxScrollWinEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSetCursorEvent swig_types[144]
2611 #define SWIGTYPE_p_wxShowEvent swig_types[145]
2612 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[146]
2613 #define SWIGTYPE_p_wxSize swig_types[147]
2614 #define SWIGTYPE_p_wxSizeEvent swig_types[148]
2615 #define SWIGTYPE_p_wxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxSizerItem swig_types[150]
2617 #define SWIGTYPE_p_wxSound swig_types[151]
2618 #define SWIGTYPE_p_wxStandardPaths swig_types[152]
2619 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[153]
2620 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[154]
2621 #define SWIGTYPE_p_wxStopWatch swig_types[155]
2622 #define SWIGTYPE_p_wxString swig_types[156]
2623 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[157]
2624 #define SWIGTYPE_p_wxSystemOptions swig_types[158]
2625 #define SWIGTYPE_p_wxSystemSettings swig_types[159]
2626 #define SWIGTYPE_p_wxTGAHandler swig_types[160]
2627 #define SWIGTYPE_p_wxTIFFHandler swig_types[161]
2628 #define SWIGTYPE_p_wxTextCtrl swig_types[162]
2629 #define SWIGTYPE_p_wxTextDataObject swig_types[163]
2630 #define SWIGTYPE_p_wxTimeSpan swig_types[164]
2631 #define SWIGTYPE_p_wxTimer swig_types[165]
2632 #define SWIGTYPE_p_wxTimerEvent swig_types[166]
2633 #define SWIGTYPE_p_wxTimerRunner swig_types[167]
2634 #define SWIGTYPE_p_wxTipProvider swig_types[168]
2635 #define SWIGTYPE_p_wxToolTip swig_types[169]
2636 #define SWIGTYPE_p_wxURLDataObject swig_types[170]
2637 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[171]
2638 #define SWIGTYPE_p_wxValidator swig_types[172]
2639 #define SWIGTYPE_p_wxVideoMode swig_types[173]
2640 #define SWIGTYPE_p_wxWindow swig_types[174]
2641 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[175]
2642 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[176]
2643 #define SWIGTYPE_p_wxWindowDisabler swig_types[177]
2644 #define SWIGTYPE_p_wxXPMHandler swig_types[178]
2645 static swig_type_info *swig_types[180];
2646 static swig_module_info swig_module = {swig_types, 179, 0, 0, 0, 0};
2647 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2648 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2649
2650 /* -------- TYPES TABLE (END) -------- */
2651
2652 #if (PY_VERSION_HEX <= 0x02000000)
2653 # if !defined(SWIG_PYTHON_CLASSIC)
2654 # error "This python version requires to use swig with the '-classic' option"
2655 # endif
2656 #endif
2657 #if (PY_VERSION_HEX <= 0x02020000)
2658 # error "This python version requires to use swig with the '-nomodern' option"
2659 #endif
2660 #if (PY_VERSION_HEX <= 0x02020000)
2661 # error "This python version requires to use swig with the '-nomodernargs' option"
2662 #endif
2663 #ifndef METH_O
2664 # error "This python version requires to use swig with the '-nofastunpack' option"
2665 #endif
2666
2667 /*-----------------------------------------------
2668 @(target):= _misc_.so
2669 ------------------------------------------------*/
2670 #define SWIG_init init_misc_
2671
2672 #define SWIG_name "_misc_"
2673
2674 #define SWIGVERSION 0x010329
2675
2676
2677 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2678 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2679
2680
2681 #include <stdexcept>
2682
2683
2684 namespace swig {
2685 class PyObject_ptr {
2686 protected:
2687 PyObject *_obj;
2688
2689 public:
2690 PyObject_ptr() :_obj(0)
2691 {
2692 }
2693
2694 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2695 {
2696 Py_XINCREF(_obj);
2697 }
2698
2699 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2700 {
2701 if (initial_ref) Py_XINCREF(_obj);
2702 }
2703
2704 PyObject_ptr & operator=(const PyObject_ptr& item)
2705 {
2706 Py_XINCREF(item._obj);
2707 Py_XDECREF(_obj);
2708 _obj = item._obj;
2709 return *this;
2710 }
2711
2712 ~PyObject_ptr()
2713 {
2714 Py_XDECREF(_obj);
2715 }
2716
2717 operator PyObject *() const
2718 {
2719 return _obj;
2720 }
2721
2722 PyObject *operator->() const
2723 {
2724 return _obj;
2725 }
2726 };
2727 }
2728
2729
2730 namespace swig {
2731 struct PyObject_var : PyObject_ptr {
2732 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2733
2734 PyObject_var & operator = (PyObject* obj)
2735 {
2736 Py_XDECREF(_obj);
2737 _obj = obj;
2738 return *this;
2739 }
2740 };
2741 }
2742
2743
2744 #include "wx/wxPython/wxPython.h"
2745 #include "wx/wxPython/pyclasses.h"
2746 #include "wx/wxPython/pyistream.h"
2747
2748 static const wxString wxPyEmptyString(wxEmptyString);
2749
2750
2751
2752 #define SWIG_From_long PyInt_FromLong
2753
2754
2755 SWIGINTERNINLINE PyObject *
2756 SWIG_From_int (int value)
2757 {
2758 return SWIG_From_long (value);
2759 }
2760
2761
2762 #include <limits.h>
2763 #ifndef LLONG_MIN
2764 # define LLONG_MIN LONG_LONG_MIN
2765 #endif
2766 #ifndef LLONG_MAX
2767 # define LLONG_MAX LONG_LONG_MAX
2768 #endif
2769 #ifndef ULLONG_MAX
2770 # define ULLONG_MAX ULONG_LONG_MAX
2771 #endif
2772
2773
2774 SWIGINTERN int
2775 SWIG_AsVal_long (PyObject* obj, long* val)
2776 {
2777 if (PyNumber_Check(obj)) {
2778 if (val) *val = PyInt_AsLong(obj);
2779 return SWIG_OK;
2780 }
2781 return SWIG_TypeError;
2782 }
2783
2784
2785 SWIGINTERN int
2786 SWIG_AsVal_int (PyObject * obj, int *val)
2787 {
2788 long v;
2789 int res = SWIG_AsVal_long (obj, &v);
2790 if (SWIG_IsOK(res)) {
2791 if ((v < INT_MIN || v > INT_MAX)) {
2792 return SWIG_OverflowError;
2793 } else {
2794 if (val) *val = static_cast< int >(v);
2795 }
2796 }
2797 return res;
2798 }
2799
2800 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2801
2802 #include <wx/stockitem.h>
2803
2804 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2805 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2806 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2807
2808 SWIGINTERN int
2809 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2810 {
2811 long v = 0;
2812 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2813 return SWIG_TypeError;
2814 }
2815 else if (val)
2816 *val = (unsigned long)v;
2817 return SWIG_OK;
2818 }
2819
2820
2821 SWIGINTERN int
2822 SWIG_AsVal_bool (PyObject *obj, bool *val)
2823 {
2824 if (obj == Py_True) {
2825 if (val) *val = true;
2826 return SWIG_OK;
2827 } else if (obj == Py_False) {
2828 if (val) *val = false;
2829 return SWIG_OK;
2830 } else {
2831 long v = 0;
2832 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2833 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2834 return res;
2835 }
2836 }
2837
2838
2839 SWIGINTERNINLINE PyObject*
2840 SWIG_From_unsigned_SS_long (unsigned long value)
2841 {
2842 return (value > LONG_MAX) ?
2843 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2844 }
2845
2846
2847 void* wxGetXDisplay()
2848 {
2849 #ifdef __WXGTK__
2850 return wxGetDisplay();
2851 #else
2852 return NULL;
2853 #endif
2854 }
2855
2856
2857 wxWindow* FindWindowAtPointer() {
2858 wxPoint unused;
2859 return wxFindWindowAtPointer(unused);
2860 }
2861
2862
2863 bool wxThread_IsMain() {
2864 #ifdef WXP_WITH_THREAD
2865 return wxThread::IsMain();
2866 #else
2867 return true;
2868 #endif
2869 }
2870
2871 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2872 delete self;
2873 }
2874
2875 #include <wx/snglinst.h>
2876
2877
2878 #ifdef __WXMSW__
2879 #include <wx/msw/private.h>
2880 #include <wx/dynload.h>
2881 #endif
2882
2883
2884
2885 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2886 #if 0
2887 , int method
2888 #endif
2889 )
2890 {
2891 #ifdef __WXMSW__
2892 #if 0
2893 switch (method)
2894 {
2895 case 1:
2896 // This one only partially works. Appears to be an undocumented
2897 // "standard" convention that not all widgets adhear to. For
2898 // example, for some widgets backgrounds or non-client areas may
2899 // not be painted.
2900 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2901 break;
2902
2903 case 2:
2904 #endif
2905 // This one works much better, nearly all widgets and their
2906 // children are captured correctly[**]. Prior to the big
2907 // background erase changes that Vadim did in 2004-2005 this
2908 // method failed badly on XP with Themes activated, most native
2909 // widgets draw only partially, if at all. Without themes it
2910 // worked just like on Win2k. After those changes this method
2911 // works very well.
2912 //
2913 // ** For example the radio buttons in a wxRadioBox are not its
2914 // children by default, but you can capture it via the panel
2915 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2916 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2917 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2918 PRF_ERASEBKGND | PRF_OWNED );
2919 return true;
2920 #if 0
2921 break;
2922
2923 case 3:
2924 // This one is only defined in the latest SDK and is only
2925 // available on XP. MSDN says it is similar to sending WM_PRINT
2926 // so I expect that it will work similar to the above. Since it
2927 // is avaialble only on XP, it can't be compiled like this and
2928 // will have to be loaded dynamically.
2929 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2930
2931 // fall through
2932
2933 case 4:
2934 // Use PrintWindow if available, or fallback to WM_PRINT
2935 // otherwise. Unfortunately using PrintWindow is even worse than
2936 // WM_PRINT. For most native widgets nothing is drawn to the dc
2937 // at all, with or without Themes.
2938 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2939 static bool s_triedToLoad = false;
2940 static PrintWindow_t pfnPrintWindow = NULL;
2941 if ( !s_triedToLoad )
2942 {
2943
2944 s_triedToLoad = true;
2945 wxDynamicLibrary dllUser32(_T("user32.dll"));
2946 if ( dllUser32.IsLoaded() )
2947 {
2948 wxLogNull nolog; // Don't report errors here
2949 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2950 }
2951 }
2952 if (pfnPrintWindow)
2953 {
2954 //printf("Using PrintWindow\n");
2955 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2956 }
2957 else
2958 {
2959 //printf("Using WM_PRINT\n");
2960 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2961 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2962 PRF_ERASEBKGND | PRF_OWNED );
2963 }
2964 }
2965 #endif // 0
2966 #else
2967 return false;
2968 #endif // __WXMSW__
2969 }
2970
2971
2972
2973 #include <wx/tipdlg.h>
2974
2975
2976 SWIGINTERNINLINE PyObject *
2977 SWIG_From_size_t (size_t value)
2978 {
2979 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2980 }
2981
2982
2983 class wxPyTipProvider : public wxTipProvider {
2984 public:
2985 wxPyTipProvider(size_t currentTip)
2986 : wxTipProvider(currentTip) {}
2987
2988 DEC_PYCALLBACK_STRING__pure(GetTip);
2989 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2990 PYPRIVATE;
2991 };
2992
2993 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2994 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2995
2996
2997 SWIGINTERNINLINE int
2998 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2999 {
3000 unsigned long v;
3001 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3002 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3003 return res;
3004 }
3005
3006
3007 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3008
3009 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3010
3011 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3012 : wxTimer(owner, id)
3013 {
3014 if (owner == NULL)
3015 SetOwner(this);
3016 }
3017
3018 wxPyTimer::~wxPyTimer()
3019 {
3020 // printf("-=* ~wxPyTimer\n");
3021 }
3022
3023
3024
3025 SWIGINTERN swig_type_info*
3026 SWIG_pchar_descriptor()
3027 {
3028 static int init = 0;
3029 static swig_type_info* info = 0;
3030 if (!init) {
3031 info = SWIG_TypeQuery("_p_char");
3032 init = 1;
3033 }
3034 return info;
3035 }
3036
3037
3038 SWIGINTERNINLINE PyObject *
3039 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3040 {
3041 if (carray) {
3042 if (size > INT_MAX) {
3043 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3044 return pchar_descriptor ?
3045 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3046 } else {
3047 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3048 }
3049 } else {
3050 return SWIG_Py_Void();
3051 }
3052 }
3053
3054
3055 SWIGINTERNINLINE PyObject *
3056 SWIG_FromCharPtr(const char *cptr)
3057 {
3058 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3059 }
3060
3061
3062 SWIGINTERN int
3063 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3064 {
3065 unsigned long v;
3066 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3067 if (SWIG_IsOK(res)) {
3068 if ((v > UINT_MAX)) {
3069 return SWIG_OverflowError;
3070 } else {
3071 if (val) *val = static_cast< unsigned int >(v);
3072 }
3073 }
3074 return res;
3075 }
3076
3077 SWIGINTERN wxString wxLog_TimeStamp(){
3078 wxString msg;
3079 wxLog::TimeStamp(&msg);
3080 return msg;
3081 }
3082 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3083 // Make some wrappers that double any % signs so they are 'escaped'
3084 void wxPyLogFatalError(const wxString& msg)
3085 {
3086 wxString m(msg);
3087 m.Replace(wxT("%"), wxT("%%"));
3088 wxLogFatalError(m);
3089 }
3090
3091 void wxPyLogError(const wxString& msg)
3092 {
3093 wxString m(msg);
3094 m.Replace(wxT("%"), wxT("%%"));
3095 wxLogError(m);
3096 }
3097
3098 void wxPyLogWarning(const wxString& msg)
3099 {
3100 wxString m(msg);
3101 m.Replace(wxT("%"), wxT("%%"));
3102 wxLogWarning(m);
3103 }
3104
3105 void wxPyLogMessage(const wxString& msg)
3106 {
3107 wxString m(msg);
3108 m.Replace(wxT("%"), wxT("%%"));
3109 wxLogMessage(m);
3110 }
3111
3112 void wxPyLogInfo(const wxString& msg)
3113 {
3114 wxString m(msg);
3115 m.Replace(wxT("%"), wxT("%%"));
3116 wxLogInfo(m);
3117 }
3118
3119 void wxPyLogDebug(const wxString& msg)
3120 {
3121 wxString m(msg);
3122 m.Replace(wxT("%"), wxT("%%"));
3123 wxLogDebug(m);
3124 }
3125
3126 void wxPyLogVerbose(const wxString& msg)
3127 {
3128 wxString m(msg);
3129 m.Replace(wxT("%"), wxT("%%"));
3130 wxLogVerbose(m);
3131 }
3132
3133 void wxPyLogStatus(const wxString& msg)
3134 {
3135 wxString m(msg);
3136 m.Replace(wxT("%"), wxT("%%"));
3137 wxLogStatus(m);
3138 }
3139
3140 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3141 {
3142 wxString m(msg);
3143 m.Replace(wxT("%"), wxT("%%"));
3144 wxLogStatus(pFrame, m);
3145 }
3146
3147 void wxPyLogSysError(const wxString& msg)
3148 {
3149 wxString m(msg);
3150 m.Replace(wxT("%"), wxT("%%"));
3151 wxLogSysError(m);
3152 }
3153
3154 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3155 {
3156 wxString m(msg);
3157 m.Replace(wxT("%"), wxT("%%"));
3158 wxLogGeneric(level, m);
3159 }
3160
3161 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3162 {
3163 wxString m(msg);
3164 m.Replace(wxT("%"), wxT("%%"));
3165 wxLogTrace(mask, m);
3166 }
3167
3168 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3169 {
3170 wxString m(msg);
3171 m.Replace(wxT("%"), wxT("%%"));
3172 wxLogTrace(mask, m);
3173 }
3174
3175
3176
3177 // A wxLog class that can be derived from in wxPython
3178 class wxPyLog : public wxLog {
3179 public:
3180 wxPyLog() : wxLog() {}
3181
3182 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3183 bool found;
3184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3185 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3186 PyObject* s = wx2PyString(szString);
3187 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3188 Py_DECREF(s);
3189 }
3190 wxPyEndBlockThreads(blocked);
3191 if (! found)
3192 wxLog::DoLog(level, szString, t);
3193 }
3194
3195 virtual void DoLogString(const wxChar *szString, time_t t) {
3196 bool found;
3197 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3198 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3199 PyObject* s = wx2PyString(szString);
3200 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3201 Py_DECREF(s);
3202 }
3203 wxPyEndBlockThreads(blocked);
3204 if (! found)
3205 wxLog::DoLogString(szString, t);
3206 }
3207
3208 DEC_PYCALLBACK_VOID_(Flush);
3209 PYPRIVATE;
3210 };
3211 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3212
3213
3214
3215
3216 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3217
3218
3219 #include <wx/joystick.h>
3220
3221
3222 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3223 // A C++ stub class for wxJoystick for platforms that don't have it.
3224 class wxJoystick : public wxObject {
3225 public:
3226 wxJoystick(int joystick = wxJOYSTICK1) {
3227 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3228 PyErr_SetString(PyExc_NotImplementedError,
3229 "wxJoystick is not available on this platform.");
3230 wxPyEndBlockThreads(blocked);
3231 }
3232 wxPoint GetPosition() { return wxPoint(-1,-1); }
3233 int GetZPosition() { return -1; }
3234 int GetButtonState() { return -1; }
3235 int GetPOVPosition() { return -1; }
3236 int GetPOVCTSPosition() { return -1; }
3237 int GetRudderPosition() { return -1; }
3238 int GetUPosition() { return -1; }
3239 int GetVPosition() { return -1; }
3240 int GetMovementThreshold() { return -1; }
3241 void SetMovementThreshold(int threshold) {}
3242
3243 bool IsOk(void) { return false; }
3244 int GetNumberJoysticks() { return -1; }
3245 int GetManufacturerId() { return -1; }
3246 int GetProductId() { return -1; }
3247 wxString GetProductName() { return wxEmptyString; }
3248 int GetXMin() { return -1; }
3249 int GetYMin() { return -1; }
3250 int GetZMin() { return -1; }
3251 int GetXMax() { return -1; }
3252 int GetYMax() { return -1; }
3253 int GetZMax() { return -1; }
3254 int GetNumberButtons() { return -1; }
3255 int GetNumberAxes() { return -1; }
3256 int GetMaxButtons() { return -1; }
3257 int GetMaxAxes() { return -1; }
3258 int GetPollingMin() { return -1; }
3259 int GetPollingMax() { return -1; }
3260 int GetRudderMin() { return -1; }
3261 int GetRudderMax() { return -1; }
3262 int GetUMin() { return -1; }
3263 int GetUMax() { return -1; }
3264 int GetVMin() { return -1; }
3265 int GetVMax() { return -1; }
3266
3267 bool HasRudder() { return false; }
3268 bool HasZ() { return false; }
3269 bool HasU() { return false; }
3270 bool HasV() { return false; }
3271 bool HasPOV() { return false; }
3272 bool HasPOV4Dir() { return false; }
3273 bool HasPOVCTS() { return false; }
3274
3275 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3276 bool ReleaseCapture() { return false; }
3277 };
3278 #endif
3279
3280
3281 #include <wx/sound.h>
3282
3283
3284 #if !wxUSE_SOUND
3285 // A C++ stub class for wxWave for platforms that don't have it.
3286 class wxSound : public wxObject
3287 {
3288 public:
3289 wxSound() {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295 wxSound(const wxString&/*, bool*/) {
3296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3297 PyErr_SetString(PyExc_NotImplementedError,
3298 "wxSound is not available on this platform.");
3299 wxPyEndBlockThreads(blocked);
3300 }
3301 wxSound(int, const wxByte*) {
3302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3303 PyErr_SetString(PyExc_NotImplementedError,
3304 "wxSound is not available on this platform.");
3305 wxPyEndBlockThreads(blocked);
3306 }
3307
3308 ~wxSound() {};
3309
3310 bool Create(const wxString&/*, bool*/) { return false; }
3311 bool Create(int, const wxByte*) { return false; };
3312 bool IsOk() { return false; };
3313 bool Play(unsigned) const { return false; }
3314 static bool Play(const wxString&, unsigned) { return false; }
3315 static void Stop() {}
3316 };
3317
3318 #endif
3319
3320 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3321 if (fileName.Length() == 0)
3322 return new wxSound;
3323 else
3324 return new wxSound(fileName);
3325 }
3326 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3327 unsigned char* buffer; int size;
3328 wxSound *sound = NULL;
3329
3330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3331 if (!PyArg_Parse(data, "t#", &buffer, &size))
3332 goto done;
3333 sound = new wxSound(size, buffer);
3334 done:
3335 wxPyEndBlockThreads(blocked);
3336 return sound;
3337 }
3338 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3339 #ifndef __WXMAC__
3340 unsigned char* buffer;
3341 int size;
3342 bool rv = false;
3343
3344 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3345 if (!PyArg_Parse(data, "t#", &buffer, &size))
3346 goto done;
3347 rv = self->Create(size, buffer);
3348 done:
3349 wxPyEndBlockThreads(blocked);
3350 return rv;
3351 #else
3352 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3353 PyErr_SetString(PyExc_NotImplementedError,
3354 "Create from data is not available on this platform.");
3355 wxPyEndBlockThreads(blocked);
3356 return false;
3357 #endif
3358 }
3359
3360 #include <wx/mimetype.h>
3361
3362 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3363 wxString str;
3364 if (self->GetMimeType(&str))
3365 return wx2PyString(str);
3366 else
3367 RETURN_NONE();
3368 }
3369 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3370 wxArrayString arr;
3371 if (self->GetMimeTypes(arr))
3372 return wxArrayString2PyList_helper(arr);
3373 else
3374 RETURN_NONE();
3375 }
3376 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3377 wxArrayString arr;
3378 if (self->GetExtensions(arr))
3379 return wxArrayString2PyList_helper(arr);
3380 else
3381 RETURN_NONE();
3382 }
3383 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3384 wxIconLocation loc;
3385 if (self->GetIcon(&loc))
3386 return new wxIcon(loc);
3387 else
3388 return NULL;
3389 }
3390 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3391 wxIconLocation loc;
3392 if (self->GetIcon(&loc)) {
3393 wxString iconFile = loc.GetFileName();
3394 int iconIndex = -1;
3395
3396
3397
3398 // Make a tuple and put the values in it
3399 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3400 PyObject* tuple = PyTuple_New(3);
3401 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3402 wxT("wxIcon"), true));
3403 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3404 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3405 wxPyEndBlockThreads(blocked);
3406 return tuple;
3407 }
3408 else
3409 RETURN_NONE();
3410 }
3411 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3412 wxString str;
3413 if (self->GetDescription(&str))
3414 return wx2PyString(str);
3415 else
3416 RETURN_NONE();
3417 }
3418 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3419 wxString str;
3420 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3421 return wx2PyString(str);
3422 else
3423 RETURN_NONE();
3424 }
3425 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3426 wxString str;
3427 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3428 return wx2PyString(str);
3429 else
3430 RETURN_NONE();
3431 }
3432 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3433 wxArrayString verbs;
3434 wxArrayString commands;
3435 if (self->GetAllCommands(&verbs, &commands,
3436 wxFileType::MessageParameters(filename, mimetype))) {
3437 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3438 PyObject* tuple = PyTuple_New(2);
3439 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3440 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3441 wxPyEndBlockThreads(blocked);
3442 return tuple;
3443 }
3444 else
3445 RETURN_NONE();
3446 }
3447 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3448 return wxFileType::ExpandCommand(command,
3449 wxFileType::MessageParameters(filename, mimetype));
3450 }
3451 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3452 wxArrayString arr;
3453 self->EnumAllFileTypes(arr);
3454 return wxArrayString2PyList_helper(arr);
3455 }
3456
3457 #include <wx/artprov.h>
3458
3459 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3460 static const wxString wxPyART_MENU(wxART_MENU);
3461 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3462 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3463 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3464 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3465 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3466 static const wxString wxPyART_LIST(wxART_LIST);
3467 static const wxString wxPyART_OTHER(wxART_OTHER);
3468 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3469 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3470 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3471 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3472 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3473 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3474 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3475 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3476 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3477 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3478 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3479 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3480 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3481 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3482 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3483 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3484 static const wxString wxPyART_PRINT(wxART_PRINT);
3485 static const wxString wxPyART_HELP(wxART_HELP);
3486 static const wxString wxPyART_TIP(wxART_TIP);
3487 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3488 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3489 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3490 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3491 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3492 static const wxString wxPyART_CDROM(wxART_CDROM);
3493 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3494 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3495 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3496 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3497 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3498 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3499 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3500 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3501 static const wxString wxPyART_ERROR(wxART_ERROR);
3502 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3503 static const wxString wxPyART_WARNING(wxART_WARNING);
3504 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3505 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3506 static const wxString wxPyART_COPY(wxART_COPY);
3507 static const wxString wxPyART_CUT(wxART_CUT);
3508 static const wxString wxPyART_PASTE(wxART_PASTE);
3509 static const wxString wxPyART_DELETE(wxART_DELETE);
3510 static const wxString wxPyART_NEW(wxART_NEW);
3511 static const wxString wxPyART_UNDO(wxART_UNDO);
3512 static const wxString wxPyART_REDO(wxART_REDO);
3513 static const wxString wxPyART_QUIT(wxART_QUIT);
3514 static const wxString wxPyART_FIND(wxART_FIND);
3515 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3516 // Python aware wxArtProvider
3517 class wxPyArtProvider : public wxArtProvider {
3518 public:
3519
3520 virtual wxBitmap CreateBitmap(const wxArtID& id,
3521 const wxArtClient& client,
3522 const wxSize& size) {
3523 wxBitmap rval = wxNullBitmap;
3524 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3525 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3526 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3527 PyObject* ro;
3528 wxBitmap* ptr;
3529 PyObject* s1, *s2;
3530 s1 = wx2PyString(id);
3531 s2 = wx2PyString(client);
3532 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3533 Py_DECREF(so);
3534 Py_DECREF(s1);
3535 Py_DECREF(s2);
3536 if (ro) {
3537 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3538 rval = *ptr;
3539 Py_DECREF(ro);
3540 }
3541 }
3542 wxPyEndBlockThreads(blocked);
3543 return rval;
3544 }
3545
3546 virtual wxIconBundle CreateIconBundle(const wxArtID& id,
3547 const wxArtClient& client)
3548 {
3549 wxIconBundle rval = wxNullIconBundle;
3550 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3551 if ((wxPyCBH_findCallback(m_myInst, "CreateIconBundle"))) {
3552 PyObject* ro;
3553 wxIconBundle* ptr;
3554 PyObject* s1, *s2;
3555 s1 = wx2PyString(id);
3556 s2 = wx2PyString(client);
3557 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)", s1, s2));
3558 Py_DECREF(s1);
3559 Py_DECREF(s2);
3560 if (ro) {
3561 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxIconBundle")))
3562 rval = *ptr;
3563 Py_DECREF(ro);
3564 }
3565 }
3566 wxPyEndBlockThreads(blocked);
3567 return rval;
3568 }
3569
3570 PYPRIVATE;
3571 };
3572
3573 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3574
3575
3576
3577 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3578 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3579 PyObject* ret = PyTuple_New(3);
3580 if (ret) {
3581 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3582 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3583 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3584 }
3585 wxPyEndBlockThreads(blocked);
3586 return ret;
3587 }
3588
3589 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3590 bool cont;
3591 long index = 0;
3592 wxString value;
3593
3594 cont = self->GetFirstGroup(value, index);
3595 return __EnumerationHelper(cont, value, index);
3596 }
3597 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3598 bool cont;
3599 wxString value;
3600
3601 cont = self->GetNextGroup(value, index);
3602 return __EnumerationHelper(cont, value, index);
3603 }
3604 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3605 bool cont;
3606 long index = 0;
3607 wxString value;
3608
3609 cont = self->GetFirstEntry(value, index);
3610 return __EnumerationHelper(cont, value, index);
3611 }
3612 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3613 bool cont;
3614 wxString value;
3615
3616 cont = self->GetNextEntry(value, index);
3617 return __EnumerationHelper(cont, value, index);
3618 }
3619 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3620 long rv;
3621 self->Read(key, &rv, defaultVal);
3622 return rv;
3623 }
3624
3625 SWIGINTERN int
3626 SWIG_AsVal_double (PyObject *obj, double* val)
3627 {
3628 if (PyNumber_Check(obj)) {
3629 if (val) *val = PyFloat_AsDouble(obj);
3630 return SWIG_OK;
3631 }
3632 return SWIG_TypeError;
3633 }
3634
3635 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3636 double rv;
3637 self->Read(key, &rv, defaultVal);
3638 return rv;
3639 }
3640
3641 #define SWIG_From_double PyFloat_FromDouble
3642
3643 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3644 bool rv;
3645 self->Read(key, &rv, defaultVal);
3646 return rv;
3647 }
3648
3649 #include <wx/datetime.h>
3650
3651 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3652 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3653
3654 #define LOCAL_TZ wxDateTime::Local
3655
3656 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3657 wxString am;
3658 wxString pm;
3659 wxDateTime::GetAmPmStrings(&am, &pm);
3660 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3661 PyObject* tup = PyTuple_New(2);
3662 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3663 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3664 wxPyEndBlockThreads(blocked);
3665 return tup;
3666 }
3667
3668 SWIGINTERNINLINE PyObject *
3669 SWIG_From_unsigned_SS_int (unsigned int value)
3670 {
3671 return SWIG_From_unsigned_SS_long (value);
3672 }
3673
3674 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3675 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3676 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3677 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3678 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3679 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3680 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3681 return (*self < *other);
3682 }
3683 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3684 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3685 return (*self <= *other);
3686 }
3687 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3688 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3689 return (*self > *other);
3690 }
3691 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3692 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3693 return (*self >= *other);
3694 }
3695 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3696 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3697 return (*self == *other);
3698 }
3699 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3700 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3701 return (*self != *other);
3702 }
3703 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3704 const wxChar* rv;
3705 const wxChar* _date = date;
3706 rv = self->ParseRfc822Date(_date);
3707 if (rv == NULL) return -1;
3708 return rv - _date;
3709 }
3710 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3711 const wxChar* rv;
3712 const wxChar* _date = date;
3713 rv = self->ParseFormat(_date, format, dateDef);
3714 if (rv == NULL) return -1;
3715 return rv - _date;
3716 }
3717 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3718 const wxChar* rv;
3719 const wxChar* _datetime = datetime;
3720 rv = self->ParseDateTime(_datetime);
3721 if (rv == NULL) return -1;
3722 return rv - _datetime;
3723 }
3724 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3725 const wxChar* rv;
3726 const wxChar* _date = date;
3727 rv = self->ParseDate(_date);
3728 if (rv == NULL) return -1;
3729 return rv - _date;
3730 }
3731 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3732 const wxChar* rv;
3733 const wxChar* _time = time;
3734 rv = self->ParseTime(_time);
3735 if (rv == NULL) return -1;
3736 return rv - _time;
3737 }
3738 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3739 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3740 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3741 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3742 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3743 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3744 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3745 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3746 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3747 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3748 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3749 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3750 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3751 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3752 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3753 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3754
3755 #include <wx/dataobj.h>
3756
3757 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3758 size_t count = self->GetFormatCount(dir);
3759 wxDataFormat* formats = new wxDataFormat[count];
3760 self->GetAllFormats(formats, dir);
3761
3762 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3763 PyObject* list = PyList_New(count);
3764 for (size_t i=0; i<count; i++) {
3765 wxDataFormat* format = new wxDataFormat(formats[i]);
3766 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3767 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3768 }
3769 wxPyEndBlockThreads(blocked);
3770 delete [] formats;
3771 return list;
3772 }
3773 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3774 PyObject* rval = NULL;
3775 size_t size = self->GetDataSize(format);
3776 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3777 if (size) {
3778 char* buf = new char[size];
3779 if (self->GetDataHere(format, buf))
3780 rval = PyString_FromStringAndSize(buf, size);
3781 delete [] buf;
3782 }
3783 if (! rval) {
3784 rval = Py_None;
3785 Py_INCREF(rval);
3786 }
3787 wxPyEndBlockThreads(blocked);
3788 return rval;
3789 }
3790 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3791 bool rval;
3792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3793 if (PyString_Check(data)) {
3794 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3795 }
3796 else {
3797 // raise a TypeError if not a string
3798 PyErr_SetString(PyExc_TypeError, "String expected.");
3799 rval = false;
3800 }
3801 wxPyEndBlockThreads(blocked);
3802 return rval;
3803 }
3804 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3805 PyObject* rval = NULL;
3806 size_t size = self->GetDataSize();
3807 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3808 if (size) {
3809 char* buf = new char[size];
3810 if (self->GetDataHere(buf))
3811 rval = PyString_FromStringAndSize(buf, size);
3812 delete [] buf;
3813 }
3814 if (! rval) {
3815 rval = Py_None;
3816 Py_INCREF(rval);
3817 }
3818 wxPyEndBlockThreads(blocked);
3819 return rval;
3820 }
3821 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3822 bool rval;
3823 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3824 if (PyString_Check(data)) {
3825 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3826 }
3827 else {
3828 // raise a TypeError if not a string
3829 PyErr_SetString(PyExc_TypeError, "String expected.");
3830 rval = false;
3831 }
3832 wxPyEndBlockThreads(blocked);
3833 return rval;
3834 }
3835 // Create a new class for wxPython to use
3836 class wxPyDataObjectSimple : public wxDataObjectSimple {
3837 public:
3838 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3839 : wxDataObjectSimple(format) {}
3840
3841 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3842 bool GetDataHere(void *buf) const;
3843 bool SetData(size_t len, const void *buf);
3844 PYPRIVATE;
3845 };
3846
3847 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3848
3849 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3850 // We need to get the data for this object and write it to buf. I think
3851 // the best way to do this for wxPython is to have the Python method
3852 // return either a string or None and then act appropriately with the
3853 // C++ version.
3854
3855 bool rval = false;
3856 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3857 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3858 PyObject* ro;
3859 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3860 if (ro) {
3861 rval = (ro != Py_None && PyString_Check(ro));
3862 if (rval)
3863 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3864 Py_DECREF(ro);
3865 }
3866 }
3867 wxPyEndBlockThreads(blocked);
3868 return rval;
3869 }
3870
3871 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3872 // For this one we simply need to make a string from buf and len
3873 // and send it to the Python method.
3874 bool rval = false;
3875 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3876 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3877 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3878 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3879 Py_DECREF(data);
3880 }
3881 wxPyEndBlockThreads(blocked);
3882 return rval;
3883 }
3884
3885 // Create a new class for wxPython to use
3886 class wxPyTextDataObject : public wxTextDataObject {
3887 public:
3888 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3889 : wxTextDataObject(text) {}
3890
3891 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3892 DEC_PYCALLBACK_STRING__const(GetText);
3893 DEC_PYCALLBACK__STRING(SetText);
3894 PYPRIVATE;
3895 };
3896
3897 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3898 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3899 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3900
3901
3902 // Create a new class for wxPython to use
3903 class wxPyBitmapDataObject : public wxBitmapDataObject {
3904 public:
3905 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3906 : wxBitmapDataObject(bitmap) {}
3907
3908 wxBitmap GetBitmap() const;
3909 void SetBitmap(const wxBitmap& bitmap);
3910 PYPRIVATE;
3911 };
3912
3913 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3914 wxBitmap* rval = &wxNullBitmap;
3915 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3916 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3917 PyObject* ro;
3918 wxBitmap* ptr;
3919 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3920 if (ro) {
3921 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3922 rval = ptr;
3923 Py_DECREF(ro);
3924 }
3925 }
3926 wxPyEndBlockThreads(blocked);
3927 return *rval;
3928 }
3929
3930 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3931 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3932 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3933 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3934 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3935 Py_DECREF(bo);
3936 }
3937 wxPyEndBlockThreads(blocked);
3938 }
3939
3940 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3941 return new wxCustomDataObject(wxDataFormat(formatName));
3942 }
3943 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3944 bool rval;
3945 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3946 if (PyString_Check(data)) {
3947 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3948 }
3949 else {
3950 // raise a TypeError if not a string
3951 PyErr_SetString(PyExc_TypeError, "String expected.");
3952 rval = false;
3953 }
3954 wxPyEndBlockThreads(blocked);
3955 return rval;
3956 }
3957 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3958 PyObject* obj;
3959 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3960 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3961 wxPyEndBlockThreads(blocked);
3962 return obj;
3963 }
3964
3965 #include <wx/metafile.h>
3966
3967
3968 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3969
3970
3971 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3972 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3973 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3974 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3975 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3976
3977
3978 class wxPyTextDropTarget : public wxTextDropTarget {
3979 public:
3980 wxPyTextDropTarget() {}
3981
3982 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3983
3984 DEC_PYCALLBACK__(OnLeave);
3985 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3986 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3987 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3988 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3989
3990 PYPRIVATE;
3991 };
3992
3993 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3994 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3995 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3998 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3999
4000
4001
4002 class wxPyFileDropTarget : public wxFileDropTarget {
4003 public:
4004 wxPyFileDropTarget() {}
4005
4006 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
4007
4008 DEC_PYCALLBACK__(OnLeave);
4009 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
4010 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
4011 DEC_PYCALLBACK_DR_2WXCDR(OnData);
4012 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
4013
4014 PYPRIVATE;
4015 };
4016
4017 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
4018 const wxArrayString& filenames) {
4019 bool rval = false;
4020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4021 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
4022 PyObject* list = wxArrayString2PyList_helper(filenames);
4023 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
4024 Py_DECREF(list);
4025 }
4026 wxPyEndBlockThreads(blocked);
4027 return rval;
4028 }
4029
4030
4031
4032 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4033 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4034 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4035 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4036 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4037
4038
4039
4040
4041 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4042
4043 #include <wx/display.h>
4044 #include <wx/vidmode.h>
4045
4046 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4047 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4048
4049 #if !wxUSE_DISPLAY
4050 const wxVideoMode wxDefaultVideoMode;
4051 #endif
4052
4053 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4054 #if wxUSE_DISPLAY
4055 PyObject* pyList = NULL;
4056 wxArrayVideoModes arr = self->GetModes(mode);
4057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4058 pyList = PyList_New(0);
4059 for (size_t i=0; i < arr.GetCount(); i++)
4060 {
4061 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4062 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4063 PyList_Append(pyList, pyObj);
4064 Py_DECREF(pyObj);
4065 }
4066 wxPyEndBlockThreads(blocked);
4067 return pyList;
4068 #else
4069 wxPyRaiseNotImplemented();
4070 return NULL;
4071 #endif
4072 }
4073 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4074 #if wxUSE_DISPLAY
4075 return self->GetCurrentMode();
4076 #else
4077 wxPyRaiseNotImplemented();
4078 return wxDefaultVideoMode;
4079 #endif
4080 }
4081 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4082 #if wxUSE_DISPLAY
4083 return self->ChangeMode(mode);
4084 #else
4085 wxPyRaiseNotImplemented();
4086 return false;
4087 #endif
4088 }
4089 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4090 #if wxUSE_DISPLAY
4091 self->ResetMode();
4092 #else
4093 wxPyRaiseNotImplemented();
4094 #endif
4095 }
4096
4097 #include <wx/stdpaths.h>
4098
4099 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4100 return (wxStandardPaths*) &wxStandardPaths::Get();
4101 }
4102 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4103 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4104
4105 #ifndef wxHAS_POWER_EVENTS
4106 // Dummy class and other definitions for platforms that don't have them
4107
4108 // See wxPython_int.h for wxPowerEvent
4109
4110 enum {
4111 wxEVT_POWER_SUSPENDING,
4112 wxEVT_POWER_SUSPENDED,
4113 wxEVT_POWER_SUSPEND_CANCEL,
4114 wxEVT_POWER_RESUME,
4115 };
4116
4117 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4118 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4119
4120 #endif
4121
4122
4123 #include <wx/aboutdlg.h>
4124
4125 #ifdef __cplusplus
4126 extern "C" {
4127 #endif
4128 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4129 PyObject *resultobj = 0;
4130 wxSystemColour arg1 ;
4131 wxColour result;
4132 int val1 ;
4133 int ecode1 = 0 ;
4134 PyObject * obj0 = 0 ;
4135 char * kwnames[] = {
4136 (char *) "index", NULL
4137 };
4138
4139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4140 ecode1 = SWIG_AsVal_int(obj0, &val1);
4141 if (!SWIG_IsOK(ecode1)) {
4142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4143 }
4144 arg1 = static_cast< wxSystemColour >(val1);
4145 {
4146 if (!wxPyCheckForApp()) SWIG_fail;
4147 PyThreadState* __tstate = wxPyBeginAllowThreads();
4148 result = wxSystemSettings::GetColour(arg1);
4149 wxPyEndAllowThreads(__tstate);
4150 if (PyErr_Occurred()) SWIG_fail;
4151 }
4152 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4153 return resultobj;
4154 fail:
4155 return NULL;
4156 }
4157
4158
4159 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4160 PyObject *resultobj = 0;
4161 wxSystemFont arg1 ;
4162 wxFont result;
4163 int val1 ;
4164 int ecode1 = 0 ;
4165 PyObject * obj0 = 0 ;
4166 char * kwnames[] = {
4167 (char *) "index", NULL
4168 };
4169
4170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4171 ecode1 = SWIG_AsVal_int(obj0, &val1);
4172 if (!SWIG_IsOK(ecode1)) {
4173 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4174 }
4175 arg1 = static_cast< wxSystemFont >(val1);
4176 {
4177 if (!wxPyCheckForApp()) SWIG_fail;
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = wxSystemSettings::GetFont(arg1);
4180 wxPyEndAllowThreads(__tstate);
4181 if (PyErr_Occurred()) SWIG_fail;
4182 }
4183 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4184 return resultobj;
4185 fail:
4186 return NULL;
4187 }
4188
4189
4190 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4191 PyObject *resultobj = 0;
4192 wxSystemMetric arg1 ;
4193 wxWindow *arg2 = (wxWindow *) NULL ;
4194 int result;
4195 int val1 ;
4196 int ecode1 = 0 ;
4197 void *argp2 = 0 ;
4198 int res2 = 0 ;
4199 PyObject * obj0 = 0 ;
4200 PyObject * obj1 = 0 ;
4201 char * kwnames[] = {
4202 (char *) "index",(char *) "win", NULL
4203 };
4204
4205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4206 ecode1 = SWIG_AsVal_int(obj0, &val1);
4207 if (!SWIG_IsOK(ecode1)) {
4208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4209 }
4210 arg1 = static_cast< wxSystemMetric >(val1);
4211 if (obj1) {
4212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4213 if (!SWIG_IsOK(res2)) {
4214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4215 }
4216 arg2 = reinterpret_cast< wxWindow * >(argp2);
4217 }
4218 {
4219 if (!wxPyCheckForApp()) SWIG_fail;
4220 PyThreadState* __tstate = wxPyBeginAllowThreads();
4221 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4222 wxPyEndAllowThreads(__tstate);
4223 if (PyErr_Occurred()) SWIG_fail;
4224 }
4225 resultobj = SWIG_From_int(static_cast< int >(result));
4226 return resultobj;
4227 fail:
4228 return NULL;
4229 }
4230
4231
4232 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4233 PyObject *resultobj = 0;
4234 wxSystemFeature arg1 ;
4235 bool result;
4236 int val1 ;
4237 int ecode1 = 0 ;
4238 PyObject * obj0 = 0 ;
4239 char * kwnames[] = {
4240 (char *) "index", NULL
4241 };
4242
4243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4244 ecode1 = SWIG_AsVal_int(obj0, &val1);
4245 if (!SWIG_IsOK(ecode1)) {
4246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4247 }
4248 arg1 = static_cast< wxSystemFeature >(val1);
4249 {
4250 if (!wxPyCheckForApp()) SWIG_fail;
4251 PyThreadState* __tstate = wxPyBeginAllowThreads();
4252 result = (bool)wxSystemSettings::HasFeature(arg1);
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 {
4257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4258 }
4259 return resultobj;
4260 fail:
4261 return NULL;
4262 }
4263
4264
4265 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4266 PyObject *resultobj = 0;
4267 wxSystemScreenType result;
4268
4269 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4270 {
4271 if (!wxPyCheckForApp()) SWIG_fail;
4272 PyThreadState* __tstate = wxPyBeginAllowThreads();
4273 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4274 wxPyEndAllowThreads(__tstate);
4275 if (PyErr_Occurred()) SWIG_fail;
4276 }
4277 resultobj = SWIG_From_int(static_cast< int >(result));
4278 return resultobj;
4279 fail:
4280 return NULL;
4281 }
4282
4283
4284 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4285 PyObject *resultobj = 0;
4286 wxSystemScreenType arg1 ;
4287 int val1 ;
4288 int ecode1 = 0 ;
4289 PyObject * obj0 = 0 ;
4290 char * kwnames[] = {
4291 (char *) "screen", NULL
4292 };
4293
4294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4295 ecode1 = SWIG_AsVal_int(obj0, &val1);
4296 if (!SWIG_IsOK(ecode1)) {
4297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4298 }
4299 arg1 = static_cast< wxSystemScreenType >(val1);
4300 {
4301 if (!wxPyCheckForApp()) SWIG_fail;
4302 PyThreadState* __tstate = wxPyBeginAllowThreads();
4303 wxSystemSettings::SetScreenType(arg1);
4304 wxPyEndAllowThreads(__tstate);
4305 if (PyErr_Occurred()) SWIG_fail;
4306 }
4307 resultobj = SWIG_Py_Void();
4308 return resultobj;
4309 fail:
4310 return NULL;
4311 }
4312
4313
4314 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4315 PyObject *obj;
4316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4317 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4318 return SWIG_Py_Void();
4319 }
4320
4321 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4322 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4323 return 1;
4324 }
4325
4326
4327 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4328 PyObject *pyobj = 0;
4329
4330 {
4331 #if wxUSE_UNICODE
4332 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4333 #else
4334 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4335 #endif
4336 }
4337 return pyobj;
4338 }
4339
4340
4341 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4342 PyObject *resultobj = 0;
4343 wxSystemOptions *result = 0 ;
4344
4345 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4346 {
4347 PyThreadState* __tstate = wxPyBeginAllowThreads();
4348 result = (wxSystemOptions *)new wxSystemOptions();
4349 wxPyEndAllowThreads(__tstate);
4350 if (PyErr_Occurred()) SWIG_fail;
4351 }
4352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj = 0;
4361 wxString *arg1 = 0 ;
4362 wxString *arg2 = 0 ;
4363 bool temp1 = false ;
4364 bool temp2 = false ;
4365 PyObject * obj0 = 0 ;
4366 PyObject * obj1 = 0 ;
4367 char * kwnames[] = {
4368 (char *) "name",(char *) "value", NULL
4369 };
4370
4371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4372 {
4373 arg1 = wxString_in_helper(obj0);
4374 if (arg1 == NULL) SWIG_fail;
4375 temp1 = true;
4376 }
4377 {
4378 arg2 = wxString_in_helper(obj1);
4379 if (arg2 == NULL) SWIG_fail;
4380 temp2 = true;
4381 }
4382 {
4383 PyThreadState* __tstate = wxPyBeginAllowThreads();
4384 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4385 wxPyEndAllowThreads(__tstate);
4386 if (PyErr_Occurred()) SWIG_fail;
4387 }
4388 resultobj = SWIG_Py_Void();
4389 {
4390 if (temp1)
4391 delete arg1;
4392 }
4393 {
4394 if (temp2)
4395 delete arg2;
4396 }
4397 return resultobj;
4398 fail:
4399 {
4400 if (temp1)
4401 delete arg1;
4402 }
4403 {
4404 if (temp2)
4405 delete arg2;
4406 }
4407 return NULL;
4408 }
4409
4410
4411 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4412 PyObject *resultobj = 0;
4413 wxString *arg1 = 0 ;
4414 int arg2 ;
4415 bool temp1 = false ;
4416 int val2 ;
4417 int ecode2 = 0 ;
4418 PyObject * obj0 = 0 ;
4419 PyObject * obj1 = 0 ;
4420 char * kwnames[] = {
4421 (char *) "name",(char *) "value", NULL
4422 };
4423
4424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4425 {
4426 arg1 = wxString_in_helper(obj0);
4427 if (arg1 == NULL) SWIG_fail;
4428 temp1 = true;
4429 }
4430 ecode2 = SWIG_AsVal_int(obj1, &val2);
4431 if (!SWIG_IsOK(ecode2)) {
4432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4433 }
4434 arg2 = static_cast< int >(val2);
4435 {
4436 PyThreadState* __tstate = wxPyBeginAllowThreads();
4437 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 resultobj = SWIG_Py_Void();
4442 {
4443 if (temp1)
4444 delete arg1;
4445 }
4446 return resultobj;
4447 fail:
4448 {
4449 if (temp1)
4450 delete arg1;
4451 }
4452 return NULL;
4453 }
4454
4455
4456 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj = 0;
4458 wxString *arg1 = 0 ;
4459 wxString result;
4460 bool temp1 = false ;
4461 PyObject * obj0 = 0 ;
4462 char * kwnames[] = {
4463 (char *) "name", NULL
4464 };
4465
4466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4467 {
4468 arg1 = wxString_in_helper(obj0);
4469 if (arg1 == NULL) SWIG_fail;
4470 temp1 = true;
4471 }
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 {
4479 #if wxUSE_UNICODE
4480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4481 #else
4482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4483 #endif
4484 }
4485 {
4486 if (temp1)
4487 delete arg1;
4488 }
4489 return resultobj;
4490 fail:
4491 {
4492 if (temp1)
4493 delete arg1;
4494 }
4495 return NULL;
4496 }
4497
4498
4499 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4500 PyObject *resultobj = 0;
4501 wxString *arg1 = 0 ;
4502 int result;
4503 bool temp1 = false ;
4504 PyObject * obj0 = 0 ;
4505 char * kwnames[] = {
4506 (char *) "name", NULL
4507 };
4508
4509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4510 {
4511 arg1 = wxString_in_helper(obj0);
4512 if (arg1 == NULL) SWIG_fail;
4513 temp1 = true;
4514 }
4515 {
4516 PyThreadState* __tstate = wxPyBeginAllowThreads();
4517 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4518 wxPyEndAllowThreads(__tstate);
4519 if (PyErr_Occurred()) SWIG_fail;
4520 }
4521 resultobj = SWIG_From_int(static_cast< int >(result));
4522 {
4523 if (temp1)
4524 delete arg1;
4525 }
4526 return resultobj;
4527 fail:
4528 {
4529 if (temp1)
4530 delete arg1;
4531 }
4532 return NULL;
4533 }
4534
4535
4536 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4537 PyObject *resultobj = 0;
4538 wxString *arg1 = 0 ;
4539 bool result;
4540 bool temp1 = false ;
4541 PyObject * obj0 = 0 ;
4542 char * kwnames[] = {
4543 (char *) "name", NULL
4544 };
4545
4546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4547 {
4548 arg1 = wxString_in_helper(obj0);
4549 if (arg1 == NULL) SWIG_fail;
4550 temp1 = true;
4551 }
4552 {
4553 PyThreadState* __tstate = wxPyBeginAllowThreads();
4554 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4555 wxPyEndAllowThreads(__tstate);
4556 if (PyErr_Occurred()) SWIG_fail;
4557 }
4558 {
4559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4560 }
4561 {
4562 if (temp1)
4563 delete arg1;
4564 }
4565 return resultobj;
4566 fail:
4567 {
4568 if (temp1)
4569 delete arg1;
4570 }
4571 return NULL;
4572 }
4573
4574
4575 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4576 PyObject *resultobj = 0;
4577 wxString *arg1 = 0 ;
4578 bool result;
4579 bool temp1 = false ;
4580 PyObject * obj0 = 0 ;
4581 char * kwnames[] = {
4582 (char *) "name", NULL
4583 };
4584
4585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4586 {
4587 arg1 = wxString_in_helper(obj0);
4588 if (arg1 == NULL) SWIG_fail;
4589 temp1 = true;
4590 }
4591 {
4592 PyThreadState* __tstate = wxPyBeginAllowThreads();
4593 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4594 wxPyEndAllowThreads(__tstate);
4595 if (PyErr_Occurred()) SWIG_fail;
4596 }
4597 {
4598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4599 }
4600 {
4601 if (temp1)
4602 delete arg1;
4603 }
4604 return resultobj;
4605 fail:
4606 {
4607 if (temp1)
4608 delete arg1;
4609 }
4610 return NULL;
4611 }
4612
4613
4614 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4615 PyObject *obj;
4616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4617 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4618 return SWIG_Py_Void();
4619 }
4620
4621 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4622 return SWIG_Python_InitShadowInstance(args);
4623 }
4624
4625 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4626 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4627 return 1;
4628 }
4629
4630
4631 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4632 PyObject *pyobj = 0;
4633
4634 {
4635 #if wxUSE_UNICODE
4636 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4637 #else
4638 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4639 #endif
4640 }
4641 return pyobj;
4642 }
4643
4644
4645 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4646 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4647 return 1;
4648 }
4649
4650
4651 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4652 PyObject *pyobj = 0;
4653
4654 {
4655 #if wxUSE_UNICODE
4656 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4657 #else
4658 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4659 #endif
4660 }
4661 return pyobj;
4662 }
4663
4664
4665 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4666 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4667 return 1;
4668 }
4669
4670
4671 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4672 PyObject *pyobj = 0;
4673
4674 {
4675 #if wxUSE_UNICODE
4676 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4677 #else
4678 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4679 #endif
4680 }
4681 return pyobj;
4682 }
4683
4684
4685 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4686 PyObject *resultobj = 0;
4687 long result;
4688
4689 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4690 {
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 result = (long)wxNewId();
4693 wxPyEndAllowThreads(__tstate);
4694 if (PyErr_Occurred()) SWIG_fail;
4695 }
4696 resultobj = SWIG_From_long(static_cast< long >(result));
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4704 PyObject *resultobj = 0;
4705 long arg1 ;
4706 long val1 ;
4707 int ecode1 = 0 ;
4708 PyObject * obj0 = 0 ;
4709 char * kwnames[] = {
4710 (char *) "id", NULL
4711 };
4712
4713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4714 ecode1 = SWIG_AsVal_long(obj0, &val1);
4715 if (!SWIG_IsOK(ecode1)) {
4716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4717 }
4718 arg1 = static_cast< long >(val1);
4719 {
4720 PyThreadState* __tstate = wxPyBeginAllowThreads();
4721 wxRegisterId(arg1);
4722 wxPyEndAllowThreads(__tstate);
4723 if (PyErr_Occurred()) SWIG_fail;
4724 }
4725 resultobj = SWIG_Py_Void();
4726 return resultobj;
4727 fail:
4728 return NULL;
4729 }
4730
4731
4732 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4733 PyObject *resultobj = 0;
4734 long result;
4735
4736 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 result = (long)wxGetCurrentId();
4740 wxPyEndAllowThreads(__tstate);
4741 if (PyErr_Occurred()) SWIG_fail;
4742 }
4743 resultobj = SWIG_From_long(static_cast< long >(result));
4744 return resultobj;
4745 fail:
4746 return NULL;
4747 }
4748
4749
4750 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4751 PyObject *resultobj = 0;
4752 int arg1 ;
4753 bool result;
4754 int val1 ;
4755 int ecode1 = 0 ;
4756 PyObject * obj0 = 0 ;
4757 char * kwnames[] = {
4758 (char *) "id", NULL
4759 };
4760
4761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4762 ecode1 = SWIG_AsVal_int(obj0, &val1);
4763 if (!SWIG_IsOK(ecode1)) {
4764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4765 }
4766 arg1 = static_cast< int >(val1);
4767 {
4768 PyThreadState* __tstate = wxPyBeginAllowThreads();
4769 result = (bool)wxIsStockID(arg1);
4770 wxPyEndAllowThreads(__tstate);
4771 if (PyErr_Occurred()) SWIG_fail;
4772 }
4773 {
4774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4775 }
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj = 0;
4784 int arg1 ;
4785 wxString *arg2 = 0 ;
4786 bool result;
4787 int val1 ;
4788 int ecode1 = 0 ;
4789 bool temp2 = false ;
4790 PyObject * obj0 = 0 ;
4791 PyObject * obj1 = 0 ;
4792 char * kwnames[] = {
4793 (char *) "id",(char *) "label", NULL
4794 };
4795
4796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4797 ecode1 = SWIG_AsVal_int(obj0, &val1);
4798 if (!SWIG_IsOK(ecode1)) {
4799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4800 }
4801 arg1 = static_cast< int >(val1);
4802 {
4803 arg2 = wxString_in_helper(obj1);
4804 if (arg2 == NULL) SWIG_fail;
4805 temp2 = true;
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4810 wxPyEndAllowThreads(__tstate);
4811 if (PyErr_Occurred()) SWIG_fail;
4812 }
4813 {
4814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4815 }
4816 {
4817 if (temp2)
4818 delete arg2;
4819 }
4820 return resultobj;
4821 fail:
4822 {
4823 if (temp2)
4824 delete arg2;
4825 }
4826 return NULL;
4827 }
4828
4829
4830 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj = 0;
4832 int arg1 ;
4833 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4834 wxString result;
4835 int val1 ;
4836 int ecode1 = 0 ;
4837 long val2 ;
4838 int ecode2 = 0 ;
4839 PyObject * obj0 = 0 ;
4840 PyObject * obj1 = 0 ;
4841 char * kwnames[] = {
4842 (char *) "id",(char *) "flags", NULL
4843 };
4844
4845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4846 ecode1 = SWIG_AsVal_int(obj0, &val1);
4847 if (!SWIG_IsOK(ecode1)) {
4848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4849 }
4850 arg1 = static_cast< int >(val1);
4851 if (obj1) {
4852 ecode2 = SWIG_AsVal_long(obj1, &val2);
4853 if (!SWIG_IsOK(ecode2)) {
4854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4855 }
4856 arg2 = static_cast< long >(val2);
4857 }
4858 {
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 result = wxGetStockLabel(arg1,arg2);
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 {
4865 #if wxUSE_UNICODE
4866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4867 #else
4868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4869 #endif
4870 }
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4878 PyObject *resultobj = 0;
4879 int arg1 ;
4880 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4881 wxString result;
4882 int val1 ;
4883 int ecode1 = 0 ;
4884 int val2 ;
4885 int ecode2 = 0 ;
4886 PyObject * obj0 = 0 ;
4887 PyObject * obj1 = 0 ;
4888 char * kwnames[] = {
4889 (char *) "id",(char *) "client", NULL
4890 };
4891
4892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4893 ecode1 = SWIG_AsVal_int(obj0, &val1);
4894 if (!SWIG_IsOK(ecode1)) {
4895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4896 }
4897 arg1 = static_cast< int >(val1);
4898 if (obj1) {
4899 ecode2 = SWIG_AsVal_int(obj1, &val2);
4900 if (!SWIG_IsOK(ecode2)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4902 }
4903 arg2 = static_cast< wxStockHelpStringClient >(val2);
4904 }
4905 {
4906 PyThreadState* __tstate = wxPyBeginAllowThreads();
4907 result = wxGetStockHelpString(arg1,arg2);
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 {
4912 #if wxUSE_UNICODE
4913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4914 #else
4915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4916 #endif
4917 }
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4925 PyObject *resultobj = 0;
4926
4927 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4928 {
4929 if (!wxPyCheckForApp()) SWIG_fail;
4930 PyThreadState* __tstate = wxPyBeginAllowThreads();
4931 wxBell();
4932 wxPyEndAllowThreads(__tstate);
4933 if (PyErr_Occurred()) SWIG_fail;
4934 }
4935 resultobj = SWIG_Py_Void();
4936 return resultobj;
4937 fail:
4938 return NULL;
4939 }
4940
4941
4942 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4943 PyObject *resultobj = 0;
4944
4945 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4946 {
4947 if (!wxPyCheckForApp()) SWIG_fail;
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 wxEndBusyCursor();
4950 wxPyEndAllowThreads(__tstate);
4951 if (PyErr_Occurred()) SWIG_fail;
4952 }
4953 resultobj = SWIG_Py_Void();
4954 return resultobj;
4955 fail:
4956 return NULL;
4957 }
4958
4959
4960 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4961 PyObject *resultobj = 0;
4962 bool result;
4963
4964 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4965 {
4966 PyThreadState* __tstate = wxPyBeginAllowThreads();
4967 result = (bool)wxIsBusy();
4968 wxPyEndAllowThreads(__tstate);
4969 if (PyErr_Occurred()) SWIG_fail;
4970 }
4971 {
4972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4973 }
4974 return resultobj;
4975 fail:
4976 return NULL;
4977 }
4978
4979
4980 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4981 PyObject *resultobj = 0;
4982 wxString result;
4983
4984 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4985 {
4986 PyThreadState* __tstate = wxPyBeginAllowThreads();
4987 result = wxNow();
4988 wxPyEndAllowThreads(__tstate);
4989 if (PyErr_Occurred()) SWIG_fail;
4990 }
4991 {
4992 #if wxUSE_UNICODE
4993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4994 #else
4995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4996 #endif
4997 }
4998 return resultobj;
4999 fail:
5000 return NULL;
5001 }
5002
5003
5004 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5005 PyObject *resultobj = 0;
5006 wxString const &arg1_defvalue = wxPyEmptyString ;
5007 wxString *arg1 = (wxString *) &arg1_defvalue ;
5008 bool result;
5009 bool temp1 = false ;
5010 PyObject * obj0 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "command", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5016 if (obj0) {
5017 {
5018 arg1 = wxString_in_helper(obj0);
5019 if (arg1 == NULL) SWIG_fail;
5020 temp1 = true;
5021 }
5022 }
5023 {
5024 PyThreadState* __tstate = wxPyBeginAllowThreads();
5025 result = (bool)wxShell((wxString const &)*arg1);
5026 wxPyEndAllowThreads(__tstate);
5027 if (PyErr_Occurred()) SWIG_fail;
5028 }
5029 {
5030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5031 }
5032 {
5033 if (temp1)
5034 delete arg1;
5035 }
5036 return resultobj;
5037 fail:
5038 {
5039 if (temp1)
5040 delete arg1;
5041 }
5042 return NULL;
5043 }
5044
5045
5046 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5047 PyObject *resultobj = 0;
5048 int *arg1 = (int *) 0 ;
5049 int *arg2 = (int *) 0 ;
5050 int result;
5051 int temp1 ;
5052 int res1 = SWIG_TMPOBJ ;
5053 int temp2 ;
5054 int res2 = SWIG_TMPOBJ ;
5055
5056 arg1 = &temp1;
5057 arg2 = &temp2;
5058 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5059 {
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 result = (int)wxGetOsVersion(arg1,arg2);
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 resultobj = SWIG_From_int(static_cast< int >(result));
5066 if (SWIG_IsTmpObj(res1)) {
5067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5068 } else {
5069 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5071 }
5072 if (SWIG_IsTmpObj(res2)) {
5073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5074 } else {
5075 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5077 }
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5085 PyObject *resultobj = 0;
5086 wxString result;
5087
5088 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5089 {
5090 PyThreadState* __tstate = wxPyBeginAllowThreads();
5091 result = wxGetOsDescription();
5092 wxPyEndAllowThreads(__tstate);
5093 if (PyErr_Occurred()) SWIG_fail;
5094 }
5095 {
5096 #if wxUSE_UNICODE
5097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5098 #else
5099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5100 #endif
5101 }
5102 return resultobj;
5103 fail:
5104 return NULL;
5105 }
5106
5107
5108 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5109 PyObject *resultobj = 0;
5110 bool result;
5111
5112 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5113 {
5114 PyThreadState* __tstate = wxPyBeginAllowThreads();
5115 result = (bool)wxIsPlatformLittleEndian();
5116 wxPyEndAllowThreads(__tstate);
5117 if (PyErr_Occurred()) SWIG_fail;
5118 }
5119 {
5120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5121 }
5122 return resultobj;
5123 fail:
5124 return NULL;
5125 }
5126
5127
5128 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5129 PyObject *resultobj = 0;
5130 bool result;
5131
5132 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (bool)wxIsPlatform64Bit();
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 {
5140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5141 }
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 wxMemorySize result;
5151
5152 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = wxGetFreeMemory();
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 {
5160 #if wxUSE_LONGLONG
5161 resultobj = PyLong_FromLongLong((&result)->GetValue());
5162 #else
5163 resultobj = PyInt_FromLong(result);
5164 #endif
5165 }
5166 return resultobj;
5167 fail:
5168 return NULL;
5169 }
5170
5171
5172 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5173 PyObject *resultobj = 0;
5174 wxShutdownFlags arg1 ;
5175 bool result;
5176 int val1 ;
5177 int ecode1 = 0 ;
5178 PyObject * obj0 = 0 ;
5179 char * kwnames[] = {
5180 (char *) "wFlags", NULL
5181 };
5182
5183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5184 ecode1 = SWIG_AsVal_int(obj0, &val1);
5185 if (!SWIG_IsOK(ecode1)) {
5186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5187 }
5188 arg1 = static_cast< wxShutdownFlags >(val1);
5189 {
5190 if (!wxPyCheckForApp()) SWIG_fail;
5191 PyThreadState* __tstate = wxPyBeginAllowThreads();
5192 result = (bool)wxShutdown(arg1);
5193 wxPyEndAllowThreads(__tstate);
5194 if (PyErr_Occurred()) SWIG_fail;
5195 }
5196 {
5197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5198 }
5199 return resultobj;
5200 fail:
5201 return NULL;
5202 }
5203
5204
5205 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5206 PyObject *resultobj = 0;
5207 int arg1 ;
5208 int val1 ;
5209 int ecode1 = 0 ;
5210 PyObject * obj0 = 0 ;
5211 char * kwnames[] = {
5212 (char *) "secs", NULL
5213 };
5214
5215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5216 ecode1 = SWIG_AsVal_int(obj0, &val1);
5217 if (!SWIG_IsOK(ecode1)) {
5218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5219 }
5220 arg1 = static_cast< int >(val1);
5221 {
5222 PyThreadState* __tstate = wxPyBeginAllowThreads();
5223 wxSleep(arg1);
5224 wxPyEndAllowThreads(__tstate);
5225 if (PyErr_Occurred()) SWIG_fail;
5226 }
5227 resultobj = SWIG_Py_Void();
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5235 PyObject *resultobj = 0;
5236 unsigned long arg1 ;
5237 unsigned long val1 ;
5238 int ecode1 = 0 ;
5239 PyObject * obj0 = 0 ;
5240 char * kwnames[] = {
5241 (char *) "milliseconds", NULL
5242 };
5243
5244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5245 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5246 if (!SWIG_IsOK(ecode1)) {
5247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5248 }
5249 arg1 = static_cast< unsigned long >(val1);
5250 {
5251 PyThreadState* __tstate = wxPyBeginAllowThreads();
5252 wxMilliSleep(arg1);
5253 wxPyEndAllowThreads(__tstate);
5254 if (PyErr_Occurred()) SWIG_fail;
5255 }
5256 resultobj = SWIG_Py_Void();
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 unsigned long arg1 ;
5266 unsigned long val1 ;
5267 int ecode1 = 0 ;
5268 PyObject * obj0 = 0 ;
5269 char * kwnames[] = {
5270 (char *) "microseconds", NULL
5271 };
5272
5273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5274 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5275 if (!SWIG_IsOK(ecode1)) {
5276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5277 }
5278 arg1 = static_cast< unsigned long >(val1);
5279 {
5280 PyThreadState* __tstate = wxPyBeginAllowThreads();
5281 wxMicroSleep(arg1);
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 resultobj = SWIG_Py_Void();
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj = 0;
5294 bool arg1 ;
5295 bool val1 ;
5296 int ecode1 = 0 ;
5297 PyObject * obj0 = 0 ;
5298 char * kwnames[] = {
5299 (char *) "enable", NULL
5300 };
5301
5302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5303 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5304 if (!SWIG_IsOK(ecode1)) {
5305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5306 }
5307 arg1 = static_cast< bool >(val1);
5308 {
5309 PyThreadState* __tstate = wxPyBeginAllowThreads();
5310 wxEnableTopLevelWindows(arg1);
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 resultobj = SWIG_Py_Void();
5315 return resultobj;
5316 fail:
5317 return NULL;
5318 }
5319
5320
5321 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5322 PyObject *resultobj = 0;
5323 wxString *arg1 = 0 ;
5324 wxString result;
5325 bool temp1 = false ;
5326 PyObject * obj0 = 0 ;
5327 char * kwnames[] = {
5328 (char *) "in", NULL
5329 };
5330
5331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5332 {
5333 arg1 = wxString_in_helper(obj0);
5334 if (arg1 == NULL) SWIG_fail;
5335 temp1 = true;
5336 }
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = wxStripMenuCodes((wxString const &)*arg1);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 #if wxUSE_UNICODE
5345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5346 #else
5347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5348 #endif
5349 }
5350 {
5351 if (temp1)
5352 delete arg1;
5353 }
5354 return resultobj;
5355 fail:
5356 {
5357 if (temp1)
5358 delete arg1;
5359 }
5360 return NULL;
5361 }
5362
5363
5364 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5365 PyObject *resultobj = 0;
5366 wxString result;
5367
5368 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5369 {
5370 PyThreadState* __tstate = wxPyBeginAllowThreads();
5371 result = wxGetEmailAddress();
5372 wxPyEndAllowThreads(__tstate);
5373 if (PyErr_Occurred()) SWIG_fail;
5374 }
5375 {
5376 #if wxUSE_UNICODE
5377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5378 #else
5379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5380 #endif
5381 }
5382 return resultobj;
5383 fail:
5384 return NULL;
5385 }
5386
5387
5388 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5389 PyObject *resultobj = 0;
5390 wxString result;
5391
5392 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5393 {
5394 PyThreadState* __tstate = wxPyBeginAllowThreads();
5395 result = wxGetHostName();
5396 wxPyEndAllowThreads(__tstate);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 {
5400 #if wxUSE_UNICODE
5401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5402 #else
5403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5404 #endif
5405 }
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *resultobj = 0;
5414 wxString result;
5415
5416 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5417 {
5418 PyThreadState* __tstate = wxPyBeginAllowThreads();
5419 result = wxGetFullHostName();
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 {
5424 #if wxUSE_UNICODE
5425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5426 #else
5427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5428 #endif
5429 }
5430 return resultobj;
5431 fail:
5432 return NULL;
5433 }
5434
5435
5436 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5437 PyObject *resultobj = 0;
5438 wxString result;
5439
5440 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5441 {
5442 PyThreadState* __tstate = wxPyBeginAllowThreads();
5443 result = wxGetUserId();
5444 wxPyEndAllowThreads(__tstate);
5445 if (PyErr_Occurred()) SWIG_fail;
5446 }
5447 {
5448 #if wxUSE_UNICODE
5449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5450 #else
5451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5452 #endif
5453 }
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461 PyObject *resultobj = 0;
5462 wxString result;
5463
5464 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = wxGetUserName();
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 {
5472 #if wxUSE_UNICODE
5473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5474 #else
5475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5476 #endif
5477 }
5478 return resultobj;
5479 fail:
5480 return NULL;
5481 }
5482
5483
5484 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5485 PyObject *resultobj = 0;
5486 wxString result;
5487
5488 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = wxGetHomeDir();
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 {
5496 #if wxUSE_UNICODE
5497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5498 #else
5499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5500 #endif
5501 }
5502 return resultobj;
5503 fail:
5504 return NULL;
5505 }
5506
5507
5508 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5509 PyObject *resultobj = 0;
5510 wxString const &arg1_defvalue = wxPyEmptyString ;
5511 wxString *arg1 = (wxString *) &arg1_defvalue ;
5512 wxString result;
5513 bool temp1 = false ;
5514 PyObject * obj0 = 0 ;
5515 char * kwnames[] = {
5516 (char *) "user", NULL
5517 };
5518
5519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5520 if (obj0) {
5521 {
5522 arg1 = wxString_in_helper(obj0);
5523 if (arg1 == NULL) SWIG_fail;
5524 temp1 = true;
5525 }
5526 }
5527 {
5528 PyThreadState* __tstate = wxPyBeginAllowThreads();
5529 result = wxGetUserHome((wxString const &)*arg1);
5530 wxPyEndAllowThreads(__tstate);
5531 if (PyErr_Occurred()) SWIG_fail;
5532 }
5533 {
5534 #if wxUSE_UNICODE
5535 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5536 #else
5537 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5538 #endif
5539 }
5540 {
5541 if (temp1)
5542 delete arg1;
5543 }
5544 return resultobj;
5545 fail:
5546 {
5547 if (temp1)
5548 delete arg1;
5549 }
5550 return NULL;
5551 }
5552
5553
5554 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5555 PyObject *resultobj = 0;
5556 unsigned long result;
5557
5558 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5559 {
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 result = (unsigned long)wxGetProcessId();
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5573 PyObject *resultobj = 0;
5574
5575 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5576 {
5577 PyThreadState* __tstate = wxPyBeginAllowThreads();
5578 wxTrap();
5579 wxPyEndAllowThreads(__tstate);
5580 if (PyErr_Occurred()) SWIG_fail;
5581 }
5582 resultobj = SWIG_Py_Void();
5583 return resultobj;
5584 fail:
5585 return NULL;
5586 }
5587
5588
5589 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5590 PyObject *resultobj = 0;
5591 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5592 wxString *arg1 = (wxString *) &arg1_defvalue ;
5593 wxString const &arg2_defvalue = wxPyEmptyString ;
5594 wxString *arg2 = (wxString *) &arg2_defvalue ;
5595 wxString const &arg3_defvalue = wxPyEmptyString ;
5596 wxString *arg3 = (wxString *) &arg3_defvalue ;
5597 wxString const &arg4_defvalue = wxPyEmptyString ;
5598 wxString *arg4 = (wxString *) &arg4_defvalue ;
5599 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5600 wxString *arg5 = (wxString *) &arg5_defvalue ;
5601 int arg6 = (int) 0 ;
5602 wxWindow *arg7 = (wxWindow *) NULL ;
5603 int arg8 = (int) -1 ;
5604 int arg9 = (int) -1 ;
5605 wxString result;
5606 bool temp1 = false ;
5607 bool temp2 = false ;
5608 bool temp3 = false ;
5609 bool temp4 = false ;
5610 bool temp5 = false ;
5611 int val6 ;
5612 int ecode6 = 0 ;
5613 void *argp7 = 0 ;
5614 int res7 = 0 ;
5615 int val8 ;
5616 int ecode8 = 0 ;
5617 int val9 ;
5618 int ecode9 = 0 ;
5619 PyObject * obj0 = 0 ;
5620 PyObject * obj1 = 0 ;
5621 PyObject * obj2 = 0 ;
5622 PyObject * obj3 = 0 ;
5623 PyObject * obj4 = 0 ;
5624 PyObject * obj5 = 0 ;
5625 PyObject * obj6 = 0 ;
5626 PyObject * obj7 = 0 ;
5627 PyObject * obj8 = 0 ;
5628 char * kwnames[] = {
5629 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5630 };
5631
5632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5633 if (obj0) {
5634 {
5635 arg1 = wxString_in_helper(obj0);
5636 if (arg1 == NULL) SWIG_fail;
5637 temp1 = true;
5638 }
5639 }
5640 if (obj1) {
5641 {
5642 arg2 = wxString_in_helper(obj1);
5643 if (arg2 == NULL) SWIG_fail;
5644 temp2 = true;
5645 }
5646 }
5647 if (obj2) {
5648 {
5649 arg3 = wxString_in_helper(obj2);
5650 if (arg3 == NULL) SWIG_fail;
5651 temp3 = true;
5652 }
5653 }
5654 if (obj3) {
5655 {
5656 arg4 = wxString_in_helper(obj3);
5657 if (arg4 == NULL) SWIG_fail;
5658 temp4 = true;
5659 }
5660 }
5661 if (obj4) {
5662 {
5663 arg5 = wxString_in_helper(obj4);
5664 if (arg5 == NULL) SWIG_fail;
5665 temp5 = true;
5666 }
5667 }
5668 if (obj5) {
5669 ecode6 = SWIG_AsVal_int(obj5, &val6);
5670 if (!SWIG_IsOK(ecode6)) {
5671 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5672 }
5673 arg6 = static_cast< int >(val6);
5674 }
5675 if (obj6) {
5676 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5677 if (!SWIG_IsOK(res7)) {
5678 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5679 }
5680 arg7 = reinterpret_cast< wxWindow * >(argp7);
5681 }
5682 if (obj7) {
5683 ecode8 = SWIG_AsVal_int(obj7, &val8);
5684 if (!SWIG_IsOK(ecode8)) {
5685 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5686 }
5687 arg8 = static_cast< int >(val8);
5688 }
5689 if (obj8) {
5690 ecode9 = SWIG_AsVal_int(obj8, &val9);
5691 if (!SWIG_IsOK(ecode9)) {
5692 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5693 }
5694 arg9 = static_cast< int >(val9);
5695 }
5696 {
5697 if (!wxPyCheckForApp()) SWIG_fail;
5698 PyThreadState* __tstate = wxPyBeginAllowThreads();
5699 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5700 wxPyEndAllowThreads(__tstate);
5701 if (PyErr_Occurred()) SWIG_fail;
5702 }
5703 {
5704 #if wxUSE_UNICODE
5705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5706 #else
5707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5708 #endif
5709 }
5710 {
5711 if (temp1)
5712 delete arg1;
5713 }
5714 {
5715 if (temp2)
5716 delete arg2;
5717 }
5718 {
5719 if (temp3)
5720 delete arg3;
5721 }
5722 {
5723 if (temp4)
5724 delete arg4;
5725 }
5726 {
5727 if (temp5)
5728 delete arg5;
5729 }
5730 return resultobj;
5731 fail:
5732 {
5733 if (temp1)
5734 delete arg1;
5735 }
5736 {
5737 if (temp2)
5738 delete arg2;
5739 }
5740 {
5741 if (temp3)
5742 delete arg3;
5743 }
5744 {
5745 if (temp4)
5746 delete arg4;
5747 }
5748 {
5749 if (temp5)
5750 delete arg5;
5751 }
5752 return NULL;
5753 }
5754
5755
5756 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5757 PyObject *resultobj = 0;
5758 wxString *arg1 = 0 ;
5759 wxString *arg2 = 0 ;
5760 wxString const &arg3_defvalue = wxPyEmptyString ;
5761 wxString *arg3 = (wxString *) &arg3_defvalue ;
5762 wxWindow *arg4 = (wxWindow *) NULL ;
5763 wxString result;
5764 bool temp1 = false ;
5765 bool temp2 = false ;
5766 bool temp3 = false ;
5767 void *argp4 = 0 ;
5768 int res4 = 0 ;
5769 PyObject * obj0 = 0 ;
5770 PyObject * obj1 = 0 ;
5771 PyObject * obj2 = 0 ;
5772 PyObject * obj3 = 0 ;
5773 char * kwnames[] = {
5774 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5775 };
5776
5777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5778 {
5779 arg1 = wxString_in_helper(obj0);
5780 if (arg1 == NULL) SWIG_fail;
5781 temp1 = true;
5782 }
5783 {
5784 arg2 = wxString_in_helper(obj1);
5785 if (arg2 == NULL) SWIG_fail;
5786 temp2 = true;
5787 }
5788 if (obj2) {
5789 {
5790 arg3 = wxString_in_helper(obj2);
5791 if (arg3 == NULL) SWIG_fail;
5792 temp3 = true;
5793 }
5794 }
5795 if (obj3) {
5796 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5797 if (!SWIG_IsOK(res4)) {
5798 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5799 }
5800 arg4 = reinterpret_cast< wxWindow * >(argp4);
5801 }
5802 {
5803 if (!wxPyCheckForApp()) SWIG_fail;
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 {
5810 #if wxUSE_UNICODE
5811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5812 #else
5813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5814 #endif
5815 }
5816 {
5817 if (temp1)
5818 delete arg1;
5819 }
5820 {
5821 if (temp2)
5822 delete arg2;
5823 }
5824 {
5825 if (temp3)
5826 delete arg3;
5827 }
5828 return resultobj;
5829 fail:
5830 {
5831 if (temp1)
5832 delete arg1;
5833 }
5834 {
5835 if (temp2)
5836 delete arg2;
5837 }
5838 {
5839 if (temp3)
5840 delete arg3;
5841 }
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 wxString *arg1 = 0 ;
5849 wxString *arg2 = 0 ;
5850 wxString const &arg3_defvalue = wxPyEmptyString ;
5851 wxString *arg3 = (wxString *) &arg3_defvalue ;
5852 wxWindow *arg4 = (wxWindow *) NULL ;
5853 wxString result;
5854 bool temp1 = false ;
5855 bool temp2 = false ;
5856 bool temp3 = false ;
5857 void *argp4 = 0 ;
5858 int res4 = 0 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 PyObject * obj2 = 0 ;
5862 PyObject * obj3 = 0 ;
5863 char * kwnames[] = {
5864 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5865 };
5866
5867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5868 {
5869 arg1 = wxString_in_helper(obj0);
5870 if (arg1 == NULL) SWIG_fail;
5871 temp1 = true;
5872 }
5873 {
5874 arg2 = wxString_in_helper(obj1);
5875 if (arg2 == NULL) SWIG_fail;
5876 temp2 = true;
5877 }
5878 if (obj2) {
5879 {
5880 arg3 = wxString_in_helper(obj2);
5881 if (arg3 == NULL) SWIG_fail;
5882 temp3 = true;
5883 }
5884 }
5885 if (obj3) {
5886 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5887 if (!SWIG_IsOK(res4)) {
5888 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5889 }
5890 arg4 = reinterpret_cast< wxWindow * >(argp4);
5891 }
5892 {
5893 if (!wxPyCheckForApp()) SWIG_fail;
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5896 wxPyEndAllowThreads(__tstate);
5897 if (PyErr_Occurred()) SWIG_fail;
5898 }
5899 {
5900 #if wxUSE_UNICODE
5901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5902 #else
5903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5904 #endif
5905 }
5906 {
5907 if (temp1)
5908 delete arg1;
5909 }
5910 {
5911 if (temp2)
5912 delete arg2;
5913 }
5914 {
5915 if (temp3)
5916 delete arg3;
5917 }
5918 return resultobj;
5919 fail:
5920 {
5921 if (temp1)
5922 delete arg1;
5923 }
5924 {
5925 if (temp2)
5926 delete arg2;
5927 }
5928 {
5929 if (temp3)
5930 delete arg3;
5931 }
5932 return NULL;
5933 }
5934
5935
5936 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5937 PyObject *resultobj = 0;
5938 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5939 wxString *arg1 = (wxString *) &arg1_defvalue ;
5940 wxString const &arg2_defvalue = wxPyEmptyString ;
5941 wxString *arg2 = (wxString *) &arg2_defvalue ;
5942 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5943 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5944 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5945 wxWindow *arg5 = (wxWindow *) NULL ;
5946 wxString result;
5947 bool temp1 = false ;
5948 bool temp2 = false ;
5949 long val3 ;
5950 int ecode3 = 0 ;
5951 wxPoint temp4 ;
5952 void *argp5 = 0 ;
5953 int res5 = 0 ;
5954 PyObject * obj0 = 0 ;
5955 PyObject * obj1 = 0 ;
5956 PyObject * obj2 = 0 ;
5957 PyObject * obj3 = 0 ;
5958 PyObject * obj4 = 0 ;
5959 char * kwnames[] = {
5960 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5961 };
5962
5963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5964 if (obj0) {
5965 {
5966 arg1 = wxString_in_helper(obj0);
5967 if (arg1 == NULL) SWIG_fail;
5968 temp1 = true;
5969 }
5970 }
5971 if (obj1) {
5972 {
5973 arg2 = wxString_in_helper(obj1);
5974 if (arg2 == NULL) SWIG_fail;
5975 temp2 = true;
5976 }
5977 }
5978 if (obj2) {
5979 ecode3 = SWIG_AsVal_long(obj2, &val3);
5980 if (!SWIG_IsOK(ecode3)) {
5981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5982 }
5983 arg3 = static_cast< long >(val3);
5984 }
5985 if (obj3) {
5986 {
5987 arg4 = &temp4;
5988 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5989 }
5990 }
5991 if (obj4) {
5992 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5993 if (!SWIG_IsOK(res5)) {
5994 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5995 }
5996 arg5 = reinterpret_cast< wxWindow * >(argp5);
5997 }
5998 {
5999 if (!wxPyCheckForApp()) SWIG_fail;
6000 PyThreadState* __tstate = wxPyBeginAllowThreads();
6001 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6002 wxPyEndAllowThreads(__tstate);
6003 if (PyErr_Occurred()) SWIG_fail;
6004 }
6005 {
6006 #if wxUSE_UNICODE
6007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6008 #else
6009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6010 #endif
6011 }
6012 {
6013 if (temp1)
6014 delete arg1;
6015 }
6016 {
6017 if (temp2)
6018 delete arg2;
6019 }
6020 return resultobj;
6021 fail:
6022 {
6023 if (temp1)
6024 delete arg1;
6025 }
6026 {
6027 if (temp2)
6028 delete arg2;
6029 }
6030 return NULL;
6031 }
6032
6033
6034 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6035 PyObject *resultobj = 0;
6036 wxString *arg1 = 0 ;
6037 wxString const &arg2_defvalue = wxPyEmptyString ;
6038 wxString *arg2 = (wxString *) &arg2_defvalue ;
6039 wxString const &arg3_defvalue = wxPyEmptyString ;
6040 wxString *arg3 = (wxString *) &arg3_defvalue ;
6041 wxWindow *arg4 = (wxWindow *) NULL ;
6042 int arg5 = (int) -1 ;
6043 int arg6 = (int) -1 ;
6044 bool arg7 = (bool) true ;
6045 wxString result;
6046 bool temp1 = false ;
6047 bool temp2 = false ;
6048 bool temp3 = false ;
6049 void *argp4 = 0 ;
6050 int res4 = 0 ;
6051 int val5 ;
6052 int ecode5 = 0 ;
6053 int val6 ;
6054 int ecode6 = 0 ;
6055 bool val7 ;
6056 int ecode7 = 0 ;
6057 PyObject * obj0 = 0 ;
6058 PyObject * obj1 = 0 ;
6059 PyObject * obj2 = 0 ;
6060 PyObject * obj3 = 0 ;
6061 PyObject * obj4 = 0 ;
6062 PyObject * obj5 = 0 ;
6063 PyObject * obj6 = 0 ;
6064 char * kwnames[] = {
6065 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6066 };
6067
6068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6069 {
6070 arg1 = wxString_in_helper(obj0);
6071 if (arg1 == NULL) SWIG_fail;
6072 temp1 = true;
6073 }
6074 if (obj1) {
6075 {
6076 arg2 = wxString_in_helper(obj1);
6077 if (arg2 == NULL) SWIG_fail;
6078 temp2 = true;
6079 }
6080 }
6081 if (obj2) {
6082 {
6083 arg3 = wxString_in_helper(obj2);
6084 if (arg3 == NULL) SWIG_fail;
6085 temp3 = true;
6086 }
6087 }
6088 if (obj3) {
6089 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6090 if (!SWIG_IsOK(res4)) {
6091 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6092 }
6093 arg4 = reinterpret_cast< wxWindow * >(argp4);
6094 }
6095 if (obj4) {
6096 ecode5 = SWIG_AsVal_int(obj4, &val5);
6097 if (!SWIG_IsOK(ecode5)) {
6098 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6099 }
6100 arg5 = static_cast< int >(val5);
6101 }
6102 if (obj5) {
6103 ecode6 = SWIG_AsVal_int(obj5, &val6);
6104 if (!SWIG_IsOK(ecode6)) {
6105 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6106 }
6107 arg6 = static_cast< int >(val6);
6108 }
6109 if (obj6) {
6110 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6111 if (!SWIG_IsOK(ecode7)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6113 }
6114 arg7 = static_cast< bool >(val7);
6115 }
6116 {
6117 if (!wxPyCheckForApp()) SWIG_fail;
6118 PyThreadState* __tstate = wxPyBeginAllowThreads();
6119 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6120 wxPyEndAllowThreads(__tstate);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 {
6124 #if wxUSE_UNICODE
6125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6126 #else
6127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6128 #endif
6129 }
6130 {
6131 if (temp1)
6132 delete arg1;
6133 }
6134 {
6135 if (temp2)
6136 delete arg2;
6137 }
6138 {
6139 if (temp3)
6140 delete arg3;
6141 }
6142 return resultobj;
6143 fail:
6144 {
6145 if (temp1)
6146 delete arg1;
6147 }
6148 {
6149 if (temp2)
6150 delete arg2;
6151 }
6152 {
6153 if (temp3)
6154 delete arg3;
6155 }
6156 return NULL;
6157 }
6158
6159
6160 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj = 0;
6162 wxString *arg1 = 0 ;
6163 wxString const &arg2_defvalue = wxPyEmptyString ;
6164 wxString *arg2 = (wxString *) &arg2_defvalue ;
6165 wxString const &arg3_defvalue = wxPyEmptyString ;
6166 wxString *arg3 = (wxString *) &arg3_defvalue ;
6167 wxWindow *arg4 = (wxWindow *) NULL ;
6168 wxString result;
6169 bool temp1 = false ;
6170 bool temp2 = false ;
6171 bool temp3 = false ;
6172 void *argp4 = 0 ;
6173 int res4 = 0 ;
6174 PyObject * obj0 = 0 ;
6175 PyObject * obj1 = 0 ;
6176 PyObject * obj2 = 0 ;
6177 PyObject * obj3 = 0 ;
6178 char * kwnames[] = {
6179 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6180 };
6181
6182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6183 {
6184 arg1 = wxString_in_helper(obj0);
6185 if (arg1 == NULL) SWIG_fail;
6186 temp1 = true;
6187 }
6188 if (obj1) {
6189 {
6190 arg2 = wxString_in_helper(obj1);
6191 if (arg2 == NULL) SWIG_fail;
6192 temp2 = true;
6193 }
6194 }
6195 if (obj2) {
6196 {
6197 arg3 = wxString_in_helper(obj2);
6198 if (arg3 == NULL) SWIG_fail;
6199 temp3 = true;
6200 }
6201 }
6202 if (obj3) {
6203 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6204 if (!SWIG_IsOK(res4)) {
6205 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6206 }
6207 arg4 = reinterpret_cast< wxWindow * >(argp4);
6208 }
6209 {
6210 if (!wxPyCheckForApp()) SWIG_fail;
6211 PyThreadState* __tstate = wxPyBeginAllowThreads();
6212 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6213 wxPyEndAllowThreads(__tstate);
6214 if (PyErr_Occurred()) SWIG_fail;
6215 }
6216 {
6217 #if wxUSE_UNICODE
6218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6219 #else
6220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6221 #endif
6222 }
6223 {
6224 if (temp1)
6225 delete arg1;
6226 }
6227 {
6228 if (temp2)
6229 delete arg2;
6230 }
6231 {
6232 if (temp3)
6233 delete arg3;
6234 }
6235 return resultobj;
6236 fail:
6237 {
6238 if (temp1)
6239 delete arg1;
6240 }
6241 {
6242 if (temp2)
6243 delete arg2;
6244 }
6245 {
6246 if (temp3)
6247 delete arg3;
6248 }
6249 return NULL;
6250 }
6251
6252
6253 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj = 0;
6255 wxString *arg1 = 0 ;
6256 wxString *arg2 = 0 ;
6257 int arg3 ;
6258 wxString *arg4 = (wxString *) 0 ;
6259 wxWindow *arg5 = (wxWindow *) NULL ;
6260 int arg6 = (int) -1 ;
6261 int arg7 = (int) -1 ;
6262 bool arg8 = (bool) true ;
6263 int arg9 = (int) 150 ;
6264 int arg10 = (int) 200 ;
6265 wxString result;
6266 bool temp1 = false ;
6267 bool temp2 = false ;
6268 void *argp5 = 0 ;
6269 int res5 = 0 ;
6270 int val6 ;
6271 int ecode6 = 0 ;
6272 int val7 ;
6273 int ecode7 = 0 ;
6274 bool val8 ;
6275 int ecode8 = 0 ;
6276 int val9 ;
6277 int ecode9 = 0 ;
6278 int val10 ;
6279 int ecode10 = 0 ;
6280 PyObject * obj0 = 0 ;
6281 PyObject * obj1 = 0 ;
6282 PyObject * obj2 = 0 ;
6283 PyObject * obj3 = 0 ;
6284 PyObject * obj4 = 0 ;
6285 PyObject * obj5 = 0 ;
6286 PyObject * obj6 = 0 ;
6287 PyObject * obj7 = 0 ;
6288 PyObject * obj8 = 0 ;
6289 char * kwnames[] = {
6290 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6291 };
6292
6293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6294 {
6295 arg1 = wxString_in_helper(obj0);
6296 if (arg1 == NULL) SWIG_fail;
6297 temp1 = true;
6298 }
6299 {
6300 arg2 = wxString_in_helper(obj1);
6301 if (arg2 == NULL) SWIG_fail;
6302 temp2 = true;
6303 }
6304 {
6305 arg3 = PyList_Size(obj2);
6306 arg4 = wxString_LIST_helper(obj2);
6307 if (arg4 == NULL) SWIG_fail;
6308 }
6309 if (obj3) {
6310 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6311 if (!SWIG_IsOK(res5)) {
6312 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6313 }
6314 arg5 = reinterpret_cast< wxWindow * >(argp5);
6315 }
6316 if (obj4) {
6317 ecode6 = SWIG_AsVal_int(obj4, &val6);
6318 if (!SWIG_IsOK(ecode6)) {
6319 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6320 }
6321 arg6 = static_cast< int >(val6);
6322 }
6323 if (obj5) {
6324 ecode7 = SWIG_AsVal_int(obj5, &val7);
6325 if (!SWIG_IsOK(ecode7)) {
6326 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6327 }
6328 arg7 = static_cast< int >(val7);
6329 }
6330 if (obj6) {
6331 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6332 if (!SWIG_IsOK(ecode8)) {
6333 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6334 }
6335 arg8 = static_cast< bool >(val8);
6336 }
6337 if (obj7) {
6338 ecode9 = SWIG_AsVal_int(obj7, &val9);
6339 if (!SWIG_IsOK(ecode9)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6341 }
6342 arg9 = static_cast< int >(val9);
6343 }
6344 if (obj8) {
6345 ecode10 = SWIG_AsVal_int(obj8, &val10);
6346 if (!SWIG_IsOK(ecode10)) {
6347 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6348 }
6349 arg10 = static_cast< int >(val10);
6350 }
6351 {
6352 if (!wxPyCheckForApp()) SWIG_fail;
6353 PyThreadState* __tstate = wxPyBeginAllowThreads();
6354 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6355 wxPyEndAllowThreads(__tstate);
6356 if (PyErr_Occurred()) SWIG_fail;
6357 }
6358 {
6359 #if wxUSE_UNICODE
6360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6361 #else
6362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6363 #endif
6364 }
6365 {
6366 if (temp1)
6367 delete arg1;
6368 }
6369 {
6370 if (temp2)
6371 delete arg2;
6372 }
6373 {
6374 if (arg4) delete [] arg4;
6375 }
6376 return resultobj;
6377 fail:
6378 {
6379 if (temp1)
6380 delete arg1;
6381 }
6382 {
6383 if (temp2)
6384 delete arg2;
6385 }
6386 {
6387 if (arg4) delete [] arg4;
6388 }
6389 return NULL;
6390 }
6391
6392
6393 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6394 PyObject *resultobj = 0;
6395 wxString *arg1 = 0 ;
6396 wxString *arg2 = 0 ;
6397 int arg3 ;
6398 wxString *arg4 = (wxString *) 0 ;
6399 wxWindow *arg5 = (wxWindow *) NULL ;
6400 int arg6 = (int) -1 ;
6401 int arg7 = (int) -1 ;
6402 bool arg8 = (bool) true ;
6403 int arg9 = (int) 150 ;
6404 int arg10 = (int) 200 ;
6405 int result;
6406 bool temp1 = false ;
6407 bool temp2 = false ;
6408 void *argp5 = 0 ;
6409 int res5 = 0 ;
6410 int val6 ;
6411 int ecode6 = 0 ;
6412 int val7 ;
6413 int ecode7 = 0 ;
6414 bool val8 ;
6415 int ecode8 = 0 ;
6416 int val9 ;
6417 int ecode9 = 0 ;
6418 int val10 ;
6419 int ecode10 = 0 ;
6420 PyObject * obj0 = 0 ;
6421 PyObject * obj1 = 0 ;
6422 PyObject * obj2 = 0 ;
6423 PyObject * obj3 = 0 ;
6424 PyObject * obj4 = 0 ;
6425 PyObject * obj5 = 0 ;
6426 PyObject * obj6 = 0 ;
6427 PyObject * obj7 = 0 ;
6428 PyObject * obj8 = 0 ;
6429 char * kwnames[] = {
6430 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6431 };
6432
6433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6434 {
6435 arg1 = wxString_in_helper(obj0);
6436 if (arg1 == NULL) SWIG_fail;
6437 temp1 = true;
6438 }
6439 {
6440 arg2 = wxString_in_helper(obj1);
6441 if (arg2 == NULL) SWIG_fail;
6442 temp2 = true;
6443 }
6444 {
6445 arg3 = PyList_Size(obj2);
6446 arg4 = wxString_LIST_helper(obj2);
6447 if (arg4 == NULL) SWIG_fail;
6448 }
6449 if (obj3) {
6450 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6451 if (!SWIG_IsOK(res5)) {
6452 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6453 }
6454 arg5 = reinterpret_cast< wxWindow * >(argp5);
6455 }
6456 if (obj4) {
6457 ecode6 = SWIG_AsVal_int(obj4, &val6);
6458 if (!SWIG_IsOK(ecode6)) {
6459 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6460 }
6461 arg6 = static_cast< int >(val6);
6462 }
6463 if (obj5) {
6464 ecode7 = SWIG_AsVal_int(obj5, &val7);
6465 if (!SWIG_IsOK(ecode7)) {
6466 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6467 }
6468 arg7 = static_cast< int >(val7);
6469 }
6470 if (obj6) {
6471 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6472 if (!SWIG_IsOK(ecode8)) {
6473 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6474 }
6475 arg8 = static_cast< bool >(val8);
6476 }
6477 if (obj7) {
6478 ecode9 = SWIG_AsVal_int(obj7, &val9);
6479 if (!SWIG_IsOK(ecode9)) {
6480 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6481 }
6482 arg9 = static_cast< int >(val9);
6483 }
6484 if (obj8) {
6485 ecode10 = SWIG_AsVal_int(obj8, &val10);
6486 if (!SWIG_IsOK(ecode10)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6488 }
6489 arg10 = static_cast< int >(val10);
6490 }
6491 {
6492 if (!wxPyCheckForApp()) SWIG_fail;
6493 PyThreadState* __tstate = wxPyBeginAllowThreads();
6494 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6495 wxPyEndAllowThreads(__tstate);
6496 if (PyErr_Occurred()) SWIG_fail;
6497 }
6498 resultobj = SWIG_From_int(static_cast< int >(result));
6499 {
6500 if (temp1)
6501 delete arg1;
6502 }
6503 {
6504 if (temp2)
6505 delete arg2;
6506 }
6507 {
6508 if (arg4) delete [] arg4;
6509 }
6510 return resultobj;
6511 fail:
6512 {
6513 if (temp1)
6514 delete arg1;
6515 }
6516 {
6517 if (temp2)
6518 delete arg2;
6519 }
6520 {
6521 if (arg4) delete [] arg4;
6522 }
6523 return NULL;
6524 }
6525
6526
6527 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6528 PyObject *resultobj = 0;
6529 wxString *arg1 = 0 ;
6530 wxString const &arg2_defvalue = wxPyEmptyString ;
6531 wxString *arg2 = (wxString *) &arg2_defvalue ;
6532 int arg3 = (int) wxOK|wxCENTRE ;
6533 wxWindow *arg4 = (wxWindow *) NULL ;
6534 int arg5 = (int) -1 ;
6535 int arg6 = (int) -1 ;
6536 int result;
6537 bool temp1 = false ;
6538 bool temp2 = false ;
6539 int val3 ;
6540 int ecode3 = 0 ;
6541 void *argp4 = 0 ;
6542 int res4 = 0 ;
6543 int val5 ;
6544 int ecode5 = 0 ;
6545 int val6 ;
6546 int ecode6 = 0 ;
6547 PyObject * obj0 = 0 ;
6548 PyObject * obj1 = 0 ;
6549 PyObject * obj2 = 0 ;
6550 PyObject * obj3 = 0 ;
6551 PyObject * obj4 = 0 ;
6552 PyObject * obj5 = 0 ;
6553 char * kwnames[] = {
6554 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6555 };
6556
6557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6558 {
6559 arg1 = wxString_in_helper(obj0);
6560 if (arg1 == NULL) SWIG_fail;
6561 temp1 = true;
6562 }
6563 if (obj1) {
6564 {
6565 arg2 = wxString_in_helper(obj1);
6566 if (arg2 == NULL) SWIG_fail;
6567 temp2 = true;
6568 }
6569 }
6570 if (obj2) {
6571 ecode3 = SWIG_AsVal_int(obj2, &val3);
6572 if (!SWIG_IsOK(ecode3)) {
6573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6574 }
6575 arg3 = static_cast< int >(val3);
6576 }
6577 if (obj3) {
6578 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6579 if (!SWIG_IsOK(res4)) {
6580 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6581 }
6582 arg4 = reinterpret_cast< wxWindow * >(argp4);
6583 }
6584 if (obj4) {
6585 ecode5 = SWIG_AsVal_int(obj4, &val5);
6586 if (!SWIG_IsOK(ecode5)) {
6587 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6588 }
6589 arg5 = static_cast< int >(val5);
6590 }
6591 if (obj5) {
6592 ecode6 = SWIG_AsVal_int(obj5, &val6);
6593 if (!SWIG_IsOK(ecode6)) {
6594 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6595 }
6596 arg6 = static_cast< int >(val6);
6597 }
6598 {
6599 if (!wxPyCheckForApp()) SWIG_fail;
6600 PyThreadState* __tstate = wxPyBeginAllowThreads();
6601 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6602 wxPyEndAllowThreads(__tstate);
6603 if (PyErr_Occurred()) SWIG_fail;
6604 }
6605 resultobj = SWIG_From_int(static_cast< int >(result));
6606 {
6607 if (temp1)
6608 delete arg1;
6609 }
6610 {
6611 if (temp2)
6612 delete arg2;
6613 }
6614 return resultobj;
6615 fail:
6616 {
6617 if (temp1)
6618 delete arg1;
6619 }
6620 {
6621 if (temp2)
6622 delete arg2;
6623 }
6624 return NULL;
6625 }
6626
6627
6628 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6629 PyObject *resultobj = 0;
6630 wxString *arg1 = 0 ;
6631 wxString *arg2 = 0 ;
6632 wxString *arg3 = 0 ;
6633 long arg4 ;
6634 long arg5 = (long) 0 ;
6635 long arg6 = (long) 100 ;
6636 wxWindow *arg7 = (wxWindow *) NULL ;
6637 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6638 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6639 long result;
6640 bool temp1 = false ;
6641 bool temp2 = false ;
6642 bool temp3 = false ;
6643 long val4 ;
6644 int ecode4 = 0 ;
6645 long val5 ;
6646 int ecode5 = 0 ;
6647 long val6 ;
6648 int ecode6 = 0 ;
6649 void *argp7 = 0 ;
6650 int res7 = 0 ;
6651 wxPoint temp8 ;
6652 PyObject * obj0 = 0 ;
6653 PyObject * obj1 = 0 ;
6654 PyObject * obj2 = 0 ;
6655 PyObject * obj3 = 0 ;
6656 PyObject * obj4 = 0 ;
6657 PyObject * obj5 = 0 ;
6658 PyObject * obj6 = 0 ;
6659 PyObject * obj7 = 0 ;
6660 char * kwnames[] = {
6661 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6662 };
6663
6664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6665 {
6666 arg1 = wxString_in_helper(obj0);
6667 if (arg1 == NULL) SWIG_fail;
6668 temp1 = true;
6669 }
6670 {
6671 arg2 = wxString_in_helper(obj1);
6672 if (arg2 == NULL) SWIG_fail;
6673 temp2 = true;
6674 }
6675 {
6676 arg3 = wxString_in_helper(obj2);
6677 if (arg3 == NULL) SWIG_fail;
6678 temp3 = true;
6679 }
6680 ecode4 = SWIG_AsVal_long(obj3, &val4);
6681 if (!SWIG_IsOK(ecode4)) {
6682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6683 }
6684 arg4 = static_cast< long >(val4);
6685 if (obj4) {
6686 ecode5 = SWIG_AsVal_long(obj4, &val5);
6687 if (!SWIG_IsOK(ecode5)) {
6688 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6689 }
6690 arg5 = static_cast< long >(val5);
6691 }
6692 if (obj5) {
6693 ecode6 = SWIG_AsVal_long(obj5, &val6);
6694 if (!SWIG_IsOK(ecode6)) {
6695 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6696 }
6697 arg6 = static_cast< long >(val6);
6698 }
6699 if (obj6) {
6700 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6701 if (!SWIG_IsOK(res7)) {
6702 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6703 }
6704 arg7 = reinterpret_cast< wxWindow * >(argp7);
6705 }
6706 if (obj7) {
6707 {
6708 arg8 = &temp8;
6709 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6710 }
6711 }
6712 {
6713 if (!wxPyCheckForApp()) SWIG_fail;
6714 PyThreadState* __tstate = wxPyBeginAllowThreads();
6715 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 resultobj = SWIG_From_long(static_cast< long >(result));
6720 {
6721 if (temp1)
6722 delete arg1;
6723 }
6724 {
6725 if (temp2)
6726 delete arg2;
6727 }
6728 {
6729 if (temp3)
6730 delete arg3;
6731 }
6732 return resultobj;
6733 fail:
6734 {
6735 if (temp1)
6736 delete arg1;
6737 }
6738 {
6739 if (temp2)
6740 delete arg2;
6741 }
6742 {
6743 if (temp3)
6744 delete arg3;
6745 }
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 bool result;
6753
6754 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6755 {
6756 if (!wxPyCheckForApp()) SWIG_fail;
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 result = (bool)wxColourDisplay();
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 {
6763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6764 }
6765 return resultobj;
6766 fail:
6767 return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6772 PyObject *resultobj = 0;
6773 int result;
6774
6775 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6776 {
6777 if (!wxPyCheckForApp()) SWIG_fail;
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = (int)wxDisplayDepth();
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 resultobj = SWIG_From_int(static_cast< int >(result));
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6791 PyObject *resultobj = 0;
6792 int result;
6793
6794 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6795 {
6796 if (!wxPyCheckForApp()) SWIG_fail;
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 result = (int)wxGetDisplayDepth();
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_From_int(static_cast< int >(result));
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6810 PyObject *resultobj = 0;
6811 int *arg1 = (int *) 0 ;
6812 int *arg2 = (int *) 0 ;
6813 int temp1 ;
6814 int res1 = SWIG_TMPOBJ ;
6815 int temp2 ;
6816 int res2 = SWIG_TMPOBJ ;
6817
6818 arg1 = &temp1;
6819 arg2 = &temp2;
6820 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6821 {
6822 if (!wxPyCheckForApp()) SWIG_fail;
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 wxDisplaySize(arg1,arg2);
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 resultobj = SWIG_Py_Void();
6829 if (SWIG_IsTmpObj(res1)) {
6830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6831 } else {
6832 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6834 }
6835 if (SWIG_IsTmpObj(res2)) {
6836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6837 } else {
6838 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6840 }
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6848 PyObject *resultobj = 0;
6849 wxSize result;
6850
6851 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6852 {
6853 if (!wxPyCheckForApp()) SWIG_fail;
6854 PyThreadState* __tstate = wxPyBeginAllowThreads();
6855 result = wxGetDisplaySize();
6856 wxPyEndAllowThreads(__tstate);
6857 if (PyErr_Occurred()) SWIG_fail;
6858 }
6859 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6860 return resultobj;
6861 fail:
6862 return NULL;
6863 }
6864
6865
6866 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6867 PyObject *resultobj = 0;
6868 int *arg1 = (int *) 0 ;
6869 int *arg2 = (int *) 0 ;
6870 int temp1 ;
6871 int res1 = SWIG_TMPOBJ ;
6872 int temp2 ;
6873 int res2 = SWIG_TMPOBJ ;
6874
6875 arg1 = &temp1;
6876 arg2 = &temp2;
6877 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6878 {
6879 if (!wxPyCheckForApp()) SWIG_fail;
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 wxDisplaySizeMM(arg1,arg2);
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 resultobj = SWIG_Py_Void();
6886 if (SWIG_IsTmpObj(res1)) {
6887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6888 } else {
6889 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6891 }
6892 if (SWIG_IsTmpObj(res2)) {
6893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6894 } else {
6895 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6897 }
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6905 PyObject *resultobj = 0;
6906 wxSize result;
6907
6908 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6909 {
6910 if (!wxPyCheckForApp()) SWIG_fail;
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 result = wxGetDisplaySizeMM();
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6924 PyObject *resultobj = 0;
6925 int *arg1 = (int *) 0 ;
6926 int *arg2 = (int *) 0 ;
6927 int *arg3 = (int *) 0 ;
6928 int *arg4 = (int *) 0 ;
6929 int temp1 ;
6930 int res1 = SWIG_TMPOBJ ;
6931 int temp2 ;
6932 int res2 = SWIG_TMPOBJ ;
6933 int temp3 ;
6934 int res3 = SWIG_TMPOBJ ;
6935 int temp4 ;
6936 int res4 = SWIG_TMPOBJ ;
6937
6938 arg1 = &temp1;
6939 arg2 = &temp2;
6940 arg3 = &temp3;
6941 arg4 = &temp4;
6942 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6943 {
6944 if (!wxPyCheckForApp()) SWIG_fail;
6945 PyThreadState* __tstate = wxPyBeginAllowThreads();
6946 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_Py_Void();
6951 if (SWIG_IsTmpObj(res1)) {
6952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6953 } else {
6954 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6956 }
6957 if (SWIG_IsTmpObj(res2)) {
6958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6959 } else {
6960 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6962 }
6963 if (SWIG_IsTmpObj(res3)) {
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6965 } else {
6966 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6968 }
6969 if (SWIG_IsTmpObj(res4)) {
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6971 } else {
6972 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6974 }
6975 return resultobj;
6976 fail:
6977 return NULL;
6978 }
6979
6980
6981 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6982 PyObject *resultobj = 0;
6983 wxRect result;
6984
6985 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6986 {
6987 if (!wxPyCheckForApp()) SWIG_fail;
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 result = wxGetClientDisplayRect();
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = 0;
7002 wxCursor *arg1 = 0 ;
7003 void *argp1 = 0 ;
7004 int res1 = 0 ;
7005 PyObject * obj0 = 0 ;
7006 char * kwnames[] = {
7007 (char *) "cursor", NULL
7008 };
7009
7010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7011 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7012 if (!SWIG_IsOK(res1)) {
7013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7014 }
7015 if (!argp1) {
7016 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7017 }
7018 arg1 = reinterpret_cast< wxCursor * >(argp1);
7019 {
7020 if (!wxPyCheckForApp()) SWIG_fail;
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 wxSetCursor(*arg1);
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 resultobj = SWIG_Py_Void();
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7034 PyObject *resultobj = 0;
7035 void *result = 0 ;
7036
7037 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7038 {
7039 if (!wxPyCheckForApp()) SWIG_fail;
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 result = (void *)wxGetXDisplay();
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7046 return resultobj;
7047 fail:
7048 return NULL;
7049 }
7050
7051
7052 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7053 PyObject *resultobj = 0;
7054 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7055 void *argp1 = 0 ;
7056 int res1 = 0 ;
7057 PyObject * obj0 = 0 ;
7058 char * kwnames[] = {
7059 (char *) "cursor", NULL
7060 };
7061
7062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7063 if (obj0) {
7064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7065 if (!SWIG_IsOK(res1)) {
7066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7067 }
7068 arg1 = reinterpret_cast< wxCursor * >(argp1);
7069 }
7070 {
7071 if (!wxPyCheckForApp()) SWIG_fail;
7072 PyThreadState* __tstate = wxPyBeginAllowThreads();
7073 wxBeginBusyCursor(arg1);
7074 wxPyEndAllowThreads(__tstate);
7075 if (PyErr_Occurred()) SWIG_fail;
7076 }
7077 resultobj = SWIG_Py_Void();
7078 return resultobj;
7079 fail:
7080 return NULL;
7081 }
7082
7083
7084 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7085 PyObject *resultobj = 0;
7086 wxPoint result;
7087
7088 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7089 {
7090 if (!wxPyCheckForApp()) SWIG_fail;
7091 PyThreadState* __tstate = wxPyBeginAllowThreads();
7092 result = wxGetMousePosition();
7093 wxPyEndAllowThreads(__tstate);
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7097 return resultobj;
7098 fail:
7099 return NULL;
7100 }
7101
7102
7103 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7104 PyObject *resultobj = 0;
7105 wxWindow *result = 0 ;
7106
7107 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7108 {
7109 if (!wxPyCheckForApp()) SWIG_fail;
7110 PyThreadState* __tstate = wxPyBeginAllowThreads();
7111 result = (wxWindow *)FindWindowAtPointer();
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 {
7116 resultobj = wxPyMake_wxObject(result, 0);
7117 }
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7125 PyObject *resultobj = 0;
7126 wxWindow *result = 0 ;
7127
7128 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7129 {
7130 if (!wxPyCheckForApp()) SWIG_fail;
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (wxWindow *)wxGetActiveWindow();
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_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7146 PyObject *resultobj = 0;
7147 wxPoint *arg1 = 0 ;
7148 wxWindow *result = 0 ;
7149 wxPoint temp1 ;
7150 PyObject * obj0 = 0 ;
7151 char * kwnames[] = {
7152 (char *) "pt", NULL
7153 };
7154
7155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7156 {
7157 arg1 = &temp1;
7158 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7159 }
7160 {
7161 if (!wxPyCheckForApp()) SWIG_fail;
7162 PyThreadState* __tstate = wxPyBeginAllowThreads();
7163 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7164 wxPyEndAllowThreads(__tstate);
7165 if (PyErr_Occurred()) SWIG_fail;
7166 }
7167 {
7168 resultobj = wxPyMake_wxObject(result, 0);
7169 }
7170 return resultobj;
7171 fail:
7172 return NULL;
7173 }
7174
7175
7176 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7177 PyObject *resultobj = 0;
7178 wxPoint *arg1 = 0 ;
7179 wxWindow *result = 0 ;
7180 wxPoint temp1 ;
7181 PyObject * obj0 = 0 ;
7182 char * kwnames[] = {
7183 (char *) "pt", NULL
7184 };
7185
7186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7187 {
7188 arg1 = &temp1;
7189 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7190 }
7191 {
7192 if (!wxPyCheckForApp()) SWIG_fail;
7193 PyThreadState* __tstate = wxPyBeginAllowThreads();
7194 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7195 wxPyEndAllowThreads(__tstate);
7196 if (PyErr_Occurred()) SWIG_fail;
7197 }
7198 {
7199 resultobj = wxPyMake_wxObject(result, 0);
7200 }
7201 return resultobj;
7202 fail:
7203 return NULL;
7204 }
7205
7206
7207 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7208 PyObject *resultobj = 0;
7209 wxWindow *arg1 = (wxWindow *) 0 ;
7210 wxWindow *result = 0 ;
7211 void *argp1 = 0 ;
7212 int res1 = 0 ;
7213 PyObject * obj0 = 0 ;
7214 char * kwnames[] = {
7215 (char *) "win", NULL
7216 };
7217
7218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7220 if (!SWIG_IsOK(res1)) {
7221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7222 }
7223 arg1 = reinterpret_cast< wxWindow * >(argp1);
7224 {
7225 if (!wxPyCheckForApp()) SWIG_fail;
7226 PyThreadState* __tstate = wxPyBeginAllowThreads();
7227 result = (wxWindow *)wxGetTopLevelParent(arg1);
7228 wxPyEndAllowThreads(__tstate);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 {
7232 resultobj = wxPyMake_wxObject(result, 0);
7233 }
7234 return resultobj;
7235 fail:
7236 return NULL;
7237 }
7238
7239
7240 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj = 0;
7242 wxString *arg1 = 0 ;
7243 bool result;
7244 bool temp1 = false ;
7245 PyObject * obj0 = 0 ;
7246 char * kwnames[] = {
7247 (char *) "url", NULL
7248 };
7249
7250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7251 {
7252 arg1 = wxString_in_helper(obj0);
7253 if (arg1 == NULL) SWIG_fail;
7254 temp1 = true;
7255 }
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 {
7263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7264 }
7265 {
7266 if (temp1)
7267 delete arg1;
7268 }
7269 return resultobj;
7270 fail:
7271 {
7272 if (temp1)
7273 delete arg1;
7274 }
7275 return NULL;
7276 }
7277
7278
7279 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj = 0;
7281 wxKeyCode arg1 ;
7282 bool result;
7283 int val1 ;
7284 int ecode1 = 0 ;
7285 PyObject * obj0 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "key", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7291 ecode1 = SWIG_AsVal_int(obj0, &val1);
7292 if (!SWIG_IsOK(ecode1)) {
7293 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7294 }
7295 arg1 = static_cast< wxKeyCode >(val1);
7296 {
7297 if (!wxPyCheckForApp()) SWIG_fail;
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 result = (bool)wxGetKeyState(arg1);
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 {
7304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7305 }
7306 return resultobj;
7307 fail:
7308 return NULL;
7309 }
7310
7311
7312 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7313 PyObject *resultobj = 0;
7314 wxMouseState *result = 0 ;
7315
7316 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (wxMouseState *)new wxMouseState();
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7331 PyObject *resultobj = 0;
7332 wxMouseState *arg1 = (wxMouseState *) 0 ;
7333 void *argp1 = 0 ;
7334 int res1 = 0 ;
7335 PyObject *swig_obj[1] ;
7336
7337 if (!args) SWIG_fail;
7338 swig_obj[0] = args;
7339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7340 if (!SWIG_IsOK(res1)) {
7341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7342 }
7343 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 delete arg1;
7347
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 resultobj = SWIG_Py_Void();
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7359 PyObject *resultobj = 0;
7360 wxMouseState *arg1 = (wxMouseState *) 0 ;
7361 int result;
7362 void *argp1 = 0 ;
7363 int res1 = 0 ;
7364 PyObject *swig_obj[1] ;
7365
7366 if (!args) SWIG_fail;
7367 swig_obj[0] = args;
7368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7369 if (!SWIG_IsOK(res1)) {
7370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7371 }
7372 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 result = (int)(arg1)->GetX();
7376 wxPyEndAllowThreads(__tstate);
7377 if (PyErr_Occurred()) SWIG_fail;
7378 }
7379 resultobj = SWIG_From_int(static_cast< int >(result));
7380 return resultobj;
7381 fail:
7382 return NULL;
7383 }
7384
7385
7386 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7387 PyObject *resultobj = 0;
7388 wxMouseState *arg1 = (wxMouseState *) 0 ;
7389 int result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 PyObject *swig_obj[1] ;
7393
7394 if (!args) SWIG_fail;
7395 swig_obj[0] = args;
7396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7399 }
7400 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 result = (int)(arg1)->GetY();
7404 wxPyEndAllowThreads(__tstate);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 resultobj = SWIG_From_int(static_cast< int >(result));
7408 return resultobj;
7409 fail:
7410 return NULL;
7411 }
7412
7413
7414 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7415 PyObject *resultobj = 0;
7416 wxMouseState *arg1 = (wxMouseState *) 0 ;
7417 bool result;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 PyObject *swig_obj[1] ;
7421
7422 if (!args) SWIG_fail;
7423 swig_obj[0] = args;
7424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7425 if (!SWIG_IsOK(res1)) {
7426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7427 }
7428 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7429 {
7430 PyThreadState* __tstate = wxPyBeginAllowThreads();
7431 result = (bool)(arg1)->LeftDown();
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 {
7436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7437 }
7438 return resultobj;
7439 fail:
7440 return NULL;
7441 }
7442
7443
7444 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7445 PyObject *resultobj = 0;
7446 wxMouseState *arg1 = (wxMouseState *) 0 ;
7447 bool result;
7448 void *argp1 = 0 ;
7449 int res1 = 0 ;
7450 PyObject *swig_obj[1] ;
7451
7452 if (!args) SWIG_fail;
7453 swig_obj[0] = args;
7454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7455 if (!SWIG_IsOK(res1)) {
7456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7457 }
7458 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7459 {
7460 PyThreadState* __tstate = wxPyBeginAllowThreads();
7461 result = (bool)(arg1)->MiddleDown();
7462 wxPyEndAllowThreads(__tstate);
7463 if (PyErr_Occurred()) SWIG_fail;
7464 }
7465 {
7466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7467 }
7468 return resultobj;
7469 fail:
7470 return NULL;
7471 }
7472
7473
7474 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7475 PyObject *resultobj = 0;
7476 wxMouseState *arg1 = (wxMouseState *) 0 ;
7477 bool result;
7478 void *argp1 = 0 ;
7479 int res1 = 0 ;
7480 PyObject *swig_obj[1] ;
7481
7482 if (!args) SWIG_fail;
7483 swig_obj[0] = args;
7484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7485 if (!SWIG_IsOK(res1)) {
7486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7487 }
7488 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 result = (bool)(arg1)->RightDown();
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 {
7496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7497 }
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7505 PyObject *resultobj = 0;
7506 wxMouseState *arg1 = (wxMouseState *) 0 ;
7507 bool result;
7508 void *argp1 = 0 ;
7509 int res1 = 0 ;
7510 PyObject *swig_obj[1] ;
7511
7512 if (!args) SWIG_fail;
7513 swig_obj[0] = args;
7514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7517 }
7518 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7519 {
7520 PyThreadState* __tstate = wxPyBeginAllowThreads();
7521 result = (bool)(arg1)->ControlDown();
7522 wxPyEndAllowThreads(__tstate);
7523 if (PyErr_Occurred()) SWIG_fail;
7524 }
7525 {
7526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7527 }
7528 return resultobj;
7529 fail:
7530 return NULL;
7531 }
7532
7533
7534 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7535 PyObject *resultobj = 0;
7536 wxMouseState *arg1 = (wxMouseState *) 0 ;
7537 bool result;
7538 void *argp1 = 0 ;
7539 int res1 = 0 ;
7540 PyObject *swig_obj[1] ;
7541
7542 if (!args) SWIG_fail;
7543 swig_obj[0] = args;
7544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7545 if (!SWIG_IsOK(res1)) {
7546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7547 }
7548 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7549 {
7550 PyThreadState* __tstate = wxPyBeginAllowThreads();
7551 result = (bool)(arg1)->ShiftDown();
7552 wxPyEndAllowThreads(__tstate);
7553 if (PyErr_Occurred()) SWIG_fail;
7554 }
7555 {
7556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7557 }
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7565 PyObject *resultobj = 0;
7566 wxMouseState *arg1 = (wxMouseState *) 0 ;
7567 bool result;
7568 void *argp1 = 0 ;
7569 int res1 = 0 ;
7570 PyObject *swig_obj[1] ;
7571
7572 if (!args) SWIG_fail;
7573 swig_obj[0] = args;
7574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7575 if (!SWIG_IsOK(res1)) {
7576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7577 }
7578 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 result = (bool)(arg1)->AltDown();
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 {
7586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7587 }
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7595 PyObject *resultobj = 0;
7596 wxMouseState *arg1 = (wxMouseState *) 0 ;
7597 bool result;
7598 void *argp1 = 0 ;
7599 int res1 = 0 ;
7600 PyObject *swig_obj[1] ;
7601
7602 if (!args) SWIG_fail;
7603 swig_obj[0] = args;
7604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7605 if (!SWIG_IsOK(res1)) {
7606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7607 }
7608 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7609 {
7610 PyThreadState* __tstate = wxPyBeginAllowThreads();
7611 result = (bool)(arg1)->MetaDown();
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 {
7616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7617 }
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7625 PyObject *resultobj = 0;
7626 wxMouseState *arg1 = (wxMouseState *) 0 ;
7627 bool result;
7628 void *argp1 = 0 ;
7629 int res1 = 0 ;
7630 PyObject *swig_obj[1] ;
7631
7632 if (!args) SWIG_fail;
7633 swig_obj[0] = args;
7634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7635 if (!SWIG_IsOK(res1)) {
7636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7637 }
7638 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7639 {
7640 PyThreadState* __tstate = wxPyBeginAllowThreads();
7641 result = (bool)(arg1)->CmdDown();
7642 wxPyEndAllowThreads(__tstate);
7643 if (PyErr_Occurred()) SWIG_fail;
7644 }
7645 {
7646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7647 }
7648 return resultobj;
7649 fail:
7650 return NULL;
7651 }
7652
7653
7654 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7655 PyObject *resultobj = 0;
7656 wxMouseState *arg1 = (wxMouseState *) 0 ;
7657 int arg2 ;
7658 void *argp1 = 0 ;
7659 int res1 = 0 ;
7660 int val2 ;
7661 int ecode2 = 0 ;
7662 PyObject * obj0 = 0 ;
7663 PyObject * obj1 = 0 ;
7664 char * kwnames[] = {
7665 (char *) "self",(char *) "x", NULL
7666 };
7667
7668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7670 if (!SWIG_IsOK(res1)) {
7671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7672 }
7673 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7674 ecode2 = SWIG_AsVal_int(obj1, &val2);
7675 if (!SWIG_IsOK(ecode2)) {
7676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7677 }
7678 arg2 = static_cast< int >(val2);
7679 {
7680 PyThreadState* __tstate = wxPyBeginAllowThreads();
7681 (arg1)->SetX(arg2);
7682 wxPyEndAllowThreads(__tstate);
7683 if (PyErr_Occurred()) SWIG_fail;
7684 }
7685 resultobj = SWIG_Py_Void();
7686 return resultobj;
7687 fail:
7688 return NULL;
7689 }
7690
7691
7692 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7693 PyObject *resultobj = 0;
7694 wxMouseState *arg1 = (wxMouseState *) 0 ;
7695 int arg2 ;
7696 void *argp1 = 0 ;
7697 int res1 = 0 ;
7698 int val2 ;
7699 int ecode2 = 0 ;
7700 PyObject * obj0 = 0 ;
7701 PyObject * obj1 = 0 ;
7702 char * kwnames[] = {
7703 (char *) "self",(char *) "y", NULL
7704 };
7705
7706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7708 if (!SWIG_IsOK(res1)) {
7709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7710 }
7711 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7712 ecode2 = SWIG_AsVal_int(obj1, &val2);
7713 if (!SWIG_IsOK(ecode2)) {
7714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7715 }
7716 arg2 = static_cast< int >(val2);
7717 {
7718 PyThreadState* __tstate = wxPyBeginAllowThreads();
7719 (arg1)->SetY(arg2);
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 resultobj = SWIG_Py_Void();
7724 return resultobj;
7725 fail:
7726 return NULL;
7727 }
7728
7729
7730 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7731 PyObject *resultobj = 0;
7732 wxMouseState *arg1 = (wxMouseState *) 0 ;
7733 bool arg2 ;
7734 void *argp1 = 0 ;
7735 int res1 = 0 ;
7736 bool val2 ;
7737 int ecode2 = 0 ;
7738 PyObject * obj0 = 0 ;
7739 PyObject * obj1 = 0 ;
7740 char * kwnames[] = {
7741 (char *) "self",(char *) "down", NULL
7742 };
7743
7744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7746 if (!SWIG_IsOK(res1)) {
7747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7748 }
7749 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7750 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7751 if (!SWIG_IsOK(ecode2)) {
7752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7753 }
7754 arg2 = static_cast< bool >(val2);
7755 {
7756 PyThreadState* __tstate = wxPyBeginAllowThreads();
7757 (arg1)->SetLeftDown(arg2);
7758 wxPyEndAllowThreads(__tstate);
7759 if (PyErr_Occurred()) SWIG_fail;
7760 }
7761 resultobj = SWIG_Py_Void();
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj = 0;
7770 wxMouseState *arg1 = (wxMouseState *) 0 ;
7771 bool arg2 ;
7772 void *argp1 = 0 ;
7773 int res1 = 0 ;
7774 bool val2 ;
7775 int ecode2 = 0 ;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 char * kwnames[] = {
7779 (char *) "self",(char *) "down", NULL
7780 };
7781
7782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7784 if (!SWIG_IsOK(res1)) {
7785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7786 }
7787 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7789 if (!SWIG_IsOK(ecode2)) {
7790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7791 }
7792 arg2 = static_cast< bool >(val2);
7793 {
7794 PyThreadState* __tstate = wxPyBeginAllowThreads();
7795 (arg1)->SetMiddleDown(arg2);
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 resultobj = SWIG_Py_Void();
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj = 0;
7808 wxMouseState *arg1 = (wxMouseState *) 0 ;
7809 bool arg2 ;
7810 void *argp1 = 0 ;
7811 int res1 = 0 ;
7812 bool val2 ;
7813 int ecode2 = 0 ;
7814 PyObject * obj0 = 0 ;
7815 PyObject * obj1 = 0 ;
7816 char * kwnames[] = {
7817 (char *) "self",(char *) "down", NULL
7818 };
7819
7820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7822 if (!SWIG_IsOK(res1)) {
7823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7824 }
7825 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7826 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7827 if (!SWIG_IsOK(ecode2)) {
7828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7829 }
7830 arg2 = static_cast< bool >(val2);
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 (arg1)->SetRightDown(arg2);
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 resultobj = SWIG_Py_Void();
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7845 PyObject *resultobj = 0;
7846 wxMouseState *arg1 = (wxMouseState *) 0 ;
7847 bool arg2 ;
7848 void *argp1 = 0 ;
7849 int res1 = 0 ;
7850 bool val2 ;
7851 int ecode2 = 0 ;
7852 PyObject * obj0 = 0 ;
7853 PyObject * obj1 = 0 ;
7854 char * kwnames[] = {
7855 (char *) "self",(char *) "down", NULL
7856 };
7857
7858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7860 if (!SWIG_IsOK(res1)) {
7861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7862 }
7863 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7864 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7865 if (!SWIG_IsOK(ecode2)) {
7866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7867 }
7868 arg2 = static_cast< bool >(val2);
7869 {
7870 PyThreadState* __tstate = wxPyBeginAllowThreads();
7871 (arg1)->SetControlDown(arg2);
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 resultobj = SWIG_Py_Void();
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj = 0;
7884 wxMouseState *arg1 = (wxMouseState *) 0 ;
7885 bool arg2 ;
7886 void *argp1 = 0 ;
7887 int res1 = 0 ;
7888 bool val2 ;
7889 int ecode2 = 0 ;
7890 PyObject * obj0 = 0 ;
7891 PyObject * obj1 = 0 ;
7892 char * kwnames[] = {
7893 (char *) "self",(char *) "down", NULL
7894 };
7895
7896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7898 if (!SWIG_IsOK(res1)) {
7899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7900 }
7901 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7902 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7903 if (!SWIG_IsOK(ecode2)) {
7904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7905 }
7906 arg2 = static_cast< bool >(val2);
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 (arg1)->SetShiftDown(arg2);
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 resultobj = SWIG_Py_Void();
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = 0;
7922 wxMouseState *arg1 = (wxMouseState *) 0 ;
7923 bool arg2 ;
7924 void *argp1 = 0 ;
7925 int res1 = 0 ;
7926 bool val2 ;
7927 int ecode2 = 0 ;
7928 PyObject * obj0 = 0 ;
7929 PyObject * obj1 = 0 ;
7930 char * kwnames[] = {
7931 (char *) "self",(char *) "down", NULL
7932 };
7933
7934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7936 if (!SWIG_IsOK(res1)) {
7937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7938 }
7939 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7940 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7941 if (!SWIG_IsOK(ecode2)) {
7942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7943 }
7944 arg2 = static_cast< bool >(val2);
7945 {
7946 PyThreadState* __tstate = wxPyBeginAllowThreads();
7947 (arg1)->SetAltDown(arg2);
7948 wxPyEndAllowThreads(__tstate);
7949 if (PyErr_Occurred()) SWIG_fail;
7950 }
7951 resultobj = SWIG_Py_Void();
7952 return resultobj;
7953 fail:
7954 return NULL;
7955 }
7956
7957
7958 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7959 PyObject *resultobj = 0;
7960 wxMouseState *arg1 = (wxMouseState *) 0 ;
7961 bool arg2 ;
7962 void *argp1 = 0 ;
7963 int res1 = 0 ;
7964 bool val2 ;
7965 int ecode2 = 0 ;
7966 PyObject * obj0 = 0 ;
7967 PyObject * obj1 = 0 ;
7968 char * kwnames[] = {
7969 (char *) "self",(char *) "down", NULL
7970 };
7971
7972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7974 if (!SWIG_IsOK(res1)) {
7975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7976 }
7977 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7978 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7979 if (!SWIG_IsOK(ecode2)) {
7980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7981 }
7982 arg2 = static_cast< bool >(val2);
7983 {
7984 PyThreadState* __tstate = wxPyBeginAllowThreads();
7985 (arg1)->SetMetaDown(arg2);
7986 wxPyEndAllowThreads(__tstate);
7987 if (PyErr_Occurred()) SWIG_fail;
7988 }
7989 resultobj = SWIG_Py_Void();
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7997 PyObject *obj;
7998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7999 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8000 return SWIG_Py_Void();
8001 }
8002
8003 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8004 return SWIG_Python_InitShadowInstance(args);
8005 }
8006
8007 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8008 PyObject *resultobj = 0;
8009 wxMouseState result;
8010
8011 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8012 {
8013 PyThreadState* __tstate = wxPyBeginAllowThreads();
8014 result = wxGetMouseState();
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8026 PyObject *resultobj = 0;
8027
8028 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8029 {
8030 if (!wxPyCheckForApp()) SWIG_fail;
8031 PyThreadState* __tstate = wxPyBeginAllowThreads();
8032 wxWakeUpMainThread();
8033 wxPyEndAllowThreads(__tstate);
8034 if (PyErr_Occurred()) SWIG_fail;
8035 }
8036 resultobj = SWIG_Py_Void();
8037 return resultobj;
8038 fail:
8039 return NULL;
8040 }
8041
8042
8043 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8044 PyObject *resultobj = 0;
8045
8046 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8047 {
8048 if (!wxPyCheckForApp()) SWIG_fail;
8049 PyThreadState* __tstate = wxPyBeginAllowThreads();
8050 wxMutexGuiEnter();
8051 wxPyEndAllowThreads(__tstate);
8052 if (PyErr_Occurred()) SWIG_fail;
8053 }
8054 resultobj = SWIG_Py_Void();
8055 return resultobj;
8056 fail:
8057 return NULL;
8058 }
8059
8060
8061 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8062 PyObject *resultobj = 0;
8063
8064 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8065 {
8066 if (!wxPyCheckForApp()) SWIG_fail;
8067 PyThreadState* __tstate = wxPyBeginAllowThreads();
8068 wxMutexGuiLeave();
8069 wxPyEndAllowThreads(__tstate);
8070 if (PyErr_Occurred()) SWIG_fail;
8071 }
8072 resultobj = SWIG_Py_Void();
8073 return resultobj;
8074 fail:
8075 return NULL;
8076 }
8077
8078
8079 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8080 PyObject *resultobj = 0;
8081 wxMutexGuiLocker *result = 0 ;
8082
8083 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8084 {
8085 if (!wxPyCheckForApp()) SWIG_fail;
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8099 PyObject *resultobj = 0;
8100 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8101 void *argp1 = 0 ;
8102 int res1 = 0 ;
8103 PyObject *swig_obj[1] ;
8104
8105 if (!args) SWIG_fail;
8106 swig_obj[0] = args;
8107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8108 if (!SWIG_IsOK(res1)) {
8109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8110 }
8111 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8112 {
8113 PyThreadState* __tstate = wxPyBeginAllowThreads();
8114 delete arg1;
8115
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 resultobj = SWIG_Py_Void();
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8127 PyObject *obj;
8128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8129 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8130 return SWIG_Py_Void();
8131 }
8132
8133 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8134 return SWIG_Python_InitShadowInstance(args);
8135 }
8136
8137 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8138 PyObject *resultobj = 0;
8139 bool result;
8140
8141 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8142 {
8143 PyThreadState* __tstate = wxPyBeginAllowThreads();
8144 result = (bool)wxThread_IsMain();
8145 wxPyEndAllowThreads(__tstate);
8146 if (PyErr_Occurred()) SWIG_fail;
8147 }
8148 {
8149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8150 }
8151 return resultobj;
8152 fail:
8153 return NULL;
8154 }
8155
8156
8157 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8158 PyObject *resultobj = 0;
8159 wxString *arg1 = 0 ;
8160 wxToolTip *result = 0 ;
8161 bool temp1 = false ;
8162 PyObject * obj0 = 0 ;
8163 char * kwnames[] = {
8164 (char *) "tip", NULL
8165 };
8166
8167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8168 {
8169 arg1 = wxString_in_helper(obj0);
8170 if (arg1 == NULL) SWIG_fail;
8171 temp1 = true;
8172 }
8173 {
8174 if (!wxPyCheckForApp()) SWIG_fail;
8175 PyThreadState* __tstate = wxPyBeginAllowThreads();
8176 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8177 wxPyEndAllowThreads(__tstate);
8178 if (PyErr_Occurred()) SWIG_fail;
8179 }
8180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8181 {
8182 if (temp1)
8183 delete arg1;
8184 }
8185 return resultobj;
8186 fail:
8187 {
8188 if (temp1)
8189 delete arg1;
8190 }
8191 return NULL;
8192 }
8193
8194
8195 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8196 PyObject *resultobj = 0;
8197 wxToolTip *arg1 = (wxToolTip *) 0 ;
8198 void *argp1 = 0 ;
8199 int res1 = 0 ;
8200 PyObject *swig_obj[1] ;
8201
8202 if (!args) SWIG_fail;
8203 swig_obj[0] = args;
8204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8205 if (!SWIG_IsOK(res1)) {
8206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8207 }
8208 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8209 {
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 delete arg1;
8212
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 resultobj = SWIG_Py_Void();
8217 return resultobj;
8218 fail:
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8224 PyObject *resultobj = 0;
8225 wxToolTip *arg1 = (wxToolTip *) 0 ;
8226 wxString *arg2 = 0 ;
8227 void *argp1 = 0 ;
8228 int res1 = 0 ;
8229 bool temp2 = false ;
8230 PyObject * obj0 = 0 ;
8231 PyObject * obj1 = 0 ;
8232 char * kwnames[] = {
8233 (char *) "self",(char *) "tip", NULL
8234 };
8235
8236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8238 if (!SWIG_IsOK(res1)) {
8239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8240 }
8241 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8242 {
8243 arg2 = wxString_in_helper(obj1);
8244 if (arg2 == NULL) SWIG_fail;
8245 temp2 = true;
8246 }
8247 {
8248 PyThreadState* __tstate = wxPyBeginAllowThreads();
8249 (arg1)->SetTip((wxString const &)*arg2);
8250 wxPyEndAllowThreads(__tstate);
8251 if (PyErr_Occurred()) SWIG_fail;
8252 }
8253 resultobj = SWIG_Py_Void();
8254 {
8255 if (temp2)
8256 delete arg2;
8257 }
8258 return resultobj;
8259 fail:
8260 {
8261 if (temp2)
8262 delete arg2;
8263 }
8264 return NULL;
8265 }
8266
8267
8268 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8269 PyObject *resultobj = 0;
8270 wxToolTip *arg1 = (wxToolTip *) 0 ;
8271 wxString result;
8272 void *argp1 = 0 ;
8273 int res1 = 0 ;
8274 PyObject *swig_obj[1] ;
8275
8276 if (!args) SWIG_fail;
8277 swig_obj[0] = args;
8278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8279 if (!SWIG_IsOK(res1)) {
8280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8281 }
8282 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8283 {
8284 PyThreadState* __tstate = wxPyBeginAllowThreads();
8285 result = (arg1)->GetTip();
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 {
8290 #if wxUSE_UNICODE
8291 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8292 #else
8293 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8294 #endif
8295 }
8296 return resultobj;
8297 fail:
8298 return NULL;
8299 }
8300
8301
8302 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8303 PyObject *resultobj = 0;
8304 wxToolTip *arg1 = (wxToolTip *) 0 ;
8305 wxWindow *result = 0 ;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 PyObject *swig_obj[1] ;
8309
8310 if (!args) SWIG_fail;
8311 swig_obj[0] = args;
8312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8313 if (!SWIG_IsOK(res1)) {
8314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8315 }
8316 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8317 {
8318 PyThreadState* __tstate = wxPyBeginAllowThreads();
8319 result = (wxWindow *)(arg1)->GetWindow();
8320 wxPyEndAllowThreads(__tstate);
8321 if (PyErr_Occurred()) SWIG_fail;
8322 }
8323 {
8324 resultobj = wxPyMake_wxObject(result, 0);
8325 }
8326 return resultobj;
8327 fail:
8328 return NULL;
8329 }
8330
8331
8332 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8333 PyObject *resultobj = 0;
8334 bool arg1 ;
8335 bool val1 ;
8336 int ecode1 = 0 ;
8337 PyObject * obj0 = 0 ;
8338 char * kwnames[] = {
8339 (char *) "flag", NULL
8340 };
8341
8342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8343 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8344 if (!SWIG_IsOK(ecode1)) {
8345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8346 }
8347 arg1 = static_cast< bool >(val1);
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 wxToolTip::Enable(arg1);
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_Py_Void();
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 long arg1 ;
8364 long val1 ;
8365 int ecode1 = 0 ;
8366 PyObject * obj0 = 0 ;
8367 char * kwnames[] = {
8368 (char *) "milliseconds", NULL
8369 };
8370
8371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8372 ecode1 = SWIG_AsVal_long(obj0, &val1);
8373 if (!SWIG_IsOK(ecode1)) {
8374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8375 }
8376 arg1 = static_cast< long >(val1);
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 wxToolTip::SetDelay(arg1);
8380 wxPyEndAllowThreads(__tstate);
8381 if (PyErr_Occurred()) SWIG_fail;
8382 }
8383 resultobj = SWIG_Py_Void();
8384 return resultobj;
8385 fail:
8386 return NULL;
8387 }
8388
8389
8390 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8391 PyObject *obj;
8392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8393 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8394 return SWIG_Py_Void();
8395 }
8396
8397 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8398 return SWIG_Python_InitShadowInstance(args);
8399 }
8400
8401 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj = 0;
8403 wxWindow *arg1 = (wxWindow *) 0 ;
8404 wxSize *arg2 = 0 ;
8405 wxCaret *result = 0 ;
8406 void *argp1 = 0 ;
8407 int res1 = 0 ;
8408 wxSize temp2 ;
8409 PyObject * obj0 = 0 ;
8410 PyObject * obj1 = 0 ;
8411 char * kwnames[] = {
8412 (char *) "window",(char *) "size", NULL
8413 };
8414
8415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8417 if (!SWIG_IsOK(res1)) {
8418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8419 }
8420 arg1 = reinterpret_cast< wxWindow * >(argp1);
8421 {
8422 arg2 = &temp2;
8423 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8424 }
8425 {
8426 if (!wxPyCheckForApp()) SWIG_fail;
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8440 PyObject *resultobj = 0;
8441 wxCaret *arg1 = (wxCaret *) 0 ;
8442 void *argp1 = 0 ;
8443 int res1 = 0 ;
8444 PyObject *swig_obj[1] ;
8445
8446 if (!args) SWIG_fail;
8447 swig_obj[0] = args;
8448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8449 if (!SWIG_IsOK(res1)) {
8450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8451 }
8452 arg1 = reinterpret_cast< wxCaret * >(argp1);
8453 {
8454 PyThreadState* __tstate = wxPyBeginAllowThreads();
8455 delete arg1;
8456
8457 wxPyEndAllowThreads(__tstate);
8458 if (PyErr_Occurred()) SWIG_fail;
8459 }
8460 resultobj = SWIG_Py_Void();
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8468 PyObject *resultobj = 0;
8469 wxCaret *arg1 = (wxCaret *) 0 ;
8470 void *argp1 = 0 ;
8471 int res1 = 0 ;
8472 PyObject *swig_obj[1] ;
8473
8474 if (!args) SWIG_fail;
8475 swig_obj[0] = args;
8476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8477 if (!SWIG_IsOK(res1)) {
8478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8479 }
8480 arg1 = reinterpret_cast< wxCaret * >(argp1);
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 wxCaret_Destroy(arg1);
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 resultobj = SWIG_Py_Void();
8488 return resultobj;
8489 fail:
8490 return NULL;
8491 }
8492
8493
8494 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8495 PyObject *resultobj = 0;
8496 wxCaret *arg1 = (wxCaret *) 0 ;
8497 bool result;
8498 void *argp1 = 0 ;
8499 int res1 = 0 ;
8500 PyObject *swig_obj[1] ;
8501
8502 if (!args) SWIG_fail;
8503 swig_obj[0] = args;
8504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8505 if (!SWIG_IsOK(res1)) {
8506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8507 }
8508 arg1 = reinterpret_cast< wxCaret * >(argp1);
8509 {
8510 PyThreadState* __tstate = wxPyBeginAllowThreads();
8511 result = (bool)(arg1)->IsOk();
8512 wxPyEndAllowThreads(__tstate);
8513 if (PyErr_Occurred()) SWIG_fail;
8514 }
8515 {
8516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8517 }
8518 return resultobj;
8519 fail:
8520 return NULL;
8521 }
8522
8523
8524 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8525 PyObject *resultobj = 0;
8526 wxCaret *arg1 = (wxCaret *) 0 ;
8527 bool result;
8528 void *argp1 = 0 ;
8529 int res1 = 0 ;
8530 PyObject *swig_obj[1] ;
8531
8532 if (!args) SWIG_fail;
8533 swig_obj[0] = args;
8534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8535 if (!SWIG_IsOK(res1)) {
8536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8537 }
8538 arg1 = reinterpret_cast< wxCaret * >(argp1);
8539 {
8540 PyThreadState* __tstate = wxPyBeginAllowThreads();
8541 result = (bool)(arg1)->IsVisible();
8542 wxPyEndAllowThreads(__tstate);
8543 if (PyErr_Occurred()) SWIG_fail;
8544 }
8545 {
8546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8547 }
8548 return resultobj;
8549 fail:
8550 return NULL;
8551 }
8552
8553
8554 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8555 PyObject *resultobj = 0;
8556 wxCaret *arg1 = (wxCaret *) 0 ;
8557 wxPoint result;
8558 void *argp1 = 0 ;
8559 int res1 = 0 ;
8560 PyObject *swig_obj[1] ;
8561
8562 if (!args) SWIG_fail;
8563 swig_obj[0] = args;
8564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8565 if (!SWIG_IsOK(res1)) {
8566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8567 }
8568 arg1 = reinterpret_cast< wxCaret * >(argp1);
8569 {
8570 PyThreadState* __tstate = wxPyBeginAllowThreads();
8571 result = (arg1)->GetPosition();
8572 wxPyEndAllowThreads(__tstate);
8573 if (PyErr_Occurred()) SWIG_fail;
8574 }
8575 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8576 return resultobj;
8577 fail:
8578 return NULL;
8579 }
8580
8581
8582 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8583 PyObject *resultobj = 0;
8584 wxCaret *arg1 = (wxCaret *) 0 ;
8585 int *arg2 = (int *) 0 ;
8586 int *arg3 = (int *) 0 ;
8587 void *argp1 = 0 ;
8588 int res1 = 0 ;
8589 int temp2 ;
8590 int res2 = SWIG_TMPOBJ ;
8591 int temp3 ;
8592 int res3 = SWIG_TMPOBJ ;
8593 PyObject *swig_obj[1] ;
8594
8595 arg2 = &temp2;
8596 arg3 = &temp3;
8597 if (!args) SWIG_fail;
8598 swig_obj[0] = args;
8599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8600 if (!SWIG_IsOK(res1)) {
8601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8602 }
8603 arg1 = reinterpret_cast< wxCaret * >(argp1);
8604 {
8605 PyThreadState* __tstate = wxPyBeginAllowThreads();
8606 (arg1)->GetPosition(arg2,arg3);
8607 wxPyEndAllowThreads(__tstate);
8608 if (PyErr_Occurred()) SWIG_fail;
8609 }
8610 resultobj = SWIG_Py_Void();
8611 if (SWIG_IsTmpObj(res2)) {
8612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8613 } else {
8614 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8616 }
8617 if (SWIG_IsTmpObj(res3)) {
8618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8619 } else {
8620 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8622 }
8623 return resultobj;
8624 fail:
8625 return NULL;
8626 }
8627
8628
8629 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8630 PyObject *resultobj = 0;
8631 wxCaret *arg1 = (wxCaret *) 0 ;
8632 wxSize result;
8633 void *argp1 = 0 ;
8634 int res1 = 0 ;
8635 PyObject *swig_obj[1] ;
8636
8637 if (!args) SWIG_fail;
8638 swig_obj[0] = args;
8639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8640 if (!SWIG_IsOK(res1)) {
8641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8642 }
8643 arg1 = reinterpret_cast< wxCaret * >(argp1);
8644 {
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 result = (arg1)->GetSize();
8647 wxPyEndAllowThreads(__tstate);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8658 PyObject *resultobj = 0;
8659 wxCaret *arg1 = (wxCaret *) 0 ;
8660 int *arg2 = (int *) 0 ;
8661 int *arg3 = (int *) 0 ;
8662 void *argp1 = 0 ;
8663 int res1 = 0 ;
8664 int temp2 ;
8665 int res2 = SWIG_TMPOBJ ;
8666 int temp3 ;
8667 int res3 = SWIG_TMPOBJ ;
8668 PyObject *swig_obj[1] ;
8669
8670 arg2 = &temp2;
8671 arg3 = &temp3;
8672 if (!args) SWIG_fail;
8673 swig_obj[0] = args;
8674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8675 if (!SWIG_IsOK(res1)) {
8676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8677 }
8678 arg1 = reinterpret_cast< wxCaret * >(argp1);
8679 {
8680 PyThreadState* __tstate = wxPyBeginAllowThreads();
8681 (arg1)->GetSize(arg2,arg3);
8682 wxPyEndAllowThreads(__tstate);
8683 if (PyErr_Occurred()) SWIG_fail;
8684 }
8685 resultobj = SWIG_Py_Void();
8686 if (SWIG_IsTmpObj(res2)) {
8687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8688 } else {
8689 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8691 }
8692 if (SWIG_IsTmpObj(res3)) {
8693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8694 } else {
8695 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8697 }
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8705 PyObject *resultobj = 0;
8706 wxCaret *arg1 = (wxCaret *) 0 ;
8707 wxWindow *result = 0 ;
8708 void *argp1 = 0 ;
8709 int res1 = 0 ;
8710 PyObject *swig_obj[1] ;
8711
8712 if (!args) SWIG_fail;
8713 swig_obj[0] = args;
8714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8715 if (!SWIG_IsOK(res1)) {
8716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8717 }
8718 arg1 = reinterpret_cast< wxCaret * >(argp1);
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 result = (wxWindow *)(arg1)->GetWindow();
8722 wxPyEndAllowThreads(__tstate);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 {
8726 resultobj = wxPyMake_wxObject(result, 0);
8727 }
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj = 0;
8736 wxCaret *arg1 = (wxCaret *) 0 ;
8737 int arg2 ;
8738 int arg3 ;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 int val2 ;
8742 int ecode2 = 0 ;
8743 int val3 ;
8744 int ecode3 = 0 ;
8745 PyObject * obj0 = 0 ;
8746 PyObject * obj1 = 0 ;
8747 PyObject * obj2 = 0 ;
8748 char * kwnames[] = {
8749 (char *) "self",(char *) "x",(char *) "y", NULL
8750 };
8751
8752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8754 if (!SWIG_IsOK(res1)) {
8755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8756 }
8757 arg1 = reinterpret_cast< wxCaret * >(argp1);
8758 ecode2 = SWIG_AsVal_int(obj1, &val2);
8759 if (!SWIG_IsOK(ecode2)) {
8760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8761 }
8762 arg2 = static_cast< int >(val2);
8763 ecode3 = SWIG_AsVal_int(obj2, &val3);
8764 if (!SWIG_IsOK(ecode3)) {
8765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8766 }
8767 arg3 = static_cast< int >(val3);
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 (arg1)->Move(arg2,arg3);
8771 wxPyEndAllowThreads(__tstate);
8772 if (PyErr_Occurred()) SWIG_fail;
8773 }
8774 resultobj = SWIG_Py_Void();
8775 return resultobj;
8776 fail:
8777 return NULL;
8778 }
8779
8780
8781 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8782 PyObject *resultobj = 0;
8783 wxCaret *arg1 = (wxCaret *) 0 ;
8784 wxPoint *arg2 = 0 ;
8785 void *argp1 = 0 ;
8786 int res1 = 0 ;
8787 wxPoint temp2 ;
8788 PyObject * obj0 = 0 ;
8789 PyObject * obj1 = 0 ;
8790 char * kwnames[] = {
8791 (char *) "self",(char *) "pt", NULL
8792 };
8793
8794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8796 if (!SWIG_IsOK(res1)) {
8797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8798 }
8799 arg1 = reinterpret_cast< wxCaret * >(argp1);
8800 {
8801 arg2 = &temp2;
8802 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8803 }
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 (arg1)->Move((wxPoint const &)*arg2);
8807 wxPyEndAllowThreads(__tstate);
8808 if (PyErr_Occurred()) SWIG_fail;
8809 }
8810 resultobj = SWIG_Py_Void();
8811 return resultobj;
8812 fail:
8813 return NULL;
8814 }
8815
8816
8817 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8818 PyObject *resultobj = 0;
8819 wxCaret *arg1 = (wxCaret *) 0 ;
8820 int arg2 ;
8821 int arg3 ;
8822 void *argp1 = 0 ;
8823 int res1 = 0 ;
8824 int val2 ;
8825 int ecode2 = 0 ;
8826 int val3 ;
8827 int ecode3 = 0 ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 PyObject * obj2 = 0 ;
8831 char * kwnames[] = {
8832 (char *) "self",(char *) "width",(char *) "height", NULL
8833 };
8834
8835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8837 if (!SWIG_IsOK(res1)) {
8838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8839 }
8840 arg1 = reinterpret_cast< wxCaret * >(argp1);
8841 ecode2 = SWIG_AsVal_int(obj1, &val2);
8842 if (!SWIG_IsOK(ecode2)) {
8843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8844 }
8845 arg2 = static_cast< int >(val2);
8846 ecode3 = SWIG_AsVal_int(obj2, &val3);
8847 if (!SWIG_IsOK(ecode3)) {
8848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8849 }
8850 arg3 = static_cast< int >(val3);
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 (arg1)->SetSize(arg2,arg3);
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 resultobj = SWIG_Py_Void();
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8865 PyObject *resultobj = 0;
8866 wxCaret *arg1 = (wxCaret *) 0 ;
8867 wxSize *arg2 = 0 ;
8868 void *argp1 = 0 ;
8869 int res1 = 0 ;
8870 wxSize temp2 ;
8871 PyObject * obj0 = 0 ;
8872 PyObject * obj1 = 0 ;
8873 char * kwnames[] = {
8874 (char *) "self",(char *) "size", NULL
8875 };
8876
8877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8879 if (!SWIG_IsOK(res1)) {
8880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8881 }
8882 arg1 = reinterpret_cast< wxCaret * >(argp1);
8883 {
8884 arg2 = &temp2;
8885 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8886 }
8887 {
8888 PyThreadState* __tstate = wxPyBeginAllowThreads();
8889 (arg1)->SetSize((wxSize const &)*arg2);
8890 wxPyEndAllowThreads(__tstate);
8891 if (PyErr_Occurred()) SWIG_fail;
8892 }
8893 resultobj = SWIG_Py_Void();
8894 return resultobj;
8895 fail:
8896 return NULL;
8897 }
8898
8899
8900 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8901 PyObject *resultobj = 0;
8902 wxCaret *arg1 = (wxCaret *) 0 ;
8903 int arg2 = (int) true ;
8904 void *argp1 = 0 ;
8905 int res1 = 0 ;
8906 int val2 ;
8907 int ecode2 = 0 ;
8908 PyObject * obj0 = 0 ;
8909 PyObject * obj1 = 0 ;
8910 char * kwnames[] = {
8911 (char *) "self",(char *) "show", NULL
8912 };
8913
8914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8916 if (!SWIG_IsOK(res1)) {
8917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8918 }
8919 arg1 = reinterpret_cast< wxCaret * >(argp1);
8920 if (obj1) {
8921 ecode2 = SWIG_AsVal_int(obj1, &val2);
8922 if (!SWIG_IsOK(ecode2)) {
8923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8924 }
8925 arg2 = static_cast< int >(val2);
8926 }
8927 {
8928 PyThreadState* __tstate = wxPyBeginAllowThreads();
8929 (arg1)->Show(arg2);
8930 wxPyEndAllowThreads(__tstate);
8931 if (PyErr_Occurred()) SWIG_fail;
8932 }
8933 resultobj = SWIG_Py_Void();
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8941 PyObject *resultobj = 0;
8942 wxCaret *arg1 = (wxCaret *) 0 ;
8943 void *argp1 = 0 ;
8944 int res1 = 0 ;
8945 PyObject *swig_obj[1] ;
8946
8947 if (!args) SWIG_fail;
8948 swig_obj[0] = args;
8949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8950 if (!SWIG_IsOK(res1)) {
8951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8952 }
8953 arg1 = reinterpret_cast< wxCaret * >(argp1);
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 (arg1)->Hide();
8957 wxPyEndAllowThreads(__tstate);
8958 if (PyErr_Occurred()) SWIG_fail;
8959 }
8960 resultobj = SWIG_Py_Void();
8961 return resultobj;
8962 fail:
8963 return NULL;
8964 }
8965
8966
8967 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8968 PyObject *resultobj = 0;
8969 int result;
8970
8971 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (int)wxCaret::GetBlinkTime();
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = SWIG_From_int(static_cast< int >(result));
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj = 0;
8987 int arg1 ;
8988 int val1 ;
8989 int ecode1 = 0 ;
8990 PyObject * obj0 = 0 ;
8991 char * kwnames[] = {
8992 (char *) "milliseconds", NULL
8993 };
8994
8995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8996 ecode1 = SWIG_AsVal_int(obj0, &val1);
8997 if (!SWIG_IsOK(ecode1)) {
8998 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8999 }
9000 arg1 = static_cast< int >(val1);
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 wxCaret::SetBlinkTime(arg1);
9004 wxPyEndAllowThreads(__tstate);
9005 if (PyErr_Occurred()) SWIG_fail;
9006 }
9007 resultobj = SWIG_Py_Void();
9008 return resultobj;
9009 fail:
9010 return NULL;
9011 }
9012
9013
9014 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9015 PyObject *obj;
9016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9017 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9018 return SWIG_Py_Void();
9019 }
9020
9021 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9022 return SWIG_Python_InitShadowInstance(args);
9023 }
9024
9025 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9026 PyObject *resultobj = 0;
9027 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9028 wxBusyCursor *result = 0 ;
9029 void *argp1 = 0 ;
9030 int res1 = 0 ;
9031 PyObject * obj0 = 0 ;
9032 char * kwnames[] = {
9033 (char *) "cursor", NULL
9034 };
9035
9036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9037 if (obj0) {
9038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9039 if (!SWIG_IsOK(res1)) {
9040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9041 }
9042 arg1 = reinterpret_cast< wxCursor * >(argp1);
9043 }
9044 {
9045 if (!wxPyCheckForApp()) SWIG_fail;
9046 PyThreadState* __tstate = wxPyBeginAllowThreads();
9047 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9059 PyObject *resultobj = 0;
9060 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9061 void *argp1 = 0 ;
9062 int res1 = 0 ;
9063 PyObject *swig_obj[1] ;
9064
9065 if (!args) SWIG_fail;
9066 swig_obj[0] = args;
9067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9068 if (!SWIG_IsOK(res1)) {
9069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9070 }
9071 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 delete arg1;
9075
9076 wxPyEndAllowThreads(__tstate);
9077 if (PyErr_Occurred()) SWIG_fail;
9078 }
9079 resultobj = SWIG_Py_Void();
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9087 PyObject *obj;
9088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9089 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9090 return SWIG_Py_Void();
9091 }
9092
9093 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9094 return SWIG_Python_InitShadowInstance(args);
9095 }
9096
9097 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj = 0;
9099 wxWindow *arg1 = (wxWindow *) NULL ;
9100 wxWindowDisabler *result = 0 ;
9101 void *argp1 = 0 ;
9102 int res1 = 0 ;
9103 PyObject * obj0 = 0 ;
9104 char * kwnames[] = {
9105 (char *) "winToSkip", NULL
9106 };
9107
9108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9109 if (obj0) {
9110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9111 if (!SWIG_IsOK(res1)) {
9112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9113 }
9114 arg1 = reinterpret_cast< wxWindow * >(argp1);
9115 }
9116 {
9117 if (!wxPyCheckForApp()) SWIG_fail;
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9120 wxPyEndAllowThreads(__tstate);
9121 if (PyErr_Occurred()) SWIG_fail;
9122 }
9123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9131 PyObject *resultobj = 0;
9132 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9133 void *argp1 = 0 ;
9134 int res1 = 0 ;
9135 PyObject *swig_obj[1] ;
9136
9137 if (!args) SWIG_fail;
9138 swig_obj[0] = args;
9139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9140 if (!SWIG_IsOK(res1)) {
9141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9142 }
9143 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 delete arg1;
9147
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 resultobj = SWIG_Py_Void();
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9159 PyObject *obj;
9160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9161 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9162 return SWIG_Py_Void();
9163 }
9164
9165 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9166 return SWIG_Python_InitShadowInstance(args);
9167 }
9168
9169 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj = 0;
9171 wxString *arg1 = 0 ;
9172 wxWindow *arg2 = (wxWindow *) NULL ;
9173 wxBusyInfo *result = 0 ;
9174 bool temp1 = false ;
9175 void *argp2 = 0 ;
9176 int res2 = 0 ;
9177 PyObject * obj0 = 0 ;
9178 PyObject * obj1 = 0 ;
9179 char * kwnames[] = {
9180 (char *) "message",(char *) "parent", NULL
9181 };
9182
9183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9184 {
9185 arg1 = wxString_in_helper(obj0);
9186 if (arg1 == NULL) SWIG_fail;
9187 temp1 = true;
9188 }
9189 if (obj1) {
9190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9191 if (!SWIG_IsOK(res2)) {
9192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9193 }
9194 arg2 = reinterpret_cast< wxWindow * >(argp2);
9195 }
9196 {
9197 if (!wxPyCheckForApp()) SWIG_fail;
9198 PyThreadState* __tstate = wxPyBeginAllowThreads();
9199 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9200 wxPyEndAllowThreads(__tstate);
9201 if (PyErr_Occurred()) SWIG_fail;
9202 }
9203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9204 {
9205 if (temp1)
9206 delete arg1;
9207 }
9208 return resultobj;
9209 fail:
9210 {
9211 if (temp1)
9212 delete arg1;
9213 }
9214 return NULL;
9215 }
9216
9217
9218 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9219 PyObject *resultobj = 0;
9220 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9221 void *argp1 = 0 ;
9222 int res1 = 0 ;
9223 PyObject *swig_obj[1] ;
9224
9225 if (!args) SWIG_fail;
9226 swig_obj[0] = args;
9227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9228 if (!SWIG_IsOK(res1)) {
9229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9230 }
9231 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9232 {
9233 PyThreadState* __tstate = wxPyBeginAllowThreads();
9234 delete arg1;
9235
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 resultobj = SWIG_Py_Void();
9240 return resultobj;
9241 fail:
9242 return NULL;
9243 }
9244
9245
9246 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9247 PyObject *obj;
9248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9249 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9250 return SWIG_Py_Void();
9251 }
9252
9253 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9254 return SWIG_Python_InitShadowInstance(args);
9255 }
9256
9257 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9258 PyObject *resultobj = 0;
9259 wxStopWatch *result = 0 ;
9260
9261 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9262 {
9263 PyThreadState* __tstate = wxPyBeginAllowThreads();
9264 result = (wxStopWatch *)new wxStopWatch();
9265 wxPyEndAllowThreads(__tstate);
9266 if (PyErr_Occurred()) SWIG_fail;
9267 }
9268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
9275 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9276 PyObject *resultobj = 0;
9277 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 PyObject *swig_obj[1] ;
9281
9282 if (!args) SWIG_fail;
9283 swig_obj[0] = args;
9284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9285 if (!SWIG_IsOK(res1)) {
9286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9287 }
9288 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9289 {
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 delete arg1;
9292
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_Py_Void();
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj = 0;
9305 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9306 long arg2 = (long) 0 ;
9307 void *argp1 = 0 ;
9308 int res1 = 0 ;
9309 long val2 ;
9310 int ecode2 = 0 ;
9311 PyObject * obj0 = 0 ;
9312 PyObject * obj1 = 0 ;
9313 char * kwnames[] = {
9314 (char *) "self",(char *) "t0", NULL
9315 };
9316
9317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9319 if (!SWIG_IsOK(res1)) {
9320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9321 }
9322 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9323 if (obj1) {
9324 ecode2 = SWIG_AsVal_long(obj1, &val2);
9325 if (!SWIG_IsOK(ecode2)) {
9326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9327 }
9328 arg2 = static_cast< long >(val2);
9329 }
9330 {
9331 PyThreadState* __tstate = wxPyBeginAllowThreads();
9332 (arg1)->Start(arg2);
9333 wxPyEndAllowThreads(__tstate);
9334 if (PyErr_Occurred()) SWIG_fail;
9335 }
9336 resultobj = SWIG_Py_Void();
9337 return resultobj;
9338 fail:
9339 return NULL;
9340 }
9341
9342
9343 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9344 PyObject *resultobj = 0;
9345 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9346 void *argp1 = 0 ;
9347 int res1 = 0 ;
9348 PyObject *swig_obj[1] ;
9349
9350 if (!args) SWIG_fail;
9351 swig_obj[0] = args;
9352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9353 if (!SWIG_IsOK(res1)) {
9354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9355 }
9356 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 (arg1)->Pause();
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 resultobj = SWIG_Py_Void();
9364 return resultobj;
9365 fail:
9366 return NULL;
9367 }
9368
9369
9370 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9371 PyObject *resultobj = 0;
9372 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9373 void *argp1 = 0 ;
9374 int res1 = 0 ;
9375 PyObject *swig_obj[1] ;
9376
9377 if (!args) SWIG_fail;
9378 swig_obj[0] = args;
9379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9382 }
9383 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9384 {
9385 PyThreadState* __tstate = wxPyBeginAllowThreads();
9386 (arg1)->Resume();
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 resultobj = SWIG_Py_Void();
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9398 PyObject *resultobj = 0;
9399 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9400 long result;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 PyObject *swig_obj[1] ;
9404
9405 if (!args) SWIG_fail;
9406 swig_obj[0] = args;
9407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9408 if (!SWIG_IsOK(res1)) {
9409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9410 }
9411 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (long)((wxStopWatch const *)arg1)->Time();
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_From_long(static_cast< long >(result));
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9426 PyObject *obj;
9427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9428 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9429 return SWIG_Py_Void();
9430 }
9431
9432 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9433 return SWIG_Python_InitShadowInstance(args);
9434 }
9435
9436 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9437 PyObject *resultobj = 0;
9438 int arg1 = (int) 9 ;
9439 int arg2 = (int) wxID_FILE1 ;
9440 wxFileHistory *result = 0 ;
9441 int val1 ;
9442 int ecode1 = 0 ;
9443 int val2 ;
9444 int ecode2 = 0 ;
9445 PyObject * obj0 = 0 ;
9446 PyObject * obj1 = 0 ;
9447 char * kwnames[] = {
9448 (char *) "maxFiles",(char *) "idBase", NULL
9449 };
9450
9451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9452 if (obj0) {
9453 ecode1 = SWIG_AsVal_int(obj0, &val1);
9454 if (!SWIG_IsOK(ecode1)) {
9455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9456 }
9457 arg1 = static_cast< int >(val1);
9458 }
9459 if (obj1) {
9460 ecode2 = SWIG_AsVal_int(obj1, &val2);
9461 if (!SWIG_IsOK(ecode2)) {
9462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9463 }
9464 arg2 = static_cast< int >(val2);
9465 }
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9469 wxPyEndAllowThreads(__tstate);
9470 if (PyErr_Occurred()) SWIG_fail;
9471 }
9472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9473 return resultobj;
9474 fail:
9475 return NULL;
9476 }
9477
9478
9479 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9480 PyObject *resultobj = 0;
9481 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9482 void *argp1 = 0 ;
9483 int res1 = 0 ;
9484 PyObject *swig_obj[1] ;
9485
9486 if (!args) SWIG_fail;
9487 swig_obj[0] = args;
9488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9489 if (!SWIG_IsOK(res1)) {
9490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9491 }
9492 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9493 {
9494 PyThreadState* __tstate = wxPyBeginAllowThreads();
9495 delete arg1;
9496
9497 wxPyEndAllowThreads(__tstate);
9498 if (PyErr_Occurred()) SWIG_fail;
9499 }
9500 resultobj = SWIG_Py_Void();
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9508 PyObject *resultobj = 0;
9509 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9510 wxString *arg2 = 0 ;
9511 void *argp1 = 0 ;
9512 int res1 = 0 ;
9513 bool temp2 = false ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 char * kwnames[] = {
9517 (char *) "self",(char *) "file", NULL
9518 };
9519
9520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9522 if (!SWIG_IsOK(res1)) {
9523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9524 }
9525 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9526 {
9527 arg2 = wxString_in_helper(obj1);
9528 if (arg2 == NULL) SWIG_fail;
9529 temp2 = true;
9530 }
9531 {
9532 PyThreadState* __tstate = wxPyBeginAllowThreads();
9533 (arg1)->AddFileToHistory((wxString const &)*arg2);
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 resultobj = SWIG_Py_Void();
9538 {
9539 if (temp2)
9540 delete arg2;
9541 }
9542 return resultobj;
9543 fail:
9544 {
9545 if (temp2)
9546 delete arg2;
9547 }
9548 return NULL;
9549 }
9550
9551
9552 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9553 PyObject *resultobj = 0;
9554 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9555 int arg2 ;
9556 void *argp1 = 0 ;
9557 int res1 = 0 ;
9558 int val2 ;
9559 int ecode2 = 0 ;
9560 PyObject * obj0 = 0 ;
9561 PyObject * obj1 = 0 ;
9562 char * kwnames[] = {
9563 (char *) "self",(char *) "i", NULL
9564 };
9565
9566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9568 if (!SWIG_IsOK(res1)) {
9569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9570 }
9571 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9572 ecode2 = SWIG_AsVal_int(obj1, &val2);
9573 if (!SWIG_IsOK(ecode2)) {
9574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9575 }
9576 arg2 = static_cast< int >(val2);
9577 {
9578 PyThreadState* __tstate = wxPyBeginAllowThreads();
9579 (arg1)->RemoveFileFromHistory(arg2);
9580 wxPyEndAllowThreads(__tstate);
9581 if (PyErr_Occurred()) SWIG_fail;
9582 }
9583 resultobj = SWIG_Py_Void();
9584 return resultobj;
9585 fail:
9586 return NULL;
9587 }
9588
9589
9590 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9591 PyObject *resultobj = 0;
9592 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9593 int result;
9594 void *argp1 = 0 ;
9595 int res1 = 0 ;
9596 PyObject *swig_obj[1] ;
9597
9598 if (!args) SWIG_fail;
9599 swig_obj[0] = args;
9600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9601 if (!SWIG_IsOK(res1)) {
9602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9603 }
9604 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9605 {
9606 PyThreadState* __tstate = wxPyBeginAllowThreads();
9607 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9608 wxPyEndAllowThreads(__tstate);
9609 if (PyErr_Occurred()) SWIG_fail;
9610 }
9611 resultobj = SWIG_From_int(static_cast< int >(result));
9612 return resultobj;
9613 fail:
9614 return NULL;
9615 }
9616
9617
9618 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj = 0;
9620 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9621 wxMenu *arg2 = (wxMenu *) 0 ;
9622 void *argp1 = 0 ;
9623 int res1 = 0 ;
9624 void *argp2 = 0 ;
9625 int res2 = 0 ;
9626 PyObject * obj0 = 0 ;
9627 PyObject * obj1 = 0 ;
9628 char * kwnames[] = {
9629 (char *) "self",(char *) "menu", NULL
9630 };
9631
9632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9634 if (!SWIG_IsOK(res1)) {
9635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9636 }
9637 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9639 if (!SWIG_IsOK(res2)) {
9640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9641 }
9642 arg2 = reinterpret_cast< wxMenu * >(argp2);
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 (arg1)->UseMenu(arg2);
9646 wxPyEndAllowThreads(__tstate);
9647 if (PyErr_Occurred()) SWIG_fail;
9648 }
9649 resultobj = SWIG_Py_Void();
9650 return resultobj;
9651 fail:
9652 return NULL;
9653 }
9654
9655
9656 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9657 PyObject *resultobj = 0;
9658 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9659 wxMenu *arg2 = (wxMenu *) 0 ;
9660 void *argp1 = 0 ;
9661 int res1 = 0 ;
9662 void *argp2 = 0 ;
9663 int res2 = 0 ;
9664 PyObject * obj0 = 0 ;
9665 PyObject * obj1 = 0 ;
9666 char * kwnames[] = {
9667 (char *) "self",(char *) "menu", NULL
9668 };
9669
9670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9672 if (!SWIG_IsOK(res1)) {
9673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9674 }
9675 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9677 if (!SWIG_IsOK(res2)) {
9678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9679 }
9680 arg2 = reinterpret_cast< wxMenu * >(argp2);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 (arg1)->RemoveMenu(arg2);
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_Py_Void();
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj = 0;
9696 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9697 wxConfigBase *arg2 = 0 ;
9698 void *argp1 = 0 ;
9699 int res1 = 0 ;
9700 void *argp2 = 0 ;
9701 int res2 = 0 ;
9702 PyObject * obj0 = 0 ;
9703 PyObject * obj1 = 0 ;
9704 char * kwnames[] = {
9705 (char *) "self",(char *) "config", NULL
9706 };
9707
9708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9710 if (!SWIG_IsOK(res1)) {
9711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9712 }
9713 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9714 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9715 if (!SWIG_IsOK(res2)) {
9716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9717 }
9718 if (!argp2) {
9719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9720 }
9721 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 (arg1)->Load(*arg2);
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 resultobj = SWIG_Py_Void();
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj = 0;
9737 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9738 wxConfigBase *arg2 = 0 ;
9739 void *argp1 = 0 ;
9740 int res1 = 0 ;
9741 void *argp2 = 0 ;
9742 int res2 = 0 ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char * kwnames[] = {
9746 (char *) "self",(char *) "config", NULL
9747 };
9748
9749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9751 if (!SWIG_IsOK(res1)) {
9752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9753 }
9754 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9755 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9756 if (!SWIG_IsOK(res2)) {
9757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9758 }
9759 if (!argp2) {
9760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9761 }
9762 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9763 {
9764 PyThreadState* __tstate = wxPyBeginAllowThreads();
9765 (arg1)->Save(*arg2);
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 resultobj = SWIG_Py_Void();
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9777 PyObject *resultobj = 0;
9778 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9779 void *argp1 = 0 ;
9780 int res1 = 0 ;
9781 PyObject *swig_obj[1] ;
9782
9783 if (!args) SWIG_fail;
9784 swig_obj[0] = args;
9785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9786 if (!SWIG_IsOK(res1)) {
9787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9788 }
9789 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9790 {
9791 PyThreadState* __tstate = wxPyBeginAllowThreads();
9792 (arg1)->AddFilesToMenu();
9793 wxPyEndAllowThreads(__tstate);
9794 if (PyErr_Occurred()) SWIG_fail;
9795 }
9796 resultobj = SWIG_Py_Void();
9797 return resultobj;
9798 fail:
9799 return NULL;
9800 }
9801
9802
9803 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9804 PyObject *resultobj = 0;
9805 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9806 wxMenu *arg2 = (wxMenu *) 0 ;
9807 void *argp1 = 0 ;
9808 int res1 = 0 ;
9809 void *argp2 = 0 ;
9810 int res2 = 0 ;
9811 PyObject * obj0 = 0 ;
9812 PyObject * obj1 = 0 ;
9813 char * kwnames[] = {
9814 (char *) "self",(char *) "menu", NULL
9815 };
9816
9817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9819 if (!SWIG_IsOK(res1)) {
9820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9821 }
9822 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9823 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9824 if (!SWIG_IsOK(res2)) {
9825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9826 }
9827 arg2 = reinterpret_cast< wxMenu * >(argp2);
9828 {
9829 PyThreadState* __tstate = wxPyBeginAllowThreads();
9830 (arg1)->AddFilesToMenu(arg2);
9831 wxPyEndAllowThreads(__tstate);
9832 if (PyErr_Occurred()) SWIG_fail;
9833 }
9834 resultobj = SWIG_Py_Void();
9835 return resultobj;
9836 fail:
9837 return NULL;
9838 }
9839
9840
9841 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9842 PyObject *resultobj = 0;
9843 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9844 int arg2 ;
9845 wxString result;
9846 void *argp1 = 0 ;
9847 int res1 = 0 ;
9848 int val2 ;
9849 int ecode2 = 0 ;
9850 PyObject * obj0 = 0 ;
9851 PyObject * obj1 = 0 ;
9852 char * kwnames[] = {
9853 (char *) "self",(char *) "i", NULL
9854 };
9855
9856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9858 if (!SWIG_IsOK(res1)) {
9859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9860 }
9861 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9862 ecode2 = SWIG_AsVal_int(obj1, &val2);
9863 if (!SWIG_IsOK(ecode2)) {
9864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9865 }
9866 arg2 = static_cast< int >(val2);
9867 {
9868 PyThreadState* __tstate = wxPyBeginAllowThreads();
9869 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 {
9874 #if wxUSE_UNICODE
9875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9876 #else
9877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9878 #endif
9879 }
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9887 PyObject *resultobj = 0;
9888 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9889 int result;
9890 void *argp1 = 0 ;
9891 int res1 = 0 ;
9892 PyObject *swig_obj[1] ;
9893
9894 if (!args) SWIG_fail;
9895 swig_obj[0] = args;
9896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9897 if (!SWIG_IsOK(res1)) {
9898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9899 }
9900 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 result = (int)((wxFileHistory const *)arg1)->GetCount();
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 resultobj = SWIG_From_int(static_cast< int >(result));
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9915 PyObject *obj;
9916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9917 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9918 return SWIG_Py_Void();
9919 }
9920
9921 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9922 return SWIG_Python_InitShadowInstance(args);
9923 }
9924
9925 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj = 0;
9927 wxString *arg1 = 0 ;
9928 wxString const &arg2_defvalue = wxPyEmptyString ;
9929 wxString *arg2 = (wxString *) &arg2_defvalue ;
9930 wxSingleInstanceChecker *result = 0 ;
9931 bool temp1 = false ;
9932 bool temp2 = false ;
9933 PyObject * obj0 = 0 ;
9934 PyObject * obj1 = 0 ;
9935 char * kwnames[] = {
9936 (char *) "name",(char *) "path", NULL
9937 };
9938
9939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9940 {
9941 arg1 = wxString_in_helper(obj0);
9942 if (arg1 == NULL) SWIG_fail;
9943 temp1 = true;
9944 }
9945 if (obj1) {
9946 {
9947 arg2 = wxString_in_helper(obj1);
9948 if (arg2 == NULL) SWIG_fail;
9949 temp2 = true;
9950 }
9951 }
9952 {
9953 PyThreadState* __tstate = wxPyBeginAllowThreads();
9954 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9955 wxPyEndAllowThreads(__tstate);
9956 if (PyErr_Occurred()) SWIG_fail;
9957 }
9958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9959 {
9960 if (temp1)
9961 delete arg1;
9962 }
9963 {
9964 if (temp2)
9965 delete arg2;
9966 }
9967 return resultobj;
9968 fail:
9969 {
9970 if (temp1)
9971 delete arg1;
9972 }
9973 {
9974 if (temp2)
9975 delete arg2;
9976 }
9977 return NULL;
9978 }
9979
9980
9981 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9982 PyObject *resultobj = 0;
9983 wxSingleInstanceChecker *result = 0 ;
9984
9985 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9986 {
9987 PyThreadState* __tstate = wxPyBeginAllowThreads();
9988 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9989 wxPyEndAllowThreads(__tstate);
9990 if (PyErr_Occurred()) SWIG_fail;
9991 }
9992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9993 return resultobj;
9994 fail:
9995 return NULL;
9996 }
9997
9998
9999 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10000 PyObject *resultobj = 0;
10001 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10002 void *argp1 = 0 ;
10003 int res1 = 0 ;
10004 PyObject *swig_obj[1] ;
10005
10006 if (!args) SWIG_fail;
10007 swig_obj[0] = args;
10008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10009 if (!SWIG_IsOK(res1)) {
10010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10011 }
10012 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 delete arg1;
10016
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_Py_Void();
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10028 PyObject *resultobj = 0;
10029 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10030 wxString *arg2 = 0 ;
10031 wxString const &arg3_defvalue = wxPyEmptyString ;
10032 wxString *arg3 = (wxString *) &arg3_defvalue ;
10033 bool result;
10034 void *argp1 = 0 ;
10035 int res1 = 0 ;
10036 bool temp2 = false ;
10037 bool temp3 = false ;
10038 PyObject * obj0 = 0 ;
10039 PyObject * obj1 = 0 ;
10040 PyObject * obj2 = 0 ;
10041 char * kwnames[] = {
10042 (char *) "self",(char *) "name",(char *) "path", NULL
10043 };
10044
10045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10047 if (!SWIG_IsOK(res1)) {
10048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10049 }
10050 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10051 {
10052 arg2 = wxString_in_helper(obj1);
10053 if (arg2 == NULL) SWIG_fail;
10054 temp2 = true;
10055 }
10056 if (obj2) {
10057 {
10058 arg3 = wxString_in_helper(obj2);
10059 if (arg3 == NULL) SWIG_fail;
10060 temp3 = true;
10061 }
10062 }
10063 {
10064 PyThreadState* __tstate = wxPyBeginAllowThreads();
10065 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10066 wxPyEndAllowThreads(__tstate);
10067 if (PyErr_Occurred()) SWIG_fail;
10068 }
10069 {
10070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10071 }
10072 {
10073 if (temp2)
10074 delete arg2;
10075 }
10076 {
10077 if (temp3)
10078 delete arg3;
10079 }
10080 return resultobj;
10081 fail:
10082 {
10083 if (temp2)
10084 delete arg2;
10085 }
10086 {
10087 if (temp3)
10088 delete arg3;
10089 }
10090 return NULL;
10091 }
10092
10093
10094 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10095 PyObject *resultobj = 0;
10096 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10097 bool result;
10098 void *argp1 = 0 ;
10099 int res1 = 0 ;
10100 PyObject *swig_obj[1] ;
10101
10102 if (!args) SWIG_fail;
10103 swig_obj[0] = args;
10104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10105 if (!SWIG_IsOK(res1)) {
10106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10107 }
10108 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10109 {
10110 PyThreadState* __tstate = wxPyBeginAllowThreads();
10111 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 {
10116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10117 }
10118 return resultobj;
10119 fail:
10120 return NULL;
10121 }
10122
10123
10124 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10125 PyObject *obj;
10126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10127 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10128 return SWIG_Py_Void();
10129 }
10130
10131 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10132 return SWIG_Python_InitShadowInstance(args);
10133 }
10134
10135 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10136 PyObject *resultobj = 0;
10137 wxPlatformInfo *result = 0 ;
10138
10139 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10140 {
10141 PyThreadState* __tstate = wxPyBeginAllowThreads();
10142 result = (wxPlatformInfo *)new wxPlatformInfo();
10143 wxPyEndAllowThreads(__tstate);
10144 if (PyErr_Occurred()) SWIG_fail;
10145 }
10146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10147 return resultobj;
10148 fail:
10149 return NULL;
10150 }
10151
10152
10153 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj = 0;
10155 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10156 wxPlatformInfo *arg2 = 0 ;
10157 bool result;
10158 void *argp1 = 0 ;
10159 int res1 = 0 ;
10160 void *argp2 = 0 ;
10161 int res2 = 0 ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 char * kwnames[] = {
10165 (char *) "self",(char *) "t", NULL
10166 };
10167
10168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10170 if (!SWIG_IsOK(res1)) {
10171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10172 }
10173 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10175 if (!SWIG_IsOK(res2)) {
10176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10177 }
10178 if (!argp2) {
10179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10180 }
10181 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10182 {
10183 PyThreadState* __tstate = wxPyBeginAllowThreads();
10184 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10185 wxPyEndAllowThreads(__tstate);
10186 if (PyErr_Occurred()) SWIG_fail;
10187 }
10188 {
10189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10190 }
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10200 wxPlatformInfo *arg2 = 0 ;
10201 bool result;
10202 void *argp1 = 0 ;
10203 int res1 = 0 ;
10204 void *argp2 = 0 ;
10205 int res2 = 0 ;
10206 PyObject * obj0 = 0 ;
10207 PyObject * obj1 = 0 ;
10208 char * kwnames[] = {
10209 (char *) "self",(char *) "t", NULL
10210 };
10211
10212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10214 if (!SWIG_IsOK(res1)) {
10215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10216 }
10217 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10218 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10219 if (!SWIG_IsOK(res2)) {
10220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10221 }
10222 if (!argp2) {
10223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10224 }
10225 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10229 wxPyEndAllowThreads(__tstate);
10230 if (PyErr_Occurred()) SWIG_fail;
10231 }
10232 {
10233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10234 }
10235 return resultobj;
10236 fail:
10237 return NULL;
10238 }
10239
10240
10241 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10242 PyObject *resultobj = 0;
10243 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10244 int result;
10245 void *argp1 = 0 ;
10246 int res1 = 0 ;
10247 PyObject *swig_obj[1] ;
10248
10249 if (!args) SWIG_fail;
10250 swig_obj[0] = args;
10251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10252 if (!SWIG_IsOK(res1)) {
10253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10254 }
10255 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10256 {
10257 PyThreadState* __tstate = wxPyBeginAllowThreads();
10258 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10259 wxPyEndAllowThreads(__tstate);
10260 if (PyErr_Occurred()) SWIG_fail;
10261 }
10262 resultobj = SWIG_From_int(static_cast< int >(result));
10263 return resultobj;
10264 fail:
10265 return NULL;
10266 }
10267
10268
10269 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10270 PyObject *resultobj = 0;
10271 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10272 int result;
10273 void *argp1 = 0 ;
10274 int res1 = 0 ;
10275 PyObject *swig_obj[1] ;
10276
10277 if (!args) SWIG_fail;
10278 swig_obj[0] = args;
10279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10280 if (!SWIG_IsOK(res1)) {
10281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10282 }
10283 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10284 {
10285 PyThreadState* __tstate = wxPyBeginAllowThreads();
10286 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10287 wxPyEndAllowThreads(__tstate);
10288 if (PyErr_Occurred()) SWIG_fail;
10289 }
10290 resultobj = SWIG_From_int(static_cast< int >(result));
10291 return resultobj;
10292 fail:
10293 return NULL;
10294 }
10295
10296
10297 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10298 PyObject *resultobj = 0;
10299 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10300 int arg2 ;
10301 int arg3 ;
10302 bool result;
10303 void *argp1 = 0 ;
10304 int res1 = 0 ;
10305 int val2 ;
10306 int ecode2 = 0 ;
10307 int val3 ;
10308 int ecode3 = 0 ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 PyObject * obj2 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "major",(char *) "minor", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10320 }
10321 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10322 ecode2 = SWIG_AsVal_int(obj1, &val2);
10323 if (!SWIG_IsOK(ecode2)) {
10324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10325 }
10326 arg2 = static_cast< int >(val2);
10327 ecode3 = SWIG_AsVal_int(obj2, &val3);
10328 if (!SWIG_IsOK(ecode3)) {
10329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10330 }
10331 arg3 = static_cast< int >(val3);
10332 {
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10335 wxPyEndAllowThreads(__tstate);
10336 if (PyErr_Occurred()) SWIG_fail;
10337 }
10338 {
10339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10340 }
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10348 PyObject *resultobj = 0;
10349 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10350 int result;
10351 void *argp1 = 0 ;
10352 int res1 = 0 ;
10353 PyObject *swig_obj[1] ;
10354
10355 if (!args) SWIG_fail;
10356 swig_obj[0] = args;
10357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10358 if (!SWIG_IsOK(res1)) {
10359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10360 }
10361 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10362 {
10363 PyThreadState* __tstate = wxPyBeginAllowThreads();
10364 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 resultobj = SWIG_From_int(static_cast< int >(result));
10369 return resultobj;
10370 fail:
10371 return NULL;
10372 }
10373
10374
10375 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10376 PyObject *resultobj = 0;
10377 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10378 int result;
10379 void *argp1 = 0 ;
10380 int res1 = 0 ;
10381 PyObject *swig_obj[1] ;
10382
10383 if (!args) SWIG_fail;
10384 swig_obj[0] = args;
10385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10386 if (!SWIG_IsOK(res1)) {
10387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10388 }
10389 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10390 {
10391 PyThreadState* __tstate = wxPyBeginAllowThreads();
10392 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10393 wxPyEndAllowThreads(__tstate);
10394 if (PyErr_Occurred()) SWIG_fail;
10395 }
10396 resultobj = SWIG_From_int(static_cast< int >(result));
10397 return resultobj;
10398 fail:
10399 return NULL;
10400 }
10401
10402
10403 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10404 PyObject *resultobj = 0;
10405 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10406 int arg2 ;
10407 int arg3 ;
10408 bool result;
10409 void *argp1 = 0 ;
10410 int res1 = 0 ;
10411 int val2 ;
10412 int ecode2 = 0 ;
10413 int val3 ;
10414 int ecode3 = 0 ;
10415 PyObject * obj0 = 0 ;
10416 PyObject * obj1 = 0 ;
10417 PyObject * obj2 = 0 ;
10418 char * kwnames[] = {
10419 (char *) "self",(char *) "major",(char *) "minor", NULL
10420 };
10421
10422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10424 if (!SWIG_IsOK(res1)) {
10425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10426 }
10427 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10428 ecode2 = SWIG_AsVal_int(obj1, &val2);
10429 if (!SWIG_IsOK(ecode2)) {
10430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10431 }
10432 arg2 = static_cast< int >(val2);
10433 ecode3 = SWIG_AsVal_int(obj2, &val3);
10434 if (!SWIG_IsOK(ecode3)) {
10435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10436 }
10437 arg3 = static_cast< int >(val3);
10438 {
10439 PyThreadState* __tstate = wxPyBeginAllowThreads();
10440 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10441 wxPyEndAllowThreads(__tstate);
10442 if (PyErr_Occurred()) SWIG_fail;
10443 }
10444 {
10445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10446 }
10447 return resultobj;
10448 fail:
10449 return NULL;
10450 }
10451
10452
10453 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10454 PyObject *resultobj = 0;
10455 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10456 bool result;
10457 void *argp1 = 0 ;
10458 int res1 = 0 ;
10459 PyObject *swig_obj[1] ;
10460
10461 if (!args) SWIG_fail;
10462 swig_obj[0] = args;
10463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10464 if (!SWIG_IsOK(res1)) {
10465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10466 }
10467 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10468 {
10469 PyThreadState* __tstate = wxPyBeginAllowThreads();
10470 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10471 wxPyEndAllowThreads(__tstate);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 {
10475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10476 }
10477 return resultobj;
10478 fail:
10479 return NULL;
10480 }
10481
10482
10483 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10484 PyObject *resultobj = 0;
10485 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10486 wxOperatingSystemId result;
10487 void *argp1 = 0 ;
10488 int res1 = 0 ;
10489 PyObject *swig_obj[1] ;
10490
10491 if (!args) SWIG_fail;
10492 swig_obj[0] = args;
10493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10496 }
10497 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10498 {
10499 PyThreadState* __tstate = wxPyBeginAllowThreads();
10500 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10501 wxPyEndAllowThreads(__tstate);
10502 if (PyErr_Occurred()) SWIG_fail;
10503 }
10504 resultobj = SWIG_From_int(static_cast< int >(result));
10505 return resultobj;
10506 fail:
10507 return NULL;
10508 }
10509
10510
10511 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10512 PyObject *resultobj = 0;
10513 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10514 wxPortId result;
10515 void *argp1 = 0 ;
10516 int res1 = 0 ;
10517 PyObject *swig_obj[1] ;
10518
10519 if (!args) SWIG_fail;
10520 swig_obj[0] = args;
10521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10522 if (!SWIG_IsOK(res1)) {
10523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10524 }
10525 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 resultobj = SWIG_From_int(static_cast< int >(result));
10533 return resultobj;
10534 fail:
10535 return NULL;
10536 }
10537
10538
10539 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10540 PyObject *resultobj = 0;
10541 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10542 wxArchitecture result;
10543 void *argp1 = 0 ;
10544 int res1 = 0 ;
10545 PyObject *swig_obj[1] ;
10546
10547 if (!args) SWIG_fail;
10548 swig_obj[0] = args;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10552 }
10553 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 resultobj = SWIG_From_int(static_cast< int >(result));
10561 return resultobj;
10562 fail:
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *resultobj = 0;
10569 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10570 wxEndianness result;
10571 void *argp1 = 0 ;
10572 int res1 = 0 ;
10573 PyObject *swig_obj[1] ;
10574
10575 if (!args) SWIG_fail;
10576 swig_obj[0] = args;
10577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10578 if (!SWIG_IsOK(res1)) {
10579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10580 }
10581 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 resultobj = SWIG_From_int(static_cast< int >(result));
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10596 PyObject *resultobj = 0;
10597 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10598 wxString result;
10599 void *argp1 = 0 ;
10600 int res1 = 0 ;
10601 PyObject *swig_obj[1] ;
10602
10603 if (!args) SWIG_fail;
10604 swig_obj[0] = args;
10605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10606 if (!SWIG_IsOK(res1)) {
10607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10608 }
10609 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10610 {
10611 PyThreadState* __tstate = wxPyBeginAllowThreads();
10612 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10613 wxPyEndAllowThreads(__tstate);
10614 if (PyErr_Occurred()) SWIG_fail;
10615 }
10616 {
10617 #if wxUSE_UNICODE
10618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10619 #else
10620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10621 #endif
10622 }
10623 return resultobj;
10624 fail:
10625 return NULL;
10626 }
10627
10628
10629 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10630 PyObject *resultobj = 0;
10631 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10632 wxString result;
10633 void *argp1 = 0 ;
10634 int res1 = 0 ;
10635 PyObject *swig_obj[1] ;
10636
10637 if (!args) SWIG_fail;
10638 swig_obj[0] = args;
10639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10640 if (!SWIG_IsOK(res1)) {
10641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10642 }
10643 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10644 {
10645 PyThreadState* __tstate = wxPyBeginAllowThreads();
10646 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10647 wxPyEndAllowThreads(__tstate);
10648 if (PyErr_Occurred()) SWIG_fail;
10649 }
10650 {
10651 #if wxUSE_UNICODE
10652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10653 #else
10654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10655 #endif
10656 }
10657 return resultobj;
10658 fail:
10659 return NULL;
10660 }
10661
10662
10663 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10664 PyObject *resultobj = 0;
10665 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10666 wxString result;
10667 void *argp1 = 0 ;
10668 int res1 = 0 ;
10669 PyObject *swig_obj[1] ;
10670
10671 if (!args) SWIG_fail;
10672 swig_obj[0] = args;
10673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10676 }
10677 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10678 {
10679 PyThreadState* __tstate = wxPyBeginAllowThreads();
10680 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10681 wxPyEndAllowThreads(__tstate);
10682 if (PyErr_Occurred()) SWIG_fail;
10683 }
10684 {
10685 #if wxUSE_UNICODE
10686 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10687 #else
10688 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10689 #endif
10690 }
10691 return resultobj;
10692 fail:
10693 return NULL;
10694 }
10695
10696
10697 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10698 PyObject *resultobj = 0;
10699 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10700 wxString result;
10701 void *argp1 = 0 ;
10702 int res1 = 0 ;
10703 PyObject *swig_obj[1] ;
10704
10705 if (!args) SWIG_fail;
10706 swig_obj[0] = args;
10707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10708 if (!SWIG_IsOK(res1)) {
10709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10710 }
10711 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 {
10719 #if wxUSE_UNICODE
10720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10721 #else
10722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10723 #endif
10724 }
10725 return resultobj;
10726 fail:
10727 return NULL;
10728 }
10729
10730
10731 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10732 PyObject *resultobj = 0;
10733 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10734 wxString result;
10735 void *argp1 = 0 ;
10736 int res1 = 0 ;
10737 PyObject *swig_obj[1] ;
10738
10739 if (!args) SWIG_fail;
10740 swig_obj[0] = args;
10741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10742 if (!SWIG_IsOK(res1)) {
10743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10744 }
10745 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10746 {
10747 PyThreadState* __tstate = wxPyBeginAllowThreads();
10748 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10749 wxPyEndAllowThreads(__tstate);
10750 if (PyErr_Occurred()) SWIG_fail;
10751 }
10752 {
10753 #if wxUSE_UNICODE
10754 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10755 #else
10756 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10757 #endif
10758 }
10759 return resultobj;
10760 fail:
10761 return NULL;
10762 }
10763
10764
10765 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10766 PyObject *resultobj = 0;
10767 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10768 wxString result;
10769 void *argp1 = 0 ;
10770 int res1 = 0 ;
10771 PyObject *swig_obj[1] ;
10772
10773 if (!args) SWIG_fail;
10774 swig_obj[0] = args;
10775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10776 if (!SWIG_IsOK(res1)) {
10777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10778 }
10779 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10780 {
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10783 wxPyEndAllowThreads(__tstate);
10784 if (PyErr_Occurred()) SWIG_fail;
10785 }
10786 {
10787 #if wxUSE_UNICODE
10788 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10789 #else
10790 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10791 #endif
10792 }
10793 return resultobj;
10794 fail:
10795 return NULL;
10796 }
10797
10798
10799 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10800 PyObject *resultobj = 0;
10801 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10802 int arg2 ;
10803 int arg3 ;
10804 void *argp1 = 0 ;
10805 int res1 = 0 ;
10806 int val2 ;
10807 int ecode2 = 0 ;
10808 int val3 ;
10809 int ecode3 = 0 ;
10810 PyObject * obj0 = 0 ;
10811 PyObject * obj1 = 0 ;
10812 PyObject * obj2 = 0 ;
10813 char * kwnames[] = {
10814 (char *) "self",(char *) "major",(char *) "minor", NULL
10815 };
10816
10817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10819 if (!SWIG_IsOK(res1)) {
10820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10821 }
10822 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10823 ecode2 = SWIG_AsVal_int(obj1, &val2);
10824 if (!SWIG_IsOK(ecode2)) {
10825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10826 }
10827 arg2 = static_cast< int >(val2);
10828 ecode3 = SWIG_AsVal_int(obj2, &val3);
10829 if (!SWIG_IsOK(ecode3)) {
10830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10831 }
10832 arg3 = static_cast< int >(val3);
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 (arg1)->SetOSVersion(arg2,arg3);
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 resultobj = SWIG_Py_Void();
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj = 0;
10848 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10849 int arg2 ;
10850 int arg3 ;
10851 void *argp1 = 0 ;
10852 int res1 = 0 ;
10853 int val2 ;
10854 int ecode2 = 0 ;
10855 int val3 ;
10856 int ecode3 = 0 ;
10857 PyObject * obj0 = 0 ;
10858 PyObject * obj1 = 0 ;
10859 PyObject * obj2 = 0 ;
10860 char * kwnames[] = {
10861 (char *) "self",(char *) "major",(char *) "minor", NULL
10862 };
10863
10864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10866 if (!SWIG_IsOK(res1)) {
10867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10868 }
10869 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10870 ecode2 = SWIG_AsVal_int(obj1, &val2);
10871 if (!SWIG_IsOK(ecode2)) {
10872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10873 }
10874 arg2 = static_cast< int >(val2);
10875 ecode3 = SWIG_AsVal_int(obj2, &val3);
10876 if (!SWIG_IsOK(ecode3)) {
10877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10878 }
10879 arg3 = static_cast< int >(val3);
10880 {
10881 PyThreadState* __tstate = wxPyBeginAllowThreads();
10882 (arg1)->SetToolkitVersion(arg2,arg3);
10883 wxPyEndAllowThreads(__tstate);
10884 if (PyErr_Occurred()) SWIG_fail;
10885 }
10886 resultobj = SWIG_Py_Void();
10887 return resultobj;
10888 fail:
10889 return NULL;
10890 }
10891
10892
10893 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10894 PyObject *resultobj = 0;
10895 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10896 wxOperatingSystemId arg2 ;
10897 void *argp1 = 0 ;
10898 int res1 = 0 ;
10899 int val2 ;
10900 int ecode2 = 0 ;
10901 PyObject * obj0 = 0 ;
10902 PyObject * obj1 = 0 ;
10903 char * kwnames[] = {
10904 (char *) "self",(char *) "n", NULL
10905 };
10906
10907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10909 if (!SWIG_IsOK(res1)) {
10910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10911 }
10912 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10913 ecode2 = SWIG_AsVal_int(obj1, &val2);
10914 if (!SWIG_IsOK(ecode2)) {
10915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10916 }
10917 arg2 = static_cast< wxOperatingSystemId >(val2);
10918 {
10919 PyThreadState* __tstate = wxPyBeginAllowThreads();
10920 (arg1)->SetOperatingSystemId(arg2);
10921 wxPyEndAllowThreads(__tstate);
10922 if (PyErr_Occurred()) SWIG_fail;
10923 }
10924 resultobj = SWIG_Py_Void();
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10932 PyObject *resultobj = 0;
10933 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10934 wxPortId arg2 ;
10935 void *argp1 = 0 ;
10936 int res1 = 0 ;
10937 int val2 ;
10938 int ecode2 = 0 ;
10939 PyObject * obj0 = 0 ;
10940 PyObject * obj1 = 0 ;
10941 char * kwnames[] = {
10942 (char *) "self",(char *) "n", NULL
10943 };
10944
10945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10947 if (!SWIG_IsOK(res1)) {
10948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10949 }
10950 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10951 ecode2 = SWIG_AsVal_int(obj1, &val2);
10952 if (!SWIG_IsOK(ecode2)) {
10953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10954 }
10955 arg2 = static_cast< wxPortId >(val2);
10956 {
10957 PyThreadState* __tstate = wxPyBeginAllowThreads();
10958 (arg1)->SetPortId(arg2);
10959 wxPyEndAllowThreads(__tstate);
10960 if (PyErr_Occurred()) SWIG_fail;
10961 }
10962 resultobj = SWIG_Py_Void();
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj = 0;
10971 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10972 wxArchitecture arg2 ;
10973 void *argp1 = 0 ;
10974 int res1 = 0 ;
10975 int val2 ;
10976 int ecode2 = 0 ;
10977 PyObject * obj0 = 0 ;
10978 PyObject * obj1 = 0 ;
10979 char * kwnames[] = {
10980 (char *) "self",(char *) "n", NULL
10981 };
10982
10983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10985 if (!SWIG_IsOK(res1)) {
10986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10987 }
10988 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10989 ecode2 = SWIG_AsVal_int(obj1, &val2);
10990 if (!SWIG_IsOK(ecode2)) {
10991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10992 }
10993 arg2 = static_cast< wxArchitecture >(val2);
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 (arg1)->SetArchitecture(arg2);
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 resultobj = SWIG_Py_Void();
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj = 0;
11009 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11010 wxEndianness arg2 ;
11011 void *argp1 = 0 ;
11012 int res1 = 0 ;
11013 int val2 ;
11014 int ecode2 = 0 ;
11015 PyObject * obj0 = 0 ;
11016 PyObject * obj1 = 0 ;
11017 char * kwnames[] = {
11018 (char *) "self",(char *) "n", NULL
11019 };
11020
11021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11023 if (!SWIG_IsOK(res1)) {
11024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11025 }
11026 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11027 ecode2 = SWIG_AsVal_int(obj1, &val2);
11028 if (!SWIG_IsOK(ecode2)) {
11029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11030 }
11031 arg2 = static_cast< wxEndianness >(val2);
11032 {
11033 PyThreadState* __tstate = wxPyBeginAllowThreads();
11034 (arg1)->SetEndianness(arg2);
11035 wxPyEndAllowThreads(__tstate);
11036 if (PyErr_Occurred()) SWIG_fail;
11037 }
11038 resultobj = SWIG_Py_Void();
11039 return resultobj;
11040 fail:
11041 return NULL;
11042 }
11043
11044
11045 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11046 PyObject *resultobj = 0;
11047 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11048 bool result;
11049 void *argp1 = 0 ;
11050 int res1 = 0 ;
11051 PyObject *swig_obj[1] ;
11052
11053 if (!args) SWIG_fail;
11054 swig_obj[0] = args;
11055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11056 if (!SWIG_IsOK(res1)) {
11057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11058 }
11059 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11060 {
11061 PyThreadState* __tstate = wxPyBeginAllowThreads();
11062 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11063 wxPyEndAllowThreads(__tstate);
11064 if (PyErr_Occurred()) SWIG_fail;
11065 }
11066 {
11067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11068 }
11069 return resultobj;
11070 fail:
11071 return NULL;
11072 }
11073
11074
11075 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11076 PyObject *obj;
11077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11079 return SWIG_Py_Void();
11080 }
11081
11082 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11083 return SWIG_Python_InitShadowInstance(args);
11084 }
11085
11086 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11087 PyObject *resultobj = 0;
11088 wxWindow *arg1 = (wxWindow *) 0 ;
11089 wxDC *arg2 = 0 ;
11090 bool result;
11091 void *argp1 = 0 ;
11092 int res1 = 0 ;
11093 void *argp2 = 0 ;
11094 int res2 = 0 ;
11095 PyObject * obj0 = 0 ;
11096 PyObject * obj1 = 0 ;
11097 char * kwnames[] = {
11098 (char *) "window",(char *) "dc", NULL
11099 };
11100
11101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11103 if (!SWIG_IsOK(res1)) {
11104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11105 }
11106 arg1 = reinterpret_cast< wxWindow * >(argp1);
11107 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11108 if (!SWIG_IsOK(res2)) {
11109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11110 }
11111 if (!argp2) {
11112 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11113 }
11114 arg2 = reinterpret_cast< wxDC * >(argp2);
11115 {
11116 PyThreadState* __tstate = wxPyBeginAllowThreads();
11117 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11118 wxPyEndAllowThreads(__tstate);
11119 if (PyErr_Occurred()) SWIG_fail;
11120 }
11121 {
11122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11123 }
11124 return resultobj;
11125 fail:
11126 return NULL;
11127 }
11128
11129
11130 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11131 PyObject *resultobj = 0;
11132 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11133 void *argp1 = 0 ;
11134 int res1 = 0 ;
11135 PyObject *swig_obj[1] ;
11136
11137 if (!args) SWIG_fail;
11138 swig_obj[0] = args;
11139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11140 if (!SWIG_IsOK(res1)) {
11141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11142 }
11143 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 delete arg1;
11147
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 resultobj = SWIG_Py_Void();
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11159 PyObject *resultobj = 0;
11160 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11161 wxString result;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 PyObject *swig_obj[1] ;
11165
11166 if (!args) SWIG_fail;
11167 swig_obj[0] = args;
11168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11169 if (!SWIG_IsOK(res1)) {
11170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11171 }
11172 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11173 {
11174 PyThreadState* __tstate = wxPyBeginAllowThreads();
11175 result = (arg1)->GetTip();
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 {
11180 #if wxUSE_UNICODE
11181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11182 #else
11183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11184 #endif
11185 }
11186 return resultobj;
11187 fail:
11188 return NULL;
11189 }
11190
11191
11192 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11193 PyObject *resultobj = 0;
11194 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11195 size_t result;
11196 void *argp1 = 0 ;
11197 int res1 = 0 ;
11198 PyObject *swig_obj[1] ;
11199
11200 if (!args) SWIG_fail;
11201 swig_obj[0] = args;
11202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11203 if (!SWIG_IsOK(res1)) {
11204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11205 }
11206 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11207 {
11208 PyThreadState* __tstate = wxPyBeginAllowThreads();
11209 result = (size_t)(arg1)->GetCurrentTip();
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj = 0;
11222 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11223 wxString *arg2 = 0 ;
11224 wxString result;
11225 void *argp1 = 0 ;
11226 int res1 = 0 ;
11227 bool temp2 = false ;
11228 PyObject * obj0 = 0 ;
11229 PyObject * obj1 = 0 ;
11230 char * kwnames[] = {
11231 (char *) "self",(char *) "tip", NULL
11232 };
11233
11234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11236 if (!SWIG_IsOK(res1)) {
11237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11238 }
11239 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11240 {
11241 arg2 = wxString_in_helper(obj1);
11242 if (arg2 == NULL) SWIG_fail;
11243 temp2 = true;
11244 }
11245 {
11246 PyThreadState* __tstate = wxPyBeginAllowThreads();
11247 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11248 wxPyEndAllowThreads(__tstate);
11249 if (PyErr_Occurred()) SWIG_fail;
11250 }
11251 {
11252 #if wxUSE_UNICODE
11253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11254 #else
11255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11256 #endif
11257 }
11258 {
11259 if (temp2)
11260 delete arg2;
11261 }
11262 return resultobj;
11263 fail:
11264 {
11265 if (temp2)
11266 delete arg2;
11267 }
11268 return NULL;
11269 }
11270
11271
11272 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11273 PyObject *obj;
11274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11275 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11276 return SWIG_Py_Void();
11277 }
11278
11279 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11280 PyObject *resultobj = 0;
11281 size_t arg1 ;
11282 wxPyTipProvider *result = 0 ;
11283 size_t val1 ;
11284 int ecode1 = 0 ;
11285 PyObject * obj0 = 0 ;
11286 char * kwnames[] = {
11287 (char *) "currentTip", NULL
11288 };
11289
11290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11291 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11292 if (!SWIG_IsOK(ecode1)) {
11293 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11294 }
11295 arg1 = static_cast< size_t >(val1);
11296 {
11297 PyThreadState* __tstate = wxPyBeginAllowThreads();
11298 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj = 0;
11311 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11312 PyObject *arg2 = (PyObject *) 0 ;
11313 PyObject *arg3 = (PyObject *) 0 ;
11314 void *argp1 = 0 ;
11315 int res1 = 0 ;
11316 PyObject * obj0 = 0 ;
11317 PyObject * obj1 = 0 ;
11318 PyObject * obj2 = 0 ;
11319 char * kwnames[] = {
11320 (char *) "self",(char *) "self",(char *) "_class", NULL
11321 };
11322
11323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11325 if (!SWIG_IsOK(res1)) {
11326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11327 }
11328 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11329 arg2 = obj1;
11330 arg3 = obj2;
11331 {
11332 PyThreadState* __tstate = wxPyBeginAllowThreads();
11333 (arg1)->_setCallbackInfo(arg2,arg3);
11334 wxPyEndAllowThreads(__tstate);
11335 if (PyErr_Occurred()) SWIG_fail;
11336 }
11337 resultobj = SWIG_Py_Void();
11338 return resultobj;
11339 fail:
11340 return NULL;
11341 }
11342
11343
11344 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11345 PyObject *obj;
11346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11347 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11348 return SWIG_Py_Void();
11349 }
11350
11351 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11352 return SWIG_Python_InitShadowInstance(args);
11353 }
11354
11355 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj = 0;
11357 wxWindow *arg1 = (wxWindow *) 0 ;
11358 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11359 bool arg3 = (bool) true ;
11360 bool result;
11361 void *argp1 = 0 ;
11362 int res1 = 0 ;
11363 void *argp2 = 0 ;
11364 int res2 = 0 ;
11365 bool val3 ;
11366 int ecode3 = 0 ;
11367 PyObject * obj0 = 0 ;
11368 PyObject * obj1 = 0 ;
11369 PyObject * obj2 = 0 ;
11370 char * kwnames[] = {
11371 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11372 };
11373
11374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11376 if (!SWIG_IsOK(res1)) {
11377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11378 }
11379 arg1 = reinterpret_cast< wxWindow * >(argp1);
11380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11381 if (!SWIG_IsOK(res2)) {
11382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11383 }
11384 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11385 if (obj2) {
11386 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11387 if (!SWIG_IsOK(ecode3)) {
11388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11389 }
11390 arg3 = static_cast< bool >(val3);
11391 }
11392 {
11393 if (!wxPyCheckForApp()) SWIG_fail;
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (bool)wxShowTip(arg1,arg2,arg3);
11396 wxPyEndAllowThreads(__tstate);
11397 if (PyErr_Occurred()) SWIG_fail;
11398 }
11399 {
11400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11401 }
11402 return resultobj;
11403 fail:
11404 return NULL;
11405 }
11406
11407
11408 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11409 PyObject *resultobj = 0;
11410 wxString *arg1 = 0 ;
11411 size_t arg2 ;
11412 wxTipProvider *result = 0 ;
11413 bool temp1 = false ;
11414 size_t val2 ;
11415 int ecode2 = 0 ;
11416 PyObject * obj0 = 0 ;
11417 PyObject * obj1 = 0 ;
11418 char * kwnames[] = {
11419 (char *) "filename",(char *) "currentTip", NULL
11420 };
11421
11422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11423 {
11424 arg1 = wxString_in_helper(obj0);
11425 if (arg1 == NULL) SWIG_fail;
11426 temp1 = true;
11427 }
11428 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11429 if (!SWIG_IsOK(ecode2)) {
11430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11431 }
11432 arg2 = static_cast< size_t >(val2);
11433 {
11434 if (!wxPyCheckForApp()) SWIG_fail;
11435 PyThreadState* __tstate = wxPyBeginAllowThreads();
11436 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11437 wxPyEndAllowThreads(__tstate);
11438 if (PyErr_Occurred()) SWIG_fail;
11439 }
11440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11441 {
11442 if (temp1)
11443 delete arg1;
11444 }
11445 return resultobj;
11446 fail:
11447 {
11448 if (temp1)
11449 delete arg1;
11450 }
11451 return NULL;
11452 }
11453
11454
11455 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj = 0;
11457 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11458 int arg2 = (int) wxID_ANY ;
11459 wxPyTimer *result = 0 ;
11460 void *argp1 = 0 ;
11461 int res1 = 0 ;
11462 int val2 ;
11463 int ecode2 = 0 ;
11464 PyObject * obj0 = 0 ;
11465 PyObject * obj1 = 0 ;
11466 char * kwnames[] = {
11467 (char *) "owner",(char *) "id", NULL
11468 };
11469
11470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11471 if (obj0) {
11472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11473 if (!SWIG_IsOK(res1)) {
11474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11475 }
11476 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11477 }
11478 if (obj1) {
11479 ecode2 = SWIG_AsVal_int(obj1, &val2);
11480 if (!SWIG_IsOK(ecode2)) {
11481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11482 }
11483 arg2 = static_cast< int >(val2);
11484 }
11485 {
11486 if (!wxPyCheckForApp()) SWIG_fail;
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11500 PyObject *resultobj = 0;
11501 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11502 void *argp1 = 0 ;
11503 int res1 = 0 ;
11504 PyObject *swig_obj[1] ;
11505
11506 if (!args) SWIG_fail;
11507 swig_obj[0] = args;
11508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11509 if (!SWIG_IsOK(res1)) {
11510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11511 }
11512 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 delete arg1;
11516
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 resultobj = SWIG_Py_Void();
11521 return resultobj;
11522 fail:
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11528 PyObject *resultobj = 0;
11529 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11530 PyObject *arg2 = (PyObject *) 0 ;
11531 PyObject *arg3 = (PyObject *) 0 ;
11532 int arg4 = (int) 0 ;
11533 void *argp1 = 0 ;
11534 int res1 = 0 ;
11535 int val4 ;
11536 int ecode4 = 0 ;
11537 PyObject * obj0 = 0 ;
11538 PyObject * obj1 = 0 ;
11539 PyObject * obj2 = 0 ;
11540 PyObject * obj3 = 0 ;
11541 char * kwnames[] = {
11542 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11543 };
11544
11545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11547 if (!SWIG_IsOK(res1)) {
11548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11549 }
11550 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11551 arg2 = obj1;
11552 arg3 = obj2;
11553 if (obj3) {
11554 ecode4 = SWIG_AsVal_int(obj3, &val4);
11555 if (!SWIG_IsOK(ecode4)) {
11556 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11557 }
11558 arg4 = static_cast< int >(val4);
11559 }
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 resultobj = SWIG_Py_Void();
11567 return resultobj;
11568 fail:
11569 return NULL;
11570 }
11571
11572
11573 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11574 PyObject *resultobj = 0;
11575 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11576 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11577 int arg3 = (int) wxID_ANY ;
11578 void *argp1 = 0 ;
11579 int res1 = 0 ;
11580 void *argp2 = 0 ;
11581 int res2 = 0 ;
11582 int val3 ;
11583 int ecode3 = 0 ;
11584 PyObject * obj0 = 0 ;
11585 PyObject * obj1 = 0 ;
11586 PyObject * obj2 = 0 ;
11587 char * kwnames[] = {
11588 (char *) "self",(char *) "owner",(char *) "id", NULL
11589 };
11590
11591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11593 if (!SWIG_IsOK(res1)) {
11594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11595 }
11596 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11598 if (!SWIG_IsOK(res2)) {
11599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11600 }
11601 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11602 if (obj2) {
11603 ecode3 = SWIG_AsVal_int(obj2, &val3);
11604 if (!SWIG_IsOK(ecode3)) {
11605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11606 }
11607 arg3 = static_cast< int >(val3);
11608 }
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 (arg1)->SetOwner(arg2,arg3);
11612 wxPyEndAllowThreads(__tstate);
11613 if (PyErr_Occurred()) SWIG_fail;
11614 }
11615 resultobj = SWIG_Py_Void();
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11623 PyObject *resultobj = 0;
11624 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11625 wxEvtHandler *result = 0 ;
11626 void *argp1 = 0 ;
11627 int res1 = 0 ;
11628 PyObject *swig_obj[1] ;
11629
11630 if (!args) SWIG_fail;
11631 swig_obj[0] = args;
11632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11635 }
11636 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (wxEvtHandler *)(arg1)->GetOwner();
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 {
11644 resultobj = wxPyMake_wxObject(result, 0);
11645 }
11646 return resultobj;
11647 fail:
11648 return NULL;
11649 }
11650
11651
11652 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11653 PyObject *resultobj = 0;
11654 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11655 int arg2 = (int) -1 ;
11656 bool arg3 = (bool) false ;
11657 bool result;
11658 void *argp1 = 0 ;
11659 int res1 = 0 ;
11660 int val2 ;
11661 int ecode2 = 0 ;
11662 bool val3 ;
11663 int ecode3 = 0 ;
11664 PyObject * obj0 = 0 ;
11665 PyObject * obj1 = 0 ;
11666 PyObject * obj2 = 0 ;
11667 char * kwnames[] = {
11668 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11669 };
11670
11671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11673 if (!SWIG_IsOK(res1)) {
11674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11675 }
11676 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11677 if (obj1) {
11678 ecode2 = SWIG_AsVal_int(obj1, &val2);
11679 if (!SWIG_IsOK(ecode2)) {
11680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11681 }
11682 arg2 = static_cast< int >(val2);
11683 }
11684 if (obj2) {
11685 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11686 if (!SWIG_IsOK(ecode3)) {
11687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11688 }
11689 arg3 = static_cast< bool >(val3);
11690 }
11691 {
11692 PyThreadState* __tstate = wxPyBeginAllowThreads();
11693 result = (bool)(arg1)->Start(arg2,arg3);
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 {
11698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11699 }
11700 return resultobj;
11701 fail:
11702 return NULL;
11703 }
11704
11705
11706 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11707 PyObject *resultobj = 0;
11708 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11709 void *argp1 = 0 ;
11710 int res1 = 0 ;
11711 PyObject *swig_obj[1] ;
11712
11713 if (!args) SWIG_fail;
11714 swig_obj[0] = args;
11715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11716 if (!SWIG_IsOK(res1)) {
11717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11718 }
11719 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 (arg1)->Stop();
11723 wxPyEndAllowThreads(__tstate);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 resultobj = SWIG_Py_Void();
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11734 PyObject *resultobj = 0;
11735 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11736 void *argp1 = 0 ;
11737 int res1 = 0 ;
11738 PyObject *swig_obj[1] ;
11739
11740 if (!args) SWIG_fail;
11741 swig_obj[0] = args;
11742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11743 if (!SWIG_IsOK(res1)) {
11744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11745 }
11746 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 (arg1)->Notify();
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 resultobj = SWIG_Py_Void();
11754 return resultobj;
11755 fail:
11756 return NULL;
11757 }
11758
11759
11760 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11761 PyObject *resultobj = 0;
11762 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11763 bool result;
11764 void *argp1 = 0 ;
11765 int res1 = 0 ;
11766 PyObject *swig_obj[1] ;
11767
11768 if (!args) SWIG_fail;
11769 swig_obj[0] = args;
11770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11771 if (!SWIG_IsOK(res1)) {
11772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11773 }
11774 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 {
11782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11783 }
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11791 PyObject *resultobj = 0;
11792 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11793 int result;
11794 void *argp1 = 0 ;
11795 int res1 = 0 ;
11796 PyObject *swig_obj[1] ;
11797
11798 if (!args) SWIG_fail;
11799 swig_obj[0] = args;
11800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11801 if (!SWIG_IsOK(res1)) {
11802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11803 }
11804 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11808 wxPyEndAllowThreads(__tstate);
11809 if (PyErr_Occurred()) SWIG_fail;
11810 }
11811 resultobj = SWIG_From_int(static_cast< int >(result));
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11819 PyObject *resultobj = 0;
11820 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11821 int result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 PyObject *swig_obj[1] ;
11825
11826 if (!args) SWIG_fail;
11827 swig_obj[0] = args;
11828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11831 }
11832 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (int)((wxPyTimer const *)arg1)->GetId();
11836 wxPyEndAllowThreads(__tstate);
11837 if (PyErr_Occurred()) SWIG_fail;
11838 }
11839 resultobj = SWIG_From_int(static_cast< int >(result));
11840 return resultobj;
11841 fail:
11842 return NULL;
11843 }
11844
11845
11846 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11847 PyObject *resultobj = 0;
11848 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11849 bool result;
11850 void *argp1 = 0 ;
11851 int res1 = 0 ;
11852 PyObject *swig_obj[1] ;
11853
11854 if (!args) SWIG_fail;
11855 swig_obj[0] = args;
11856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11857 if (!SWIG_IsOK(res1)) {
11858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11859 }
11860 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11861 {
11862 PyThreadState* __tstate = wxPyBeginAllowThreads();
11863 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 {
11868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11869 }
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11877 PyObject *obj;
11878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11879 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11880 return SWIG_Py_Void();
11881 }
11882
11883 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11884 return SWIG_Python_InitShadowInstance(args);
11885 }
11886
11887 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj = 0;
11889 int arg1 = (int) 0 ;
11890 int arg2 = (int) 0 ;
11891 wxTimerEvent *result = 0 ;
11892 int val1 ;
11893 int ecode1 = 0 ;
11894 int val2 ;
11895 int ecode2 = 0 ;
11896 PyObject * obj0 = 0 ;
11897 PyObject * obj1 = 0 ;
11898 char * kwnames[] = {
11899 (char *) "timerid",(char *) "interval", NULL
11900 };
11901
11902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11903 if (obj0) {
11904 ecode1 = SWIG_AsVal_int(obj0, &val1);
11905 if (!SWIG_IsOK(ecode1)) {
11906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11907 }
11908 arg1 = static_cast< int >(val1);
11909 }
11910 if (obj1) {
11911 ecode2 = SWIG_AsVal_int(obj1, &val2);
11912 if (!SWIG_IsOK(ecode2)) {
11913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11914 }
11915 arg2 = static_cast< int >(val2);
11916 }
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11924 return resultobj;
11925 fail:
11926 return NULL;
11927 }
11928
11929
11930 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11931 PyObject *resultobj = 0;
11932 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11933 int result;
11934 void *argp1 = 0 ;
11935 int res1 = 0 ;
11936 PyObject *swig_obj[1] ;
11937
11938 if (!args) SWIG_fail;
11939 swig_obj[0] = args;
11940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11941 if (!SWIG_IsOK(res1)) {
11942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11943 }
11944 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 resultobj = SWIG_From_int(static_cast< int >(result));
11952 return resultobj;
11953 fail:
11954 return NULL;
11955 }
11956
11957
11958 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11959 PyObject *obj;
11960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11961 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11962 return SWIG_Py_Void();
11963 }
11964
11965 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11966 return SWIG_Python_InitShadowInstance(args);
11967 }
11968
11969 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11970 PyObject *resultobj = 0;
11971 wxTimer *arg1 = 0 ;
11972 wxTimerRunner *result = 0 ;
11973 void *argp1 = 0 ;
11974 int res1 = 0 ;
11975
11976 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11978 if (!SWIG_IsOK(res1)) {
11979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11980 }
11981 if (!argp1) {
11982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11983 }
11984 arg1 = reinterpret_cast< wxTimer * >(argp1);
11985 {
11986 if (!wxPyCheckForApp()) SWIG_fail;
11987 PyThreadState* __tstate = wxPyBeginAllowThreads();
11988 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11989 wxPyEndAllowThreads(__tstate);
11990 if (PyErr_Occurred()) SWIG_fail;
11991 }
11992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11993 return resultobj;
11994 fail:
11995 return NULL;
11996 }
11997
11998
11999 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12000 PyObject *resultobj = 0;
12001 wxTimer *arg1 = 0 ;
12002 int arg2 ;
12003 bool arg3 = (bool) false ;
12004 wxTimerRunner *result = 0 ;
12005 void *argp1 = 0 ;
12006 int res1 = 0 ;
12007 int val2 ;
12008 int ecode2 = 0 ;
12009 bool val3 ;
12010 int ecode3 = 0 ;
12011
12012 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12014 if (!SWIG_IsOK(res1)) {
12015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12016 }
12017 if (!argp1) {
12018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12019 }
12020 arg1 = reinterpret_cast< wxTimer * >(argp1);
12021 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12022 if (!SWIG_IsOK(ecode2)) {
12023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12024 }
12025 arg2 = static_cast< int >(val2);
12026 if (swig_obj[2]) {
12027 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12028 if (!SWIG_IsOK(ecode3)) {
12029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12030 }
12031 arg3 = static_cast< bool >(val3);
12032 }
12033 {
12034 if (!wxPyCheckForApp()) SWIG_fail;
12035 PyThreadState* __tstate = wxPyBeginAllowThreads();
12036 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12041 return resultobj;
12042 fail:
12043 return NULL;
12044 }
12045
12046
12047 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12048 int argc;
12049 PyObject *argv[4];
12050
12051 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12052 --argc;
12053 if (argc == 1) {
12054 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12055 }
12056 if ((argc >= 2) && (argc <= 3)) {
12057 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12058 }
12059
12060 fail:
12061 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12062 return NULL;
12063 }
12064
12065
12066 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12067 PyObject *resultobj = 0;
12068 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12069 void *argp1 = 0 ;
12070 int res1 = 0 ;
12071 PyObject *swig_obj[1] ;
12072
12073 if (!args) SWIG_fail;
12074 swig_obj[0] = args;
12075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12076 if (!SWIG_IsOK(res1)) {
12077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12078 }
12079 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12080 {
12081 PyThreadState* __tstate = wxPyBeginAllowThreads();
12082 delete arg1;
12083
12084 wxPyEndAllowThreads(__tstate);
12085 if (PyErr_Occurred()) SWIG_fail;
12086 }
12087 resultobj = SWIG_Py_Void();
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12095 PyObject *resultobj = 0;
12096 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12097 int arg2 ;
12098 bool arg3 = (bool) false ;
12099 void *argp1 = 0 ;
12100 int res1 = 0 ;
12101 int val2 ;
12102 int ecode2 = 0 ;
12103 bool val3 ;
12104 int ecode3 = 0 ;
12105 PyObject * obj0 = 0 ;
12106 PyObject * obj1 = 0 ;
12107 PyObject * obj2 = 0 ;
12108 char * kwnames[] = {
12109 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12110 };
12111
12112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12114 if (!SWIG_IsOK(res1)) {
12115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12116 }
12117 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12118 ecode2 = SWIG_AsVal_int(obj1, &val2);
12119 if (!SWIG_IsOK(ecode2)) {
12120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12121 }
12122 arg2 = static_cast< int >(val2);
12123 if (obj2) {
12124 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12125 if (!SWIG_IsOK(ecode3)) {
12126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12127 }
12128 arg3 = static_cast< bool >(val3);
12129 }
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 (arg1)->Start(arg2,arg3);
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 resultobj = SWIG_Py_Void();
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12144 PyObject *obj;
12145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12146 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12147 return SWIG_Py_Void();
12148 }
12149
12150 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12151 return SWIG_Python_InitShadowInstance(args);
12152 }
12153
12154 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12155 PyObject *resultobj = 0;
12156 wxLog *result = 0 ;
12157
12158 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (wxLog *)new wxLog();
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12173 PyObject *resultobj = 0;
12174 wxLog *arg1 = (wxLog *) 0 ;
12175 void *argp1 = 0 ;
12176 int res1 = 0 ;
12177 PyObject *swig_obj[1] ;
12178
12179 if (!args) SWIG_fail;
12180 swig_obj[0] = args;
12181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12182 if (!SWIG_IsOK(res1)) {
12183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12184 }
12185 arg1 = reinterpret_cast< wxLog * >(argp1);
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 delete arg1;
12189
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 resultobj = SWIG_Py_Void();
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201 PyObject *resultobj = 0;
12202 bool result;
12203
12204 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12205 {
12206 PyThreadState* __tstate = wxPyBeginAllowThreads();
12207 result = (bool)wxLog::IsEnabled();
12208 wxPyEndAllowThreads(__tstate);
12209 if (PyErr_Occurred()) SWIG_fail;
12210 }
12211 {
12212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12213 }
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12221 PyObject *resultobj = 0;
12222 bool arg1 = (bool) true ;
12223 bool result;
12224 bool val1 ;
12225 int ecode1 = 0 ;
12226 PyObject * obj0 = 0 ;
12227 char * kwnames[] = {
12228 (char *) "doIt", NULL
12229 };
12230
12231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12232 if (obj0) {
12233 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12234 if (!SWIG_IsOK(ecode1)) {
12235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12236 }
12237 arg1 = static_cast< bool >(val1);
12238 }
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 result = (bool)wxLog::EnableLogging(arg1);
12242 wxPyEndAllowThreads(__tstate);
12243 if (PyErr_Occurred()) SWIG_fail;
12244 }
12245 {
12246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12247 }
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12255 PyObject *resultobj = 0;
12256 wxLogLevel arg1 ;
12257 wxChar *arg2 = (wxChar *) 0 ;
12258 time_t arg3 ;
12259 unsigned long val1 ;
12260 int ecode1 = 0 ;
12261 void *argp2 = 0 ;
12262 int res2 = 0 ;
12263 unsigned int val3 ;
12264 int ecode3 = 0 ;
12265 PyObject * obj0 = 0 ;
12266 PyObject * obj1 = 0 ;
12267 PyObject * obj2 = 0 ;
12268 char * kwnames[] = {
12269 (char *) "level",(char *) "szString",(char *) "t", NULL
12270 };
12271
12272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12273 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12274 if (!SWIG_IsOK(ecode1)) {
12275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12276 }
12277 arg1 = static_cast< wxLogLevel >(val1);
12278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12279 if (!SWIG_IsOK(res2)) {
12280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12281 }
12282 arg2 = reinterpret_cast< wxChar * >(argp2);
12283 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12284 if (!SWIG_IsOK(ecode3)) {
12285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12286 }
12287 arg3 = static_cast< time_t >(val3);
12288 {
12289 PyThreadState* __tstate = wxPyBeginAllowThreads();
12290 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 resultobj = SWIG_Py_Void();
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12302 PyObject *resultobj = 0;
12303 wxLog *arg1 = (wxLog *) 0 ;
12304 void *argp1 = 0 ;
12305 int res1 = 0 ;
12306 PyObject *swig_obj[1] ;
12307
12308 if (!args) SWIG_fail;
12309 swig_obj[0] = args;
12310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12311 if (!SWIG_IsOK(res1)) {
12312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12313 }
12314 arg1 = reinterpret_cast< wxLog * >(argp1);
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 (arg1)->Flush();
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 resultobj = SWIG_Py_Void();
12322 return resultobj;
12323 fail:
12324 return NULL;
12325 }
12326
12327
12328 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12329 PyObject *resultobj = 0;
12330
12331 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 wxLog::FlushActive();
12335 wxPyEndAllowThreads(__tstate);
12336 if (PyErr_Occurred()) SWIG_fail;
12337 }
12338 resultobj = SWIG_Py_Void();
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12346 PyObject *resultobj = 0;
12347 wxLog *result = 0 ;
12348
12349 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 result = (wxLog *)wxLog::GetActiveTarget();
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12357 return resultobj;
12358 fail:
12359 return NULL;
12360 }
12361
12362
12363 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12364 PyObject *resultobj = 0;
12365 wxLog *arg1 = (wxLog *) 0 ;
12366 wxLog *result = 0 ;
12367 int res1 = 0 ;
12368 PyObject * obj0 = 0 ;
12369 char * kwnames[] = {
12370 (char *) "pLogger", NULL
12371 };
12372
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12377 }
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12385 return resultobj;
12386 fail:
12387 return NULL;
12388 }
12389
12390
12391 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12392 PyObject *resultobj = 0;
12393
12394 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12395 {
12396 PyThreadState* __tstate = wxPyBeginAllowThreads();
12397 wxLog::Suspend();
12398 wxPyEndAllowThreads(__tstate);
12399 if (PyErr_Occurred()) SWIG_fail;
12400 }
12401 resultobj = SWIG_Py_Void();
12402 return resultobj;
12403 fail:
12404 return NULL;
12405 }
12406
12407
12408 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12409 PyObject *resultobj = 0;
12410
12411 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12412 {
12413 PyThreadState* __tstate = wxPyBeginAllowThreads();
12414 wxLog::Resume();
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 resultobj = SWIG_Py_Void();
12419 return resultobj;
12420 fail:
12421 return NULL;
12422 }
12423
12424
12425 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12426 PyObject *resultobj = 0;
12427 bool arg1 = (bool) true ;
12428 bool val1 ;
12429 int ecode1 = 0 ;
12430 PyObject * obj0 = 0 ;
12431 char * kwnames[] = {
12432 (char *) "bVerbose", NULL
12433 };
12434
12435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12436 if (obj0) {
12437 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12438 if (!SWIG_IsOK(ecode1)) {
12439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12440 }
12441 arg1 = static_cast< bool >(val1);
12442 }
12443 {
12444 PyThreadState* __tstate = wxPyBeginAllowThreads();
12445 wxLog::SetVerbose(arg1);
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 resultobj = SWIG_Py_Void();
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj = 0;
12458 wxLogLevel arg1 ;
12459 unsigned long val1 ;
12460 int ecode1 = 0 ;
12461 PyObject * obj0 = 0 ;
12462 char * kwnames[] = {
12463 (char *) "logLevel", NULL
12464 };
12465
12466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12467 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12468 if (!SWIG_IsOK(ecode1)) {
12469 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12470 }
12471 arg1 = static_cast< wxLogLevel >(val1);
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 wxLog::SetLogLevel(arg1);
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 resultobj = SWIG_Py_Void();
12479 return resultobj;
12480 fail:
12481 return NULL;
12482 }
12483
12484
12485 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12486 PyObject *resultobj = 0;
12487
12488 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 wxLog::DontCreateOnDemand();
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 resultobj = SWIG_Py_Void();
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj = 0;
12504 bool arg1 = (bool) true ;
12505 bool val1 ;
12506 int ecode1 = 0 ;
12507 PyObject * obj0 = 0 ;
12508 char * kwnames[] = {
12509 (char *) "bRepetCounting", NULL
12510 };
12511
12512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12513 if (obj0) {
12514 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12515 if (!SWIG_IsOK(ecode1)) {
12516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12517 }
12518 arg1 = static_cast< bool >(val1);
12519 }
12520 {
12521 PyThreadState* __tstate = wxPyBeginAllowThreads();
12522 wxLog::SetRepetitionCounting(arg1);
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 resultobj = SWIG_Py_Void();
12527 return resultobj;
12528 fail:
12529 return NULL;
12530 }
12531
12532
12533 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12534 PyObject *resultobj = 0;
12535 bool result;
12536
12537 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 result = (bool)wxLog::GetRepetitionCounting();
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 {
12545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12546 }
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj = 0;
12555 wxTraceMask arg1 ;
12556 unsigned long val1 ;
12557 int ecode1 = 0 ;
12558 PyObject * obj0 = 0 ;
12559 char * kwnames[] = {
12560 (char *) "ulMask", NULL
12561 };
12562
12563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12564 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12565 if (!SWIG_IsOK(ecode1)) {
12566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12567 }
12568 arg1 = static_cast< wxTraceMask >(val1);
12569 {
12570 PyThreadState* __tstate = wxPyBeginAllowThreads();
12571 wxLog::SetTraceMask(arg1);
12572 wxPyEndAllowThreads(__tstate);
12573 if (PyErr_Occurred()) SWIG_fail;
12574 }
12575 resultobj = SWIG_Py_Void();
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj = 0;
12584 wxString *arg1 = 0 ;
12585 bool temp1 = false ;
12586 PyObject * obj0 = 0 ;
12587 char * kwnames[] = {
12588 (char *) "str", NULL
12589 };
12590
12591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12592 {
12593 arg1 = wxString_in_helper(obj0);
12594 if (arg1 == NULL) SWIG_fail;
12595 temp1 = true;
12596 }
12597 {
12598 PyThreadState* __tstate = wxPyBeginAllowThreads();
12599 wxLog::AddTraceMask((wxString const &)*arg1);
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 resultobj = SWIG_Py_Void();
12604 {
12605 if (temp1)
12606 delete arg1;
12607 }
12608 return resultobj;
12609 fail:
12610 {
12611 if (temp1)
12612 delete arg1;
12613 }
12614 return NULL;
12615 }
12616
12617
12618 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12619 PyObject *resultobj = 0;
12620 wxString *arg1 = 0 ;
12621 bool temp1 = false ;
12622 PyObject * obj0 = 0 ;
12623 char * kwnames[] = {
12624 (char *) "str", NULL
12625 };
12626
12627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12628 {
12629 arg1 = wxString_in_helper(obj0);
12630 if (arg1 == NULL) SWIG_fail;
12631 temp1 = true;
12632 }
12633 {
12634 PyThreadState* __tstate = wxPyBeginAllowThreads();
12635 wxLog::RemoveTraceMask((wxString const &)*arg1);
12636 wxPyEndAllowThreads(__tstate);
12637 if (PyErr_Occurred()) SWIG_fail;
12638 }
12639 resultobj = SWIG_Py_Void();
12640 {
12641 if (temp1)
12642 delete arg1;
12643 }
12644 return resultobj;
12645 fail:
12646 {
12647 if (temp1)
12648 delete arg1;
12649 }
12650 return NULL;
12651 }
12652
12653
12654 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12655 PyObject *resultobj = 0;
12656
12657 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12658 {
12659 PyThreadState* __tstate = wxPyBeginAllowThreads();
12660 wxLog::ClearTraceMasks();
12661 wxPyEndAllowThreads(__tstate);
12662 if (PyErr_Occurred()) SWIG_fail;
12663 }
12664 resultobj = SWIG_Py_Void();
12665 return resultobj;
12666 fail:
12667 return NULL;
12668 }
12669
12670
12671 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12672 PyObject *resultobj = 0;
12673 wxArrayString *result = 0 ;
12674
12675 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 {
12679 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12680 result = (wxArrayString *) &_result_ref;
12681 }
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 {
12686 resultobj = wxArrayString2PyList_helper(*result);
12687 }
12688 return resultobj;
12689 fail:
12690 return NULL;
12691 }
12692
12693
12694 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12695 PyObject *resultobj = 0;
12696 wxChar *arg1 = (wxChar *) 0 ;
12697 void *argp1 = 0 ;
12698 int res1 = 0 ;
12699 PyObject * obj0 = 0 ;
12700 char * kwnames[] = {
12701 (char *) "ts", NULL
12702 };
12703
12704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12706 if (!SWIG_IsOK(res1)) {
12707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12708 }
12709 arg1 = reinterpret_cast< wxChar * >(argp1);
12710 {
12711 PyThreadState* __tstate = wxPyBeginAllowThreads();
12712 wxLog::SetTimestamp((wxChar const *)arg1);
12713 wxPyEndAllowThreads(__tstate);
12714 if (PyErr_Occurred()) SWIG_fail;
12715 }
12716 resultobj = SWIG_Py_Void();
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 PyObject *resultobj = 0;
12725 bool result;
12726
12727 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12728 {
12729 PyThreadState* __tstate = wxPyBeginAllowThreads();
12730 result = (bool)wxLog::GetVerbose();
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 {
12735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12736 }
12737 return resultobj;
12738 fail:
12739 return NULL;
12740 }
12741
12742
12743 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12744 PyObject *resultobj = 0;
12745 wxTraceMask result;
12746
12747 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12748 {
12749 PyThreadState* __tstate = wxPyBeginAllowThreads();
12750 result = (wxTraceMask)wxLog::GetTraceMask();
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12755 return resultobj;
12756 fail:
12757 return NULL;
12758 }
12759
12760
12761 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12762 PyObject *resultobj = 0;
12763 wxChar *arg1 = (wxChar *) 0 ;
12764 bool result;
12765 void *argp1 = 0 ;
12766 int res1 = 0 ;
12767 PyObject * obj0 = 0 ;
12768 char * kwnames[] = {
12769 (char *) "mask", NULL
12770 };
12771
12772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12774 if (!SWIG_IsOK(res1)) {
12775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12776 }
12777 arg1 = reinterpret_cast< wxChar * >(argp1);
12778 {
12779 PyThreadState* __tstate = wxPyBeginAllowThreads();
12780 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12781 wxPyEndAllowThreads(__tstate);
12782 if (PyErr_Occurred()) SWIG_fail;
12783 }
12784 {
12785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12786 }
12787 return resultobj;
12788 fail:
12789 return NULL;
12790 }
12791
12792
12793 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12794 PyObject *resultobj = 0;
12795 wxLogLevel result;
12796
12797 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 result = (wxLogLevel)wxLog::GetLogLevel();
12801 wxPyEndAllowThreads(__tstate);
12802 if (PyErr_Occurred()) SWIG_fail;
12803 }
12804 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12812 PyObject *resultobj = 0;
12813 wxChar *result = 0 ;
12814
12815 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 result = (wxChar *)wxLog::GetTimestamp();
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12823 return resultobj;
12824 fail:
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12830 PyObject *resultobj = 0;
12831 wxString result;
12832
12833 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12834 {
12835 PyThreadState* __tstate = wxPyBeginAllowThreads();
12836 result = wxLog_TimeStamp();
12837 wxPyEndAllowThreads(__tstate);
12838 if (PyErr_Occurred()) SWIG_fail;
12839 }
12840 {
12841 #if wxUSE_UNICODE
12842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12843 #else
12844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12845 #endif
12846 }
12847 return resultobj;
12848 fail:
12849 return NULL;
12850 }
12851
12852
12853 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12854 PyObject *resultobj = 0;
12855 wxLog *arg1 = (wxLog *) 0 ;
12856 void *argp1 = 0 ;
12857 int res1 = 0 ;
12858 PyObject *swig_obj[1] ;
12859
12860 if (!args) SWIG_fail;
12861 swig_obj[0] = args;
12862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12863 if (!SWIG_IsOK(res1)) {
12864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12865 }
12866 arg1 = reinterpret_cast< wxLog * >(argp1);
12867 {
12868 PyThreadState* __tstate = wxPyBeginAllowThreads();
12869 wxLog_Destroy(arg1);
12870 wxPyEndAllowThreads(__tstate);
12871 if (PyErr_Occurred()) SWIG_fail;
12872 }
12873 resultobj = SWIG_Py_Void();
12874 return resultobj;
12875 fail:
12876 return NULL;
12877 }
12878
12879
12880 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12881 PyObject *obj;
12882 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12883 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12884 return SWIG_Py_Void();
12885 }
12886
12887 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12888 return SWIG_Python_InitShadowInstance(args);
12889 }
12890
12891 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12892 PyObject *resultobj = 0;
12893 wxLogStderr *result = 0 ;
12894
12895 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 result = (wxLogStderr *)new wxLogStderr();
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12903 return resultobj;
12904 fail:
12905 return NULL;
12906 }
12907
12908
12909 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12910 PyObject *obj;
12911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12912 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12913 return SWIG_Py_Void();
12914 }
12915
12916 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12917 return SWIG_Python_InitShadowInstance(args);
12918 }
12919
12920 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj = 0;
12922 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12923 wxLogTextCtrl *result = 0 ;
12924 void *argp1 = 0 ;
12925 int res1 = 0 ;
12926 PyObject * obj0 = 0 ;
12927 char * kwnames[] = {
12928 (char *) "pTextCtrl", NULL
12929 };
12930
12931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12933 if (!SWIG_IsOK(res1)) {
12934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12935 }
12936 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12937 {
12938 PyThreadState* __tstate = wxPyBeginAllowThreads();
12939 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12940 wxPyEndAllowThreads(__tstate);
12941 if (PyErr_Occurred()) SWIG_fail;
12942 }
12943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12951 PyObject *obj;
12952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12953 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12954 return SWIG_Py_Void();
12955 }
12956
12957 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12958 return SWIG_Python_InitShadowInstance(args);
12959 }
12960
12961 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12962 PyObject *resultobj = 0;
12963 wxLogGui *result = 0 ;
12964
12965 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 result = (wxLogGui *)new wxLogGui();
12969 wxPyEndAllowThreads(__tstate);
12970 if (PyErr_Occurred()) SWIG_fail;
12971 }
12972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12980 PyObject *obj;
12981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12982 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12983 return SWIG_Py_Void();
12984 }
12985
12986 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12987 return SWIG_Python_InitShadowInstance(args);
12988 }
12989
12990 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj = 0;
12992 wxFrame *arg1 = (wxFrame *) 0 ;
12993 wxString *arg2 = 0 ;
12994 bool arg3 = (bool) true ;
12995 bool arg4 = (bool) true ;
12996 wxLogWindow *result = 0 ;
12997 void *argp1 = 0 ;
12998 int res1 = 0 ;
12999 bool temp2 = false ;
13000 bool val3 ;
13001 int ecode3 = 0 ;
13002 bool val4 ;
13003 int ecode4 = 0 ;
13004 PyObject * obj0 = 0 ;
13005 PyObject * obj1 = 0 ;
13006 PyObject * obj2 = 0 ;
13007 PyObject * obj3 = 0 ;
13008 char * kwnames[] = {
13009 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13010 };
13011
13012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13014 if (!SWIG_IsOK(res1)) {
13015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13016 }
13017 arg1 = reinterpret_cast< wxFrame * >(argp1);
13018 {
13019 arg2 = wxString_in_helper(obj1);
13020 if (arg2 == NULL) SWIG_fail;
13021 temp2 = true;
13022 }
13023 if (obj2) {
13024 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13025 if (!SWIG_IsOK(ecode3)) {
13026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13027 }
13028 arg3 = static_cast< bool >(val3);
13029 }
13030 if (obj3) {
13031 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13032 if (!SWIG_IsOK(ecode4)) {
13033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13034 }
13035 arg4 = static_cast< bool >(val4);
13036 }
13037 {
13038 PyThreadState* __tstate = wxPyBeginAllowThreads();
13039 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13040 wxPyEndAllowThreads(__tstate);
13041 if (PyErr_Occurred()) SWIG_fail;
13042 }
13043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13044 {
13045 if (temp2)
13046 delete arg2;
13047 }
13048 return resultobj;
13049 fail:
13050 {
13051 if (temp2)
13052 delete arg2;
13053 }
13054 return NULL;
13055 }
13056
13057
13058 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13059 PyObject *resultobj = 0;
13060 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13061 bool arg2 = (bool) true ;
13062 void *argp1 = 0 ;
13063 int res1 = 0 ;
13064 bool val2 ;
13065 int ecode2 = 0 ;
13066 PyObject * obj0 = 0 ;
13067 PyObject * obj1 = 0 ;
13068 char * kwnames[] = {
13069 (char *) "self",(char *) "bShow", NULL
13070 };
13071
13072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13074 if (!SWIG_IsOK(res1)) {
13075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13076 }
13077 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13078 if (obj1) {
13079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13080 if (!SWIG_IsOK(ecode2)) {
13081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13082 }
13083 arg2 = static_cast< bool >(val2);
13084 }
13085 {
13086 PyThreadState* __tstate = wxPyBeginAllowThreads();
13087 (arg1)->Show(arg2);
13088 wxPyEndAllowThreads(__tstate);
13089 if (PyErr_Occurred()) SWIG_fail;
13090 }
13091 resultobj = SWIG_Py_Void();
13092 return resultobj;
13093 fail:
13094 return NULL;
13095 }
13096
13097
13098 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13099 PyObject *resultobj = 0;
13100 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13101 wxFrame *result = 0 ;
13102 void *argp1 = 0 ;
13103 int res1 = 0 ;
13104 PyObject *swig_obj[1] ;
13105
13106 if (!args) SWIG_fail;
13107 swig_obj[0] = args;
13108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13109 if (!SWIG_IsOK(res1)) {
13110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13111 }
13112 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 {
13120 resultobj = wxPyMake_wxObject(result, (bool)0);
13121 }
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13129 PyObject *resultobj = 0;
13130 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13131 wxLog *result = 0 ;
13132 void *argp1 = 0 ;
13133 int res1 = 0 ;
13134 PyObject *swig_obj[1] ;
13135
13136 if (!args) SWIG_fail;
13137 swig_obj[0] = args;
13138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13139 if (!SWIG_IsOK(res1)) {
13140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13141 }
13142 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13157 PyObject *resultobj = 0;
13158 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13159 bool result;
13160 void *argp1 = 0 ;
13161 int res1 = 0 ;
13162 PyObject *swig_obj[1] ;
13163
13164 if (!args) SWIG_fail;
13165 swig_obj[0] = args;
13166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13167 if (!SWIG_IsOK(res1)) {
13168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13169 }
13170 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 {
13178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13179 }
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj = 0;
13188 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13189 bool arg2 ;
13190 void *argp1 = 0 ;
13191 int res1 = 0 ;
13192 bool val2 ;
13193 int ecode2 = 0 ;
13194 PyObject * obj0 = 0 ;
13195 PyObject * obj1 = 0 ;
13196 char * kwnames[] = {
13197 (char *) "self",(char *) "bDoPass", NULL
13198 };
13199
13200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13202 if (!SWIG_IsOK(res1)) {
13203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13204 }
13205 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13206 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13207 if (!SWIG_IsOK(ecode2)) {
13208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13209 }
13210 arg2 = static_cast< bool >(val2);
13211 {
13212 PyThreadState* __tstate = wxPyBeginAllowThreads();
13213 (arg1)->PassMessages(arg2);
13214 wxPyEndAllowThreads(__tstate);
13215 if (PyErr_Occurred()) SWIG_fail;
13216 }
13217 resultobj = SWIG_Py_Void();
13218 return resultobj;
13219 fail:
13220 return NULL;
13221 }
13222
13223
13224 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13225 PyObject *obj;
13226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13227 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13228 return SWIG_Py_Void();
13229 }
13230
13231 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13232 return SWIG_Python_InitShadowInstance(args);
13233 }
13234
13235 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13236 PyObject *resultobj = 0;
13237 wxLog *arg1 = (wxLog *) 0 ;
13238 wxLogChain *result = 0 ;
13239 void *argp1 = 0 ;
13240 int res1 = 0 ;
13241 PyObject * obj0 = 0 ;
13242 char * kwnames[] = {
13243 (char *) "logger", NULL
13244 };
13245
13246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13248 if (!SWIG_IsOK(res1)) {
13249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13250 }
13251 arg1 = reinterpret_cast< wxLog * >(argp1);
13252 {
13253 PyThreadState* __tstate = wxPyBeginAllowThreads();
13254 result = (wxLogChain *)new wxLogChain(arg1);
13255 wxPyEndAllowThreads(__tstate);
13256 if (PyErr_Occurred()) SWIG_fail;
13257 }
13258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13259 return resultobj;
13260 fail:
13261 return NULL;
13262 }
13263
13264
13265 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13266 PyObject *resultobj = 0;
13267 wxLogChain *arg1 = (wxLogChain *) 0 ;
13268 wxLog *arg2 = (wxLog *) 0 ;
13269 void *argp1 = 0 ;
13270 int res1 = 0 ;
13271 void *argp2 = 0 ;
13272 int res2 = 0 ;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 char * kwnames[] = {
13276 (char *) "self",(char *) "logger", NULL
13277 };
13278
13279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13281 if (!SWIG_IsOK(res1)) {
13282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13283 }
13284 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13286 if (!SWIG_IsOK(res2)) {
13287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13288 }
13289 arg2 = reinterpret_cast< wxLog * >(argp2);
13290 {
13291 PyThreadState* __tstate = wxPyBeginAllowThreads();
13292 (arg1)->SetLog(arg2);
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 resultobj = SWIG_Py_Void();
13297 return resultobj;
13298 fail:
13299 return NULL;
13300 }
13301
13302
13303 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13304 PyObject *resultobj = 0;
13305 wxLogChain *arg1 = (wxLogChain *) 0 ;
13306 bool arg2 ;
13307 void *argp1 = 0 ;
13308 int res1 = 0 ;
13309 bool val2 ;
13310 int ecode2 = 0 ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 char * kwnames[] = {
13314 (char *) "self",(char *) "bDoPass", NULL
13315 };
13316
13317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13319 if (!SWIG_IsOK(res1)) {
13320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13321 }
13322 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13323 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13324 if (!SWIG_IsOK(ecode2)) {
13325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13326 }
13327 arg2 = static_cast< bool >(val2);
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 (arg1)->PassMessages(arg2);
13331 wxPyEndAllowThreads(__tstate);
13332 if (PyErr_Occurred()) SWIG_fail;
13333 }
13334 resultobj = SWIG_Py_Void();
13335 return resultobj;
13336 fail:
13337 return NULL;
13338 }
13339
13340
13341 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13342 PyObject *resultobj = 0;
13343 wxLogChain *arg1 = (wxLogChain *) 0 ;
13344 bool result;
13345 void *argp1 = 0 ;
13346 int res1 = 0 ;
13347 PyObject *swig_obj[1] ;
13348
13349 if (!args) SWIG_fail;
13350 swig_obj[0] = args;
13351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13352 if (!SWIG_IsOK(res1)) {
13353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13354 }
13355 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (bool)(arg1)->IsPassingMessages();
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 {
13363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13364 }
13365 return resultobj;
13366 fail:
13367 return NULL;
13368 }
13369
13370
13371 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13372 PyObject *resultobj = 0;
13373 wxLogChain *arg1 = (wxLogChain *) 0 ;
13374 wxLog *result = 0 ;
13375 void *argp1 = 0 ;
13376 int res1 = 0 ;
13377 PyObject *swig_obj[1] ;
13378
13379 if (!args) SWIG_fail;
13380 swig_obj[0] = args;
13381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13382 if (!SWIG_IsOK(res1)) {
13383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13384 }
13385 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13386 {
13387 PyThreadState* __tstate = wxPyBeginAllowThreads();
13388 result = (wxLog *)(arg1)->GetOldLog();
13389 wxPyEndAllowThreads(__tstate);
13390 if (PyErr_Occurred()) SWIG_fail;
13391 }
13392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13393 return resultobj;
13394 fail:
13395 return NULL;
13396 }
13397
13398
13399 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13400 PyObject *obj;
13401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13402 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13403 return SWIG_Py_Void();
13404 }
13405
13406 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13407 return SWIG_Python_InitShadowInstance(args);
13408 }
13409
13410 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13411 PyObject *resultobj = 0;
13412 wxLogBuffer *result = 0 ;
13413
13414 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13415 {
13416 PyThreadState* __tstate = wxPyBeginAllowThreads();
13417 result = (wxLogBuffer *)new wxLogBuffer();
13418 wxPyEndAllowThreads(__tstate);
13419 if (PyErr_Occurred()) SWIG_fail;
13420 }
13421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13422 return resultobj;
13423 fail:
13424 return NULL;
13425 }
13426
13427
13428 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13429 PyObject *resultobj = 0;
13430 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13431 wxString *result = 0 ;
13432 void *argp1 = 0 ;
13433 int res1 = 0 ;
13434 PyObject *swig_obj[1] ;
13435
13436 if (!args) SWIG_fail;
13437 swig_obj[0] = args;
13438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13439 if (!SWIG_IsOK(res1)) {
13440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13441 }
13442 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13443 {
13444 PyThreadState* __tstate = wxPyBeginAllowThreads();
13445 {
13446 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13447 result = (wxString *) &_result_ref;
13448 }
13449 wxPyEndAllowThreads(__tstate);
13450 if (PyErr_Occurred()) SWIG_fail;
13451 }
13452 {
13453 #if wxUSE_UNICODE
13454 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13455 #else
13456 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13457 #endif
13458 }
13459 return resultobj;
13460 fail:
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13466 PyObject *obj;
13467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13468 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13469 return SWIG_Py_Void();
13470 }
13471
13472 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13473 return SWIG_Python_InitShadowInstance(args);
13474 }
13475
13476 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13477 PyObject *resultobj = 0;
13478 unsigned long result;
13479
13480 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 result = (unsigned long)wxSysErrorCode();
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13488 return resultobj;
13489 fail:
13490 return NULL;
13491 }
13492
13493
13494 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13495 PyObject *resultobj = 0;
13496 unsigned long arg1 = (unsigned long) 0 ;
13497 wxString result;
13498 unsigned long val1 ;
13499 int ecode1 = 0 ;
13500 PyObject * obj0 = 0 ;
13501 char * kwnames[] = {
13502 (char *) "nErrCode", NULL
13503 };
13504
13505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13506 if (obj0) {
13507 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13508 if (!SWIG_IsOK(ecode1)) {
13509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13510 }
13511 arg1 = static_cast< unsigned long >(val1);
13512 }
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = wxSysErrorMsg(arg1);
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 {
13520 #if wxUSE_UNICODE
13521 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13522 #else
13523 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13524 #endif
13525 }
13526 return resultobj;
13527 fail:
13528 return NULL;
13529 }
13530
13531
13532 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13533 PyObject *resultobj = 0;
13534 wxString *arg1 = 0 ;
13535 bool temp1 = false ;
13536 PyObject * obj0 = 0 ;
13537 char * kwnames[] = {
13538 (char *) "msg", NULL
13539 };
13540
13541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13542 {
13543 arg1 = wxString_in_helper(obj0);
13544 if (arg1 == NULL) SWIG_fail;
13545 temp1 = true;
13546 }
13547 {
13548 PyThreadState* __tstate = wxPyBeginAllowThreads();
13549 wxPyLogFatalError((wxString const &)*arg1);
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 resultobj = SWIG_Py_Void();
13554 {
13555 if (temp1)
13556 delete arg1;
13557 }
13558 return resultobj;
13559 fail:
13560 {
13561 if (temp1)
13562 delete arg1;
13563 }
13564 return NULL;
13565 }
13566
13567
13568 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13569 PyObject *resultobj = 0;
13570 wxString *arg1 = 0 ;
13571 bool temp1 = false ;
13572 PyObject * obj0 = 0 ;
13573 char * kwnames[] = {
13574 (char *) "msg", NULL
13575 };
13576
13577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13578 {
13579 arg1 = wxString_in_helper(obj0);
13580 if (arg1 == NULL) SWIG_fail;
13581 temp1 = true;
13582 }
13583 {
13584 PyThreadState* __tstate = wxPyBeginAllowThreads();
13585 wxPyLogError((wxString const &)*arg1);
13586 wxPyEndAllowThreads(__tstate);
13587 if (PyErr_Occurred()) SWIG_fail;
13588 }
13589 resultobj = SWIG_Py_Void();
13590 {
13591 if (temp1)
13592 delete arg1;
13593 }
13594 return resultobj;
13595 fail:
13596 {
13597 if (temp1)
13598 delete arg1;
13599 }
13600 return NULL;
13601 }
13602
13603
13604 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13605 PyObject *resultobj = 0;
13606 wxString *arg1 = 0 ;
13607 bool temp1 = false ;
13608 PyObject * obj0 = 0 ;
13609 char * kwnames[] = {
13610 (char *) "msg", NULL
13611 };
13612
13613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13614 {
13615 arg1 = wxString_in_helper(obj0);
13616 if (arg1 == NULL) SWIG_fail;
13617 temp1 = true;
13618 }
13619 {
13620 PyThreadState* __tstate = wxPyBeginAllowThreads();
13621 wxPyLogWarning((wxString const &)*arg1);
13622 wxPyEndAllowThreads(__tstate);
13623 if (PyErr_Occurred()) SWIG_fail;
13624 }
13625 resultobj = SWIG_Py_Void();
13626 {
13627 if (temp1)
13628 delete arg1;
13629 }
13630 return resultobj;
13631 fail:
13632 {
13633 if (temp1)
13634 delete arg1;
13635 }
13636 return NULL;
13637 }
13638
13639
13640 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj = 0;
13642 wxString *arg1 = 0 ;
13643 bool temp1 = false ;
13644 PyObject * obj0 = 0 ;
13645 char * kwnames[] = {
13646 (char *) "msg", NULL
13647 };
13648
13649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13650 {
13651 arg1 = wxString_in_helper(obj0);
13652 if (arg1 == NULL) SWIG_fail;
13653 temp1 = true;
13654 }
13655 {
13656 PyThreadState* __tstate = wxPyBeginAllowThreads();
13657 wxPyLogMessage((wxString const &)*arg1);
13658 wxPyEndAllowThreads(__tstate);
13659 if (PyErr_Occurred()) SWIG_fail;
13660 }
13661 resultobj = SWIG_Py_Void();
13662 {
13663 if (temp1)
13664 delete arg1;
13665 }
13666 return resultobj;
13667 fail:
13668 {
13669 if (temp1)
13670 delete arg1;
13671 }
13672 return NULL;
13673 }
13674
13675
13676 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13677 PyObject *resultobj = 0;
13678 wxString *arg1 = 0 ;
13679 bool temp1 = false ;
13680 PyObject * obj0 = 0 ;
13681 char * kwnames[] = {
13682 (char *) "msg", NULL
13683 };
13684
13685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13686 {
13687 arg1 = wxString_in_helper(obj0);
13688 if (arg1 == NULL) SWIG_fail;
13689 temp1 = true;
13690 }
13691 {
13692 PyThreadState* __tstate = wxPyBeginAllowThreads();
13693 wxPyLogInfo((wxString const &)*arg1);
13694 wxPyEndAllowThreads(__tstate);
13695 if (PyErr_Occurred()) SWIG_fail;
13696 }
13697 resultobj = SWIG_Py_Void();
13698 {
13699 if (temp1)
13700 delete arg1;
13701 }
13702 return resultobj;
13703 fail:
13704 {
13705 if (temp1)
13706 delete arg1;
13707 }
13708 return NULL;
13709 }
13710
13711
13712 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13713 PyObject *resultobj = 0;
13714 wxString *arg1 = 0 ;
13715 bool temp1 = false ;
13716 PyObject * obj0 = 0 ;
13717 char * kwnames[] = {
13718 (char *) "msg", NULL
13719 };
13720
13721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13722 {
13723 arg1 = wxString_in_helper(obj0);
13724 if (arg1 == NULL) SWIG_fail;
13725 temp1 = true;
13726 }
13727 {
13728 PyThreadState* __tstate = wxPyBeginAllowThreads();
13729 wxPyLogDebug((wxString const &)*arg1);
13730 wxPyEndAllowThreads(__tstate);
13731 if (PyErr_Occurred()) SWIG_fail;
13732 }
13733 resultobj = SWIG_Py_Void();
13734 {
13735 if (temp1)
13736 delete arg1;
13737 }
13738 return resultobj;
13739 fail:
13740 {
13741 if (temp1)
13742 delete arg1;
13743 }
13744 return NULL;
13745 }
13746
13747
13748 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13749 PyObject *resultobj = 0;
13750 wxString *arg1 = 0 ;
13751 bool temp1 = false ;
13752 PyObject * obj0 = 0 ;
13753 char * kwnames[] = {
13754 (char *) "msg", NULL
13755 };
13756
13757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13758 {
13759 arg1 = wxString_in_helper(obj0);
13760 if (arg1 == NULL) SWIG_fail;
13761 temp1 = true;
13762 }
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 wxPyLogVerbose((wxString const &)*arg1);
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 resultobj = SWIG_Py_Void();
13770 {
13771 if (temp1)
13772 delete arg1;
13773 }
13774 return resultobj;
13775 fail:
13776 {
13777 if (temp1)
13778 delete arg1;
13779 }
13780 return NULL;
13781 }
13782
13783
13784 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13785 PyObject *resultobj = 0;
13786 wxString *arg1 = 0 ;
13787 bool temp1 = false ;
13788 PyObject * obj0 = 0 ;
13789 char * kwnames[] = {
13790 (char *) "msg", NULL
13791 };
13792
13793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13794 {
13795 arg1 = wxString_in_helper(obj0);
13796 if (arg1 == NULL) SWIG_fail;
13797 temp1 = true;
13798 }
13799 {
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 wxPyLogStatus((wxString const &)*arg1);
13802 wxPyEndAllowThreads(__tstate);
13803 if (PyErr_Occurred()) SWIG_fail;
13804 }
13805 resultobj = SWIG_Py_Void();
13806 {
13807 if (temp1)
13808 delete arg1;
13809 }
13810 return resultobj;
13811 fail:
13812 {
13813 if (temp1)
13814 delete arg1;
13815 }
13816 return NULL;
13817 }
13818
13819
13820 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13821 PyObject *resultobj = 0;
13822 wxFrame *arg1 = (wxFrame *) 0 ;
13823 wxString *arg2 = 0 ;
13824 void *argp1 = 0 ;
13825 int res1 = 0 ;
13826 bool temp2 = false ;
13827 PyObject * obj0 = 0 ;
13828 PyObject * obj1 = 0 ;
13829 char * kwnames[] = {
13830 (char *) "pFrame",(char *) "msg", NULL
13831 };
13832
13833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13835 if (!SWIG_IsOK(res1)) {
13836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13837 }
13838 arg1 = reinterpret_cast< wxFrame * >(argp1);
13839 {
13840 arg2 = wxString_in_helper(obj1);
13841 if (arg2 == NULL) SWIG_fail;
13842 temp2 = true;
13843 }
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13847 wxPyEndAllowThreads(__tstate);
13848 if (PyErr_Occurred()) SWIG_fail;
13849 }
13850 resultobj = SWIG_Py_Void();
13851 {
13852 if (temp2)
13853 delete arg2;
13854 }
13855 return resultobj;
13856 fail:
13857 {
13858 if (temp2)
13859 delete arg2;
13860 }
13861 return NULL;
13862 }
13863
13864
13865 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13866 PyObject *resultobj = 0;
13867 wxString *arg1 = 0 ;
13868 bool temp1 = false ;
13869 PyObject * obj0 = 0 ;
13870 char * kwnames[] = {
13871 (char *) "msg", NULL
13872 };
13873
13874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13875 {
13876 arg1 = wxString_in_helper(obj0);
13877 if (arg1 == NULL) SWIG_fail;
13878 temp1 = true;
13879 }
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 wxPyLogSysError((wxString const &)*arg1);
13883 wxPyEndAllowThreads(__tstate);
13884 if (PyErr_Occurred()) SWIG_fail;
13885 }
13886 resultobj = SWIG_Py_Void();
13887 {
13888 if (temp1)
13889 delete arg1;
13890 }
13891 return resultobj;
13892 fail:
13893 {
13894 if (temp1)
13895 delete arg1;
13896 }
13897 return NULL;
13898 }
13899
13900
13901 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj = 0;
13903 unsigned long arg1 ;
13904 wxString *arg2 = 0 ;
13905 unsigned long val1 ;
13906 int ecode1 = 0 ;
13907 bool temp2 = false ;
13908 PyObject * obj0 = 0 ;
13909 PyObject * obj1 = 0 ;
13910 char * kwnames[] = {
13911 (char *) "level",(char *) "msg", NULL
13912 };
13913
13914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13915 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13916 if (!SWIG_IsOK(ecode1)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13918 }
13919 arg1 = static_cast< unsigned long >(val1);
13920 {
13921 arg2 = wxString_in_helper(obj1);
13922 if (arg2 == NULL) SWIG_fail;
13923 temp2 = true;
13924 }
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_Py_Void();
13932 {
13933 if (temp2)
13934 delete arg2;
13935 }
13936 return resultobj;
13937 fail:
13938 {
13939 if (temp2)
13940 delete arg2;
13941 }
13942 return NULL;
13943 }
13944
13945
13946 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13947 PyObject *resultobj = 0;
13948 unsigned long arg1 ;
13949 wxString *arg2 = 0 ;
13950 unsigned long val1 ;
13951 int ecode1 = 0 ;
13952 bool temp2 = false ;
13953
13954 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13955 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13956 if (!SWIG_IsOK(ecode1)) {
13957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13958 }
13959 arg1 = static_cast< unsigned long >(val1);
13960 {
13961 arg2 = wxString_in_helper(swig_obj[1]);
13962 if (arg2 == NULL) SWIG_fail;
13963 temp2 = true;
13964 }
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 wxPyLogTrace(arg1,(wxString const &)*arg2);
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 resultobj = SWIG_Py_Void();
13972 {
13973 if (temp2)
13974 delete arg2;
13975 }
13976 return resultobj;
13977 fail:
13978 {
13979 if (temp2)
13980 delete arg2;
13981 }
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13987 PyObject *resultobj = 0;
13988 wxString *arg1 = 0 ;
13989 wxString *arg2 = 0 ;
13990 bool temp1 = false ;
13991 bool temp2 = false ;
13992
13993 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13994 {
13995 arg1 = wxString_in_helper(swig_obj[0]);
13996 if (arg1 == NULL) SWIG_fail;
13997 temp1 = true;
13998 }
13999 {
14000 arg2 = wxString_in_helper(swig_obj[1]);
14001 if (arg2 == NULL) SWIG_fail;
14002 temp2 = true;
14003 }
14004 {
14005 PyThreadState* __tstate = wxPyBeginAllowThreads();
14006 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 resultobj = SWIG_Py_Void();
14011 {
14012 if (temp1)
14013 delete arg1;
14014 }
14015 {
14016 if (temp2)
14017 delete arg2;
14018 }
14019 return resultobj;
14020 fail:
14021 {
14022 if (temp1)
14023 delete arg1;
14024 }
14025 {
14026 if (temp2)
14027 delete arg2;
14028 }
14029 return NULL;
14030 }
14031
14032
14033 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14034 int argc;
14035 PyObject *argv[3];
14036
14037 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14038 --argc;
14039 if (argc == 2) {
14040 int _v = 0;
14041 {
14042 {
14043 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14044 }
14045 }
14046 if (!_v) goto check_1;
14047 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14048 }
14049 check_1:
14050
14051 if (argc == 2) {
14052 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14053 }
14054
14055 fail:
14056 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj = 0;
14063 wxString *arg1 = 0 ;
14064 wxString *arg2 = 0 ;
14065 bool temp1 = false ;
14066 bool temp2 = false ;
14067 PyObject * obj0 = 0 ;
14068 PyObject * obj1 = 0 ;
14069 char * kwnames[] = {
14070 (char *) "title",(char *) "text", NULL
14071 };
14072
14073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14074 {
14075 arg1 = wxString_in_helper(obj0);
14076 if (arg1 == NULL) SWIG_fail;
14077 temp1 = true;
14078 }
14079 {
14080 arg2 = wxString_in_helper(obj1);
14081 if (arg2 == NULL) SWIG_fail;
14082 temp2 = true;
14083 }
14084 {
14085 PyThreadState* __tstate = wxPyBeginAllowThreads();
14086 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14087 wxPyEndAllowThreads(__tstate);
14088 if (PyErr_Occurred()) SWIG_fail;
14089 }
14090 resultobj = SWIG_Py_Void();
14091 {
14092 if (temp1)
14093 delete arg1;
14094 }
14095 {
14096 if (temp2)
14097 delete arg2;
14098 }
14099 return resultobj;
14100 fail:
14101 {
14102 if (temp1)
14103 delete arg1;
14104 }
14105 {
14106 if (temp2)
14107 delete arg2;
14108 }
14109 return NULL;
14110 }
14111
14112
14113 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14114 PyObject *resultobj = 0;
14115 wxLogNull *result = 0 ;
14116
14117 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 result = (wxLogNull *)new wxLogNull();
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14132 PyObject *resultobj = 0;
14133 wxLogNull *arg1 = (wxLogNull *) 0 ;
14134 void *argp1 = 0 ;
14135 int res1 = 0 ;
14136 PyObject *swig_obj[1] ;
14137
14138 if (!args) SWIG_fail;
14139 swig_obj[0] = args;
14140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14141 if (!SWIG_IsOK(res1)) {
14142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14143 }
14144 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14145 {
14146 PyThreadState* __tstate = wxPyBeginAllowThreads();
14147 delete arg1;
14148
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 resultobj = SWIG_Py_Void();
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14160 PyObject *obj;
14161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14162 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14163 return SWIG_Py_Void();
14164 }
14165
14166 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14167 return SWIG_Python_InitShadowInstance(args);
14168 }
14169
14170 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14171 PyObject *resultobj = 0;
14172 wxPyLog *result = 0 ;
14173
14174 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 result = (wxPyLog *)new wxPyLog();
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj = 0;
14190 wxPyLog *arg1 = (wxPyLog *) 0 ;
14191 PyObject *arg2 = (PyObject *) 0 ;
14192 PyObject *arg3 = (PyObject *) 0 ;
14193 void *argp1 = 0 ;
14194 int res1 = 0 ;
14195 PyObject * obj0 = 0 ;
14196 PyObject * obj1 = 0 ;
14197 PyObject * obj2 = 0 ;
14198 char * kwnames[] = {
14199 (char *) "self",(char *) "self",(char *) "_class", NULL
14200 };
14201
14202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14204 if (!SWIG_IsOK(res1)) {
14205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14206 }
14207 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14208 arg2 = obj1;
14209 arg3 = obj2;
14210 {
14211 PyThreadState* __tstate = wxPyBeginAllowThreads();
14212 (arg1)->_setCallbackInfo(arg2,arg3);
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 resultobj = SWIG_Py_Void();
14217 return resultobj;
14218 fail:
14219 return NULL;
14220 }
14221
14222
14223 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14224 PyObject *obj;
14225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14226 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14227 return SWIG_Py_Void();
14228 }
14229
14230 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14231 return SWIG_Python_InitShadowInstance(args);
14232 }
14233
14234 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14235 PyObject *resultobj = 0;
14236 int arg1 ;
14237 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14238 int arg3 = (int) wxKILL_NOCHILDREN ;
14239 wxKillError result;
14240 int val1 ;
14241 int ecode1 = 0 ;
14242 int val2 ;
14243 int ecode2 = 0 ;
14244 int val3 ;
14245 int ecode3 = 0 ;
14246 PyObject * obj0 = 0 ;
14247 PyObject * obj1 = 0 ;
14248 PyObject * obj2 = 0 ;
14249 char * kwnames[] = {
14250 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14251 };
14252
14253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14254 ecode1 = SWIG_AsVal_int(obj0, &val1);
14255 if (!SWIG_IsOK(ecode1)) {
14256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14257 }
14258 arg1 = static_cast< int >(val1);
14259 if (obj1) {
14260 ecode2 = SWIG_AsVal_int(obj1, &val2);
14261 if (!SWIG_IsOK(ecode2)) {
14262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14263 }
14264 arg2 = static_cast< wxSignal >(val2);
14265 }
14266 if (obj2) {
14267 ecode3 = SWIG_AsVal_int(obj2, &val3);
14268 if (!SWIG_IsOK(ecode3)) {
14269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14270 }
14271 arg3 = static_cast< int >(val3);
14272 }
14273 {
14274 PyThreadState* __tstate = wxPyBeginAllowThreads();
14275 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 resultobj = SWIG_From_int(static_cast< int >(result));
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14287 PyObject *resultobj = 0;
14288 int arg1 ;
14289 bool result;
14290 int val1 ;
14291 int ecode1 = 0 ;
14292 PyObject * obj0 = 0 ;
14293 char * kwnames[] = {
14294 (char *) "pid", NULL
14295 };
14296
14297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14298 ecode1 = SWIG_AsVal_int(obj0, &val1);
14299 if (!SWIG_IsOK(ecode1)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14301 }
14302 arg1 = static_cast< int >(val1);
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 result = (bool)wxPyProcess::Exists(arg1);
14306 wxPyEndAllowThreads(__tstate);
14307 if (PyErr_Occurred()) SWIG_fail;
14308 }
14309 {
14310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14311 }
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj = 0;
14320 wxString *arg1 = 0 ;
14321 int arg2 = (int) wxEXEC_ASYNC ;
14322 wxPyProcess *result = 0 ;
14323 bool temp1 = false ;
14324 int val2 ;
14325 int ecode2 = 0 ;
14326 PyObject * obj0 = 0 ;
14327 PyObject * obj1 = 0 ;
14328 char * kwnames[] = {
14329 (char *) "cmd",(char *) "flags", NULL
14330 };
14331
14332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14333 {
14334 arg1 = wxString_in_helper(obj0);
14335 if (arg1 == NULL) SWIG_fail;
14336 temp1 = true;
14337 }
14338 if (obj1) {
14339 ecode2 = SWIG_AsVal_int(obj1, &val2);
14340 if (!SWIG_IsOK(ecode2)) {
14341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14342 }
14343 arg2 = static_cast< int >(val2);
14344 }
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14352 {
14353 if (temp1)
14354 delete arg1;
14355 }
14356 return resultobj;
14357 fail:
14358 {
14359 if (temp1)
14360 delete arg1;
14361 }
14362 return NULL;
14363 }
14364
14365
14366 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14367 PyObject *resultobj = 0;
14368 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14369 int arg2 = (int) -1 ;
14370 wxPyProcess *result = 0 ;
14371 void *argp1 = 0 ;
14372 int res1 = 0 ;
14373 int val2 ;
14374 int ecode2 = 0 ;
14375 PyObject * obj0 = 0 ;
14376 PyObject * obj1 = 0 ;
14377 char * kwnames[] = {
14378 (char *) "parent",(char *) "id", NULL
14379 };
14380
14381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14382 if (obj0) {
14383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14384 if (!SWIG_IsOK(res1)) {
14385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14386 }
14387 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14388 }
14389 if (obj1) {
14390 ecode2 = SWIG_AsVal_int(obj1, &val2);
14391 if (!SWIG_IsOK(ecode2)) {
14392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14393 }
14394 arg2 = static_cast< int >(val2);
14395 }
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14410 PyObject *resultobj = 0;
14411 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14412 void *argp1 = 0 ;
14413 int res1 = 0 ;
14414 PyObject *swig_obj[1] ;
14415
14416 if (!args) SWIG_fail;
14417 swig_obj[0] = args;
14418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14419 if (!SWIG_IsOK(res1)) {
14420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14421 }
14422 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 delete arg1;
14426
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 resultobj = SWIG_Py_Void();
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj = 0;
14439 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14440 PyObject *arg2 = (PyObject *) 0 ;
14441 PyObject *arg3 = (PyObject *) 0 ;
14442 void *argp1 = 0 ;
14443 int res1 = 0 ;
14444 PyObject * obj0 = 0 ;
14445 PyObject * obj1 = 0 ;
14446 PyObject * obj2 = 0 ;
14447 char * kwnames[] = {
14448 (char *) "self",(char *) "self",(char *) "_class", NULL
14449 };
14450
14451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14455 }
14456 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14457 arg2 = obj1;
14458 arg3 = obj2;
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 (arg1)->_setCallbackInfo(arg2,arg3);
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 resultobj = SWIG_Py_Void();
14466 return resultobj;
14467 fail:
14468 return NULL;
14469 }
14470
14471
14472 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14473 PyObject *resultobj = 0;
14474 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14475 long result;
14476 void *argp1 = 0 ;
14477 int res1 = 0 ;
14478 PyObject *swig_obj[1] ;
14479
14480 if (!args) SWIG_fail;
14481 swig_obj[0] = args;
14482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14483 if (!SWIG_IsOK(res1)) {
14484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14485 }
14486 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 result = (long)((wxPyProcess const *)arg1)->GetPid();
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 resultobj = SWIG_From_long(static_cast< long >(result));
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14501 PyObject *resultobj = 0;
14502 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14503 int arg2 ;
14504 int arg3 ;
14505 void *argp1 = 0 ;
14506 int res1 = 0 ;
14507 int val2 ;
14508 int ecode2 = 0 ;
14509 int val3 ;
14510 int ecode3 = 0 ;
14511 PyObject * obj0 = 0 ;
14512 PyObject * obj1 = 0 ;
14513 PyObject * obj2 = 0 ;
14514 char * kwnames[] = {
14515 (char *) "self",(char *) "pid",(char *) "status", NULL
14516 };
14517
14518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14520 if (!SWIG_IsOK(res1)) {
14521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14522 }
14523 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14524 ecode2 = SWIG_AsVal_int(obj1, &val2);
14525 if (!SWIG_IsOK(ecode2)) {
14526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14527 }
14528 arg2 = static_cast< int >(val2);
14529 ecode3 = SWIG_AsVal_int(obj2, &val3);
14530 if (!SWIG_IsOK(ecode3)) {
14531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14532 }
14533 arg3 = static_cast< int >(val3);
14534 {
14535 PyThreadState* __tstate = wxPyBeginAllowThreads();
14536 (arg1)->OnTerminate(arg2,arg3);
14537 wxPyEndAllowThreads(__tstate);
14538 if (PyErr_Occurred()) SWIG_fail;
14539 }
14540 resultobj = SWIG_Py_Void();
14541 return resultobj;
14542 fail:
14543 return NULL;
14544 }
14545
14546
14547 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14548 PyObject *resultobj = 0;
14549 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14550 void *argp1 = 0 ;
14551 int res1 = 0 ;
14552 PyObject *swig_obj[1] ;
14553
14554 if (!args) SWIG_fail;
14555 swig_obj[0] = args;
14556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14557 if (!SWIG_IsOK(res1)) {
14558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14559 }
14560 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 (arg1)->Redirect();
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 resultobj = SWIG_Py_Void();
14568 return resultobj;
14569 fail:
14570 return NULL;
14571 }
14572
14573
14574 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14575 PyObject *resultobj = 0;
14576 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14577 bool result;
14578 void *argp1 = 0 ;
14579 int res1 = 0 ;
14580 PyObject *swig_obj[1] ;
14581
14582 if (!args) SWIG_fail;
14583 swig_obj[0] = args;
14584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14585 if (!SWIG_IsOK(res1)) {
14586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14587 }
14588 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 result = (bool)(arg1)->IsRedirected();
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 {
14596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14597 }
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14605 PyObject *resultobj = 0;
14606 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14607 void *argp1 = 0 ;
14608 int res1 = 0 ;
14609 PyObject *swig_obj[1] ;
14610
14611 if (!args) SWIG_fail;
14612 swig_obj[0] = args;
14613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14614 if (!SWIG_IsOK(res1)) {
14615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14616 }
14617 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14618 {
14619 PyThreadState* __tstate = wxPyBeginAllowThreads();
14620 (arg1)->Detach();
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 resultobj = SWIG_Py_Void();
14625 return resultobj;
14626 fail:
14627 return NULL;
14628 }
14629
14630
14631 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14632 PyObject *resultobj = 0;
14633 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14634 wxInputStream *result = 0 ;
14635 void *argp1 = 0 ;
14636 int res1 = 0 ;
14637 PyObject *swig_obj[1] ;
14638
14639 if (!args) SWIG_fail;
14640 swig_obj[0] = args;
14641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14642 if (!SWIG_IsOK(res1)) {
14643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14644 }
14645 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14646 {
14647 PyThreadState* __tstate = wxPyBeginAllowThreads();
14648 result = (wxInputStream *)(arg1)->GetInputStream();
14649 wxPyEndAllowThreads(__tstate);
14650 if (PyErr_Occurred()) SWIG_fail;
14651 }
14652 {
14653 wxPyInputStream * _ptr = NULL;
14654
14655 if (result) {
14656 _ptr = new wxPyInputStream(result);
14657 }
14658 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14659 }
14660 return resultobj;
14661 fail:
14662 return NULL;
14663 }
14664
14665
14666 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14667 PyObject *resultobj = 0;
14668 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14669 wxInputStream *result = 0 ;
14670 void *argp1 = 0 ;
14671 int res1 = 0 ;
14672 PyObject *swig_obj[1] ;
14673
14674 if (!args) SWIG_fail;
14675 swig_obj[0] = args;
14676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14677 if (!SWIG_IsOK(res1)) {
14678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14679 }
14680 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14681 {
14682 PyThreadState* __tstate = wxPyBeginAllowThreads();
14683 result = (wxInputStream *)(arg1)->GetErrorStream();
14684 wxPyEndAllowThreads(__tstate);
14685 if (PyErr_Occurred()) SWIG_fail;
14686 }
14687 {
14688 wxPyInputStream * _ptr = NULL;
14689
14690 if (result) {
14691 _ptr = new wxPyInputStream(result);
14692 }
14693 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14694 }
14695 return resultobj;
14696 fail:
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14702 PyObject *resultobj = 0;
14703 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14704 wxOutputStream *result = 0 ;
14705 void *argp1 = 0 ;
14706 int res1 = 0 ;
14707 PyObject *swig_obj[1] ;
14708
14709 if (!args) SWIG_fail;
14710 swig_obj[0] = args;
14711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14712 if (!SWIG_IsOK(res1)) {
14713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14714 }
14715 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14716 {
14717 PyThreadState* __tstate = wxPyBeginAllowThreads();
14718 result = (wxOutputStream *)(arg1)->GetOutputStream();
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 PyObject *resultobj = 0;
14731 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14732 void *argp1 = 0 ;
14733 int res1 = 0 ;
14734 PyObject *swig_obj[1] ;
14735
14736 if (!args) SWIG_fail;
14737 swig_obj[0] = args;
14738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14739 if (!SWIG_IsOK(res1)) {
14740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14741 }
14742 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14743 {
14744 PyThreadState* __tstate = wxPyBeginAllowThreads();
14745 (arg1)->CloseOutput();
14746 wxPyEndAllowThreads(__tstate);
14747 if (PyErr_Occurred()) SWIG_fail;
14748 }
14749 resultobj = SWIG_Py_Void();
14750 return resultobj;
14751 fail:
14752 return NULL;
14753 }
14754
14755
14756 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14757 PyObject *resultobj = 0;
14758 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14759 bool result;
14760 void *argp1 = 0 ;
14761 int res1 = 0 ;
14762 PyObject *swig_obj[1] ;
14763
14764 if (!args) SWIG_fail;
14765 swig_obj[0] = args;
14766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14767 if (!SWIG_IsOK(res1)) {
14768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14769 }
14770 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14771 {
14772 PyThreadState* __tstate = wxPyBeginAllowThreads();
14773 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14774 wxPyEndAllowThreads(__tstate);
14775 if (PyErr_Occurred()) SWIG_fail;
14776 }
14777 {
14778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14779 }
14780 return resultobj;
14781 fail:
14782 return NULL;
14783 }
14784
14785
14786 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14787 PyObject *resultobj = 0;
14788 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14789 bool result;
14790 void *argp1 = 0 ;
14791 int res1 = 0 ;
14792 PyObject *swig_obj[1] ;
14793
14794 if (!args) SWIG_fail;
14795 swig_obj[0] = args;
14796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14797 if (!SWIG_IsOK(res1)) {
14798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14799 }
14800 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14801 {
14802 PyThreadState* __tstate = wxPyBeginAllowThreads();
14803 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 {
14808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14809 }
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14817 PyObject *resultobj = 0;
14818 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14819 bool result;
14820 void *argp1 = 0 ;
14821 int res1 = 0 ;
14822 PyObject *swig_obj[1] ;
14823
14824 if (!args) SWIG_fail;
14825 swig_obj[0] = args;
14826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14829 }
14830 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14831 {
14832 PyThreadState* __tstate = wxPyBeginAllowThreads();
14833 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14834 wxPyEndAllowThreads(__tstate);
14835 if (PyErr_Occurred()) SWIG_fail;
14836 }
14837 {
14838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14839 }
14840 return resultobj;
14841 fail:
14842 return NULL;
14843 }
14844
14845
14846 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14847 PyObject *obj;
14848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14849 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14850 return SWIG_Py_Void();
14851 }
14852
14853 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14854 return SWIG_Python_InitShadowInstance(args);
14855 }
14856
14857 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14858 PyObject *resultobj = 0;
14859 int arg1 = (int) 0 ;
14860 int arg2 = (int) 0 ;
14861 int arg3 = (int) 0 ;
14862 wxProcessEvent *result = 0 ;
14863 int val1 ;
14864 int ecode1 = 0 ;
14865 int val2 ;
14866 int ecode2 = 0 ;
14867 int val3 ;
14868 int ecode3 = 0 ;
14869 PyObject * obj0 = 0 ;
14870 PyObject * obj1 = 0 ;
14871 PyObject * obj2 = 0 ;
14872 char * kwnames[] = {
14873 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14874 };
14875
14876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14877 if (obj0) {
14878 ecode1 = SWIG_AsVal_int(obj0, &val1);
14879 if (!SWIG_IsOK(ecode1)) {
14880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14881 }
14882 arg1 = static_cast< int >(val1);
14883 }
14884 if (obj1) {
14885 ecode2 = SWIG_AsVal_int(obj1, &val2);
14886 if (!SWIG_IsOK(ecode2)) {
14887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14888 }
14889 arg2 = static_cast< int >(val2);
14890 }
14891 if (obj2) {
14892 ecode3 = SWIG_AsVal_int(obj2, &val3);
14893 if (!SWIG_IsOK(ecode3)) {
14894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14895 }
14896 arg3 = static_cast< int >(val3);
14897 }
14898 {
14899 PyThreadState* __tstate = wxPyBeginAllowThreads();
14900 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14905 return resultobj;
14906 fail:
14907 return NULL;
14908 }
14909
14910
14911 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14912 PyObject *resultobj = 0;
14913 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14914 int result;
14915 void *argp1 = 0 ;
14916 int res1 = 0 ;
14917 PyObject *swig_obj[1] ;
14918
14919 if (!args) SWIG_fail;
14920 swig_obj[0] = args;
14921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14922 if (!SWIG_IsOK(res1)) {
14923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14924 }
14925 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14926 {
14927 PyThreadState* __tstate = wxPyBeginAllowThreads();
14928 result = (int)(arg1)->GetPid();
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 resultobj = SWIG_From_int(static_cast< int >(result));
14933 return resultobj;
14934 fail:
14935 return NULL;
14936 }
14937
14938
14939 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14940 PyObject *resultobj = 0;
14941 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14942 int result;
14943 void *argp1 = 0 ;
14944 int res1 = 0 ;
14945 PyObject *swig_obj[1] ;
14946
14947 if (!args) SWIG_fail;
14948 swig_obj[0] = args;
14949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14950 if (!SWIG_IsOK(res1)) {
14951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14952 }
14953 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 result = (int)(arg1)->GetExitCode();
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 resultobj = SWIG_From_int(static_cast< int >(result));
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14968 PyObject *resultobj = 0;
14969 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14970 int arg2 ;
14971 void *argp1 = 0 ;
14972 int res1 = 0 ;
14973 int val2 ;
14974 int ecode2 = 0 ;
14975 PyObject *swig_obj[2] ;
14976
14977 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14979 if (!SWIG_IsOK(res1)) {
14980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14981 }
14982 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14983 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14984 if (!SWIG_IsOK(ecode2)) {
14985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14986 }
14987 arg2 = static_cast< int >(val2);
14988 if (arg1) (arg1)->m_pid = arg2;
14989
14990 resultobj = SWIG_Py_Void();
14991 return resultobj;
14992 fail:
14993 return NULL;
14994 }
14995
14996
14997 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14998 PyObject *resultobj = 0;
14999 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15000 int result;
15001 void *argp1 = 0 ;
15002 int res1 = 0 ;
15003 PyObject *swig_obj[1] ;
15004
15005 if (!args) SWIG_fail;
15006 swig_obj[0] = args;
15007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15008 if (!SWIG_IsOK(res1)) {
15009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15010 }
15011 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15012 result = (int) ((arg1)->m_pid);
15013 resultobj = SWIG_From_int(static_cast< int >(result));
15014 return resultobj;
15015 fail:
15016 return NULL;
15017 }
15018
15019
15020 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15021 PyObject *resultobj = 0;
15022 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15023 int arg2 ;
15024 void *argp1 = 0 ;
15025 int res1 = 0 ;
15026 int val2 ;
15027 int ecode2 = 0 ;
15028 PyObject *swig_obj[2] ;
15029
15030 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15032 if (!SWIG_IsOK(res1)) {
15033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15034 }
15035 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15036 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15037 if (!SWIG_IsOK(ecode2)) {
15038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15039 }
15040 arg2 = static_cast< int >(val2);
15041 if (arg1) (arg1)->m_exitcode = arg2;
15042
15043 resultobj = SWIG_Py_Void();
15044 return resultobj;
15045 fail:
15046 return NULL;
15047 }
15048
15049
15050 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15051 PyObject *resultobj = 0;
15052 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15053 int result;
15054 void *argp1 = 0 ;
15055 int res1 = 0 ;
15056 PyObject *swig_obj[1] ;
15057
15058 if (!args) SWIG_fail;
15059 swig_obj[0] = args;
15060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15063 }
15064 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15065 result = (int) ((arg1)->m_exitcode);
15066 resultobj = SWIG_From_int(static_cast< int >(result));
15067 return resultobj;
15068 fail:
15069 return NULL;
15070 }
15071
15072
15073 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15074 PyObject *obj;
15075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15076 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15077 return SWIG_Py_Void();
15078 }
15079
15080 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15081 return SWIG_Python_InitShadowInstance(args);
15082 }
15083
15084 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15085 PyObject *resultobj = 0;
15086 wxString *arg1 = 0 ;
15087 int arg2 = (int) wxEXEC_ASYNC ;
15088 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15089 long result;
15090 bool temp1 = false ;
15091 int val2 ;
15092 int ecode2 = 0 ;
15093 void *argp3 = 0 ;
15094 int res3 = 0 ;
15095 PyObject * obj0 = 0 ;
15096 PyObject * obj1 = 0 ;
15097 PyObject * obj2 = 0 ;
15098 char * kwnames[] = {
15099 (char *) "command",(char *) "flags",(char *) "process", NULL
15100 };
15101
15102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15103 {
15104 arg1 = wxString_in_helper(obj0);
15105 if (arg1 == NULL) SWIG_fail;
15106 temp1 = true;
15107 }
15108 if (obj1) {
15109 ecode2 = SWIG_AsVal_int(obj1, &val2);
15110 if (!SWIG_IsOK(ecode2)) {
15111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15112 }
15113 arg2 = static_cast< int >(val2);
15114 }
15115 if (obj2) {
15116 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15117 if (!SWIG_IsOK(res3)) {
15118 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15119 }
15120 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15121 }
15122 {
15123 if (!wxPyCheckForApp()) SWIG_fail;
15124 PyThreadState* __tstate = wxPyBeginAllowThreads();
15125 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15126 wxPyEndAllowThreads(__tstate);
15127 if (PyErr_Occurred()) SWIG_fail;
15128 }
15129 resultobj = SWIG_From_long(static_cast< long >(result));
15130 {
15131 if (temp1)
15132 delete arg1;
15133 }
15134 return resultobj;
15135 fail:
15136 {
15137 if (temp1)
15138 delete arg1;
15139 }
15140 return NULL;
15141 }
15142
15143
15144 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj = 0;
15146 long arg1 ;
15147 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15148 wxKillError *arg3 = (wxKillError *) 0 ;
15149 int arg4 = (int) wxKILL_NOCHILDREN ;
15150 int result;
15151 long val1 ;
15152 int ecode1 = 0 ;
15153 int val2 ;
15154 int ecode2 = 0 ;
15155 wxKillError temp3 ;
15156 int val4 ;
15157 int ecode4 = 0 ;
15158 PyObject * obj0 = 0 ;
15159 PyObject * obj1 = 0 ;
15160 PyObject * obj2 = 0 ;
15161 char * kwnames[] = {
15162 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15163 };
15164
15165 {
15166 arg3 = &temp3;
15167 }
15168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15169 ecode1 = SWIG_AsVal_long(obj0, &val1);
15170 if (!SWIG_IsOK(ecode1)) {
15171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15172 }
15173 arg1 = static_cast< long >(val1);
15174 if (obj1) {
15175 ecode2 = SWIG_AsVal_int(obj1, &val2);
15176 if (!SWIG_IsOK(ecode2)) {
15177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15178 }
15179 arg2 = static_cast< wxSignal >(val2);
15180 }
15181 if (obj2) {
15182 ecode4 = SWIG_AsVal_int(obj2, &val4);
15183 if (!SWIG_IsOK(ecode4)) {
15184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15185 }
15186 arg4 = static_cast< int >(val4);
15187 }
15188 {
15189 PyThreadState* __tstate = wxPyBeginAllowThreads();
15190 result = (int)wxKill(arg1,arg2,arg3,arg4);
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 resultobj = SWIG_From_int(static_cast< int >(result));
15195 {
15196 PyObject* o;
15197 o = PyInt_FromLong((long) (*arg3));
15198
15199
15200
15201 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15202
15203 }
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj = 0;
15212 int arg1 = (int) wxJOYSTICK1 ;
15213 wxJoystick *result = 0 ;
15214 int val1 ;
15215 int ecode1 = 0 ;
15216 PyObject * obj0 = 0 ;
15217 char * kwnames[] = {
15218 (char *) "joystick", NULL
15219 };
15220
15221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15222 if (obj0) {
15223 ecode1 = SWIG_AsVal_int(obj0, &val1);
15224 if (!SWIG_IsOK(ecode1)) {
15225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15226 }
15227 arg1 = static_cast< int >(val1);
15228 }
15229 {
15230 if (!wxPyCheckForApp()) SWIG_fail;
15231 PyThreadState* __tstate = wxPyBeginAllowThreads();
15232 result = (wxJoystick *)new wxJoystick(arg1);
15233 wxPyEndAllowThreads(__tstate);
15234 if (PyErr_Occurred()) SWIG_fail;
15235 }
15236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15237 return resultobj;
15238 fail:
15239 return NULL;
15240 }
15241
15242
15243 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15244 PyObject *resultobj = 0;
15245 wxJoystick *arg1 = (wxJoystick *) 0 ;
15246 void *argp1 = 0 ;
15247 int res1 = 0 ;
15248 PyObject *swig_obj[1] ;
15249
15250 if (!args) SWIG_fail;
15251 swig_obj[0] = args;
15252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15253 if (!SWIG_IsOK(res1)) {
15254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15255 }
15256 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15257 {
15258 PyThreadState* __tstate = wxPyBeginAllowThreads();
15259 delete arg1;
15260
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 resultobj = SWIG_Py_Void();
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 wxJoystick *arg1 = (wxJoystick *) 0 ;
15274 wxPoint result;
15275 void *argp1 = 0 ;
15276 int res1 = 0 ;
15277 PyObject *swig_obj[1] ;
15278
15279 if (!args) SWIG_fail;
15280 swig_obj[0] = args;
15281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15282 if (!SWIG_IsOK(res1)) {
15283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15284 }
15285 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15286 {
15287 PyThreadState* __tstate = wxPyBeginAllowThreads();
15288 result = (arg1)->GetPosition();
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300 PyObject *resultobj = 0;
15301 wxJoystick *arg1 = (wxJoystick *) 0 ;
15302 int result;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 PyObject *swig_obj[1] ;
15306
15307 if (!args) SWIG_fail;
15308 swig_obj[0] = args;
15309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15310 if (!SWIG_IsOK(res1)) {
15311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15312 }
15313 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 result = (int)(arg1)->GetZPosition();
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 resultobj = SWIG_From_int(static_cast< int >(result));
15321 return resultobj;
15322 fail:
15323 return NULL;
15324 }
15325
15326
15327 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15328 PyObject *resultobj = 0;
15329 wxJoystick *arg1 = (wxJoystick *) 0 ;
15330 int result;
15331 void *argp1 = 0 ;
15332 int res1 = 0 ;
15333 PyObject *swig_obj[1] ;
15334
15335 if (!args) SWIG_fail;
15336 swig_obj[0] = args;
15337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15340 }
15341 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (int)(arg1)->GetButtonState();
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 resultobj = SWIG_From_int(static_cast< int >(result));
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15356 PyObject *resultobj = 0;
15357 wxJoystick *arg1 = (wxJoystick *) 0 ;
15358 int result;
15359 void *argp1 = 0 ;
15360 int res1 = 0 ;
15361 PyObject *swig_obj[1] ;
15362
15363 if (!args) SWIG_fail;
15364 swig_obj[0] = args;
15365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15366 if (!SWIG_IsOK(res1)) {
15367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15368 }
15369 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (int)(arg1)->GetPOVPosition();
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = SWIG_From_int(static_cast< int >(result));
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxJoystick *arg1 = (wxJoystick *) 0 ;
15386 int result;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15396 }
15397 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (int)(arg1)->GetPOVCTSPosition();
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = SWIG_From_int(static_cast< int >(result));
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15412 PyObject *resultobj = 0;
15413 wxJoystick *arg1 = (wxJoystick *) 0 ;
15414 int result;
15415 void *argp1 = 0 ;
15416 int res1 = 0 ;
15417 PyObject *swig_obj[1] ;
15418
15419 if (!args) SWIG_fail;
15420 swig_obj[0] = args;
15421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15422 if (!SWIG_IsOK(res1)) {
15423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15424 }
15425 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15426 {
15427 PyThreadState* __tstate = wxPyBeginAllowThreads();
15428 result = (int)(arg1)->GetRudderPosition();
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 resultobj = SWIG_From_int(static_cast< int >(result));
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440 PyObject *resultobj = 0;
15441 wxJoystick *arg1 = (wxJoystick *) 0 ;
15442 int result;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 PyObject *swig_obj[1] ;
15446
15447 if (!args) SWIG_fail;
15448 swig_obj[0] = args;
15449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15450 if (!SWIG_IsOK(res1)) {
15451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15452 }
15453 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15454 {
15455 PyThreadState* __tstate = wxPyBeginAllowThreads();
15456 result = (int)(arg1)->GetUPosition();
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 resultobj = SWIG_From_int(static_cast< int >(result));
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15468 PyObject *resultobj = 0;
15469 wxJoystick *arg1 = (wxJoystick *) 0 ;
15470 int result;
15471 void *argp1 = 0 ;
15472 int res1 = 0 ;
15473 PyObject *swig_obj[1] ;
15474
15475 if (!args) SWIG_fail;
15476 swig_obj[0] = args;
15477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15478 if (!SWIG_IsOK(res1)) {
15479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15480 }
15481 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (int)(arg1)->GetVPosition();
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 resultobj = SWIG_From_int(static_cast< int >(result));
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15496 PyObject *resultobj = 0;
15497 wxJoystick *arg1 = (wxJoystick *) 0 ;
15498 int result;
15499 void *argp1 = 0 ;
15500 int res1 = 0 ;
15501 PyObject *swig_obj[1] ;
15502
15503 if (!args) SWIG_fail;
15504 swig_obj[0] = args;
15505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15506 if (!SWIG_IsOK(res1)) {
15507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15508 }
15509 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 result = (int)(arg1)->GetMovementThreshold();
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_From_int(static_cast< int >(result));
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15524 PyObject *resultobj = 0;
15525 wxJoystick *arg1 = (wxJoystick *) 0 ;
15526 int arg2 ;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 int val2 ;
15530 int ecode2 = 0 ;
15531 PyObject * obj0 = 0 ;
15532 PyObject * obj1 = 0 ;
15533 char * kwnames[] = {
15534 (char *) "self",(char *) "threshold", NULL
15535 };
15536
15537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15539 if (!SWIG_IsOK(res1)) {
15540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15541 }
15542 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15543 ecode2 = SWIG_AsVal_int(obj1, &val2);
15544 if (!SWIG_IsOK(ecode2)) {
15545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15546 }
15547 arg2 = static_cast< int >(val2);
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 (arg1)->SetMovementThreshold(arg2);
15551 wxPyEndAllowThreads(__tstate);
15552 if (PyErr_Occurred()) SWIG_fail;
15553 }
15554 resultobj = SWIG_Py_Void();
15555 return resultobj;
15556 fail:
15557 return NULL;
15558 }
15559
15560
15561 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15562 PyObject *resultobj = 0;
15563 wxJoystick *arg1 = (wxJoystick *) 0 ;
15564 bool result;
15565 void *argp1 = 0 ;
15566 int res1 = 0 ;
15567 PyObject *swig_obj[1] ;
15568
15569 if (!args) SWIG_fail;
15570 swig_obj[0] = args;
15571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15572 if (!SWIG_IsOK(res1)) {
15573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15574 }
15575 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 result = (bool)(arg1)->IsOk();
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 {
15583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15584 }
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15592 PyObject *resultobj = 0;
15593 wxJoystick *arg1 = (wxJoystick *) 0 ;
15594 int result;
15595 void *argp1 = 0 ;
15596 int res1 = 0 ;
15597 PyObject *swig_obj[1] ;
15598
15599 if (!args) SWIG_fail;
15600 swig_obj[0] = args;
15601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15602 if (!SWIG_IsOK(res1)) {
15603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15604 }
15605 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 result = (int)(arg1)->GetNumberJoysticks();
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 resultobj = SWIG_From_int(static_cast< int >(result));
15613 return resultobj;
15614 fail:
15615 return NULL;
15616 }
15617
15618
15619 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15620 PyObject *resultobj = 0;
15621 wxJoystick *arg1 = (wxJoystick *) 0 ;
15622 int result;
15623 void *argp1 = 0 ;
15624 int res1 = 0 ;
15625 PyObject *swig_obj[1] ;
15626
15627 if (!args) SWIG_fail;
15628 swig_obj[0] = args;
15629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15630 if (!SWIG_IsOK(res1)) {
15631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15632 }
15633 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = (int)(arg1)->GetManufacturerId();
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 resultobj = SWIG_From_int(static_cast< int >(result));
15641 return resultobj;
15642 fail:
15643 return NULL;
15644 }
15645
15646
15647 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15648 PyObject *resultobj = 0;
15649 wxJoystick *arg1 = (wxJoystick *) 0 ;
15650 int result;
15651 void *argp1 = 0 ;
15652 int res1 = 0 ;
15653 PyObject *swig_obj[1] ;
15654
15655 if (!args) SWIG_fail;
15656 swig_obj[0] = args;
15657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15658 if (!SWIG_IsOK(res1)) {
15659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15660 }
15661 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (int)(arg1)->GetProductId();
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 resultobj = SWIG_From_int(static_cast< int >(result));
15669 return resultobj;
15670 fail:
15671 return NULL;
15672 }
15673
15674
15675 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15676 PyObject *resultobj = 0;
15677 wxJoystick *arg1 = (wxJoystick *) 0 ;
15678 wxString result;
15679 void *argp1 = 0 ;
15680 int res1 = 0 ;
15681 PyObject *swig_obj[1] ;
15682
15683 if (!args) SWIG_fail;
15684 swig_obj[0] = args;
15685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15686 if (!SWIG_IsOK(res1)) {
15687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15688 }
15689 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 result = (arg1)->GetProductName();
15693 wxPyEndAllowThreads(__tstate);
15694 if (PyErr_Occurred()) SWIG_fail;
15695 }
15696 {
15697 #if wxUSE_UNICODE
15698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15699 #else
15700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15701 #endif
15702 }
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxJoystick *arg1 = (wxJoystick *) 0 ;
15712 int result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15722 }
15723 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (int)(arg1)->GetXMin();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 resultobj = SWIG_From_int(static_cast< int >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxJoystick *arg1 = (wxJoystick *) 0 ;
15740 int result;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 PyObject *swig_obj[1] ;
15744
15745 if (!args) SWIG_fail;
15746 swig_obj[0] = args;
15747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15750 }
15751 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (int)(arg1)->GetYMin();
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_From_int(static_cast< int >(result));
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxJoystick *arg1 = (wxJoystick *) 0 ;
15768 int result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15778 }
15779 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (int)(arg1)->GetZMin();
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_From_int(static_cast< int >(result));
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxJoystick *arg1 = (wxJoystick *) 0 ;
15796 int result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15806 }
15807 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (int)(arg1)->GetXMax();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_From_int(static_cast< int >(result));
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxJoystick *arg1 = (wxJoystick *) 0 ;
15824 int result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15834 }
15835 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (int)(arg1)->GetYMax();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_int(static_cast< int >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15850 PyObject *resultobj = 0;
15851 wxJoystick *arg1 = (wxJoystick *) 0 ;
15852 int result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 PyObject *swig_obj[1] ;
15856
15857 if (!args) SWIG_fail;
15858 swig_obj[0] = args;
15859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15860 if (!SWIG_IsOK(res1)) {
15861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15862 }
15863 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (int)(arg1)->GetZMax();
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_From_int(static_cast< int >(result));
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxJoystick *arg1 = (wxJoystick *) 0 ;
15880 int result;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 PyObject *swig_obj[1] ;
15884
15885 if (!args) SWIG_fail;
15886 swig_obj[0] = args;
15887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15890 }
15891 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (int)(arg1)->GetNumberButtons();
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_From_int(static_cast< int >(result));
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15906 PyObject *resultobj = 0;
15907 wxJoystick *arg1 = (wxJoystick *) 0 ;
15908 int result;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 PyObject *swig_obj[1] ;
15912
15913 if (!args) SWIG_fail;
15914 swig_obj[0] = args;
15915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15918 }
15919 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (int)(arg1)->GetNumberAxes();
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 resultobj = SWIG_From_int(static_cast< int >(result));
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15934 PyObject *resultobj = 0;
15935 wxJoystick *arg1 = (wxJoystick *) 0 ;
15936 int result;
15937 void *argp1 = 0 ;
15938 int res1 = 0 ;
15939 PyObject *swig_obj[1] ;
15940
15941 if (!args) SWIG_fail;
15942 swig_obj[0] = args;
15943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15946 }
15947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (int)(arg1)->GetMaxButtons();
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_From_int(static_cast< int >(result));
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxJoystick *arg1 = (wxJoystick *) 0 ;
15964 int result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject *swig_obj[1] ;
15968
15969 if (!args) SWIG_fail;
15970 swig_obj[0] = args;
15971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15974 }
15975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 result = (int)(arg1)->GetMaxAxes();
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 resultobj = SWIG_From_int(static_cast< int >(result));
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15990 PyObject *resultobj = 0;
15991 wxJoystick *arg1 = (wxJoystick *) 0 ;
15992 int result;
15993 void *argp1 = 0 ;
15994 int res1 = 0 ;
15995 PyObject *swig_obj[1] ;
15996
15997 if (!args) SWIG_fail;
15998 swig_obj[0] = args;
15999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16002 }
16003 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (int)(arg1)->GetPollingMin();
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 resultobj = SWIG_From_int(static_cast< int >(result));
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16018 PyObject *resultobj = 0;
16019 wxJoystick *arg1 = (wxJoystick *) 0 ;
16020 int result;
16021 void *argp1 = 0 ;
16022 int res1 = 0 ;
16023 PyObject *swig_obj[1] ;
16024
16025 if (!args) SWIG_fail;
16026 swig_obj[0] = args;
16027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16028 if (!SWIG_IsOK(res1)) {
16029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16030 }
16031 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 result = (int)(arg1)->GetPollingMax();
16035 wxPyEndAllowThreads(__tstate);
16036 if (PyErr_Occurred()) SWIG_fail;
16037 }
16038 resultobj = SWIG_From_int(static_cast< int >(result));
16039 return resultobj;
16040 fail:
16041 return NULL;
16042 }
16043
16044
16045 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16046 PyObject *resultobj = 0;
16047 wxJoystick *arg1 = (wxJoystick *) 0 ;
16048 int result;
16049 void *argp1 = 0 ;
16050 int res1 = 0 ;
16051 PyObject *swig_obj[1] ;
16052
16053 if (!args) SWIG_fail;
16054 swig_obj[0] = args;
16055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16056 if (!SWIG_IsOK(res1)) {
16057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16058 }
16059 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16060 {
16061 PyThreadState* __tstate = wxPyBeginAllowThreads();
16062 result = (int)(arg1)->GetRudderMin();
16063 wxPyEndAllowThreads(__tstate);
16064 if (PyErr_Occurred()) SWIG_fail;
16065 }
16066 resultobj = SWIG_From_int(static_cast< int >(result));
16067 return resultobj;
16068 fail:
16069 return NULL;
16070 }
16071
16072
16073 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16074 PyObject *resultobj = 0;
16075 wxJoystick *arg1 = (wxJoystick *) 0 ;
16076 int result;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 PyObject *swig_obj[1] ;
16080
16081 if (!args) SWIG_fail;
16082 swig_obj[0] = args;
16083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16084 if (!SWIG_IsOK(res1)) {
16085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16086 }
16087 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16088 {
16089 PyThreadState* __tstate = wxPyBeginAllowThreads();
16090 result = (int)(arg1)->GetRudderMax();
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = SWIG_From_int(static_cast< int >(result));
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16102 PyObject *resultobj = 0;
16103 wxJoystick *arg1 = (wxJoystick *) 0 ;
16104 int result;
16105 void *argp1 = 0 ;
16106 int res1 = 0 ;
16107 PyObject *swig_obj[1] ;
16108
16109 if (!args) SWIG_fail;
16110 swig_obj[0] = args;
16111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16112 if (!SWIG_IsOK(res1)) {
16113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16114 }
16115 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16116 {
16117 PyThreadState* __tstate = wxPyBeginAllowThreads();
16118 result = (int)(arg1)->GetUMin();
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 resultobj = SWIG_From_int(static_cast< int >(result));
16123 return resultobj;
16124 fail:
16125 return NULL;
16126 }
16127
16128
16129 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16130 PyObject *resultobj = 0;
16131 wxJoystick *arg1 = (wxJoystick *) 0 ;
16132 int result;
16133 void *argp1 = 0 ;
16134 int res1 = 0 ;
16135 PyObject *swig_obj[1] ;
16136
16137 if (!args) SWIG_fail;
16138 swig_obj[0] = args;
16139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16140 if (!SWIG_IsOK(res1)) {
16141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16142 }
16143 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 result = (int)(arg1)->GetUMax();
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 resultobj = SWIG_From_int(static_cast< int >(result));
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16158 PyObject *resultobj = 0;
16159 wxJoystick *arg1 = (wxJoystick *) 0 ;
16160 int result;
16161 void *argp1 = 0 ;
16162 int res1 = 0 ;
16163 PyObject *swig_obj[1] ;
16164
16165 if (!args) SWIG_fail;
16166 swig_obj[0] = args;
16167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16168 if (!SWIG_IsOK(res1)) {
16169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16170 }
16171 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16172 {
16173 PyThreadState* __tstate = wxPyBeginAllowThreads();
16174 result = (int)(arg1)->GetVMin();
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 resultobj = SWIG_From_int(static_cast< int >(result));
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16186 PyObject *resultobj = 0;
16187 wxJoystick *arg1 = (wxJoystick *) 0 ;
16188 int result;
16189 void *argp1 = 0 ;
16190 int res1 = 0 ;
16191 PyObject *swig_obj[1] ;
16192
16193 if (!args) SWIG_fail;
16194 swig_obj[0] = args;
16195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16196 if (!SWIG_IsOK(res1)) {
16197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16198 }
16199 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 result = (int)(arg1)->GetVMax();
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_From_int(static_cast< int >(result));
16207 return resultobj;
16208 fail:
16209 return NULL;
16210 }
16211
16212
16213 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16214 PyObject *resultobj = 0;
16215 wxJoystick *arg1 = (wxJoystick *) 0 ;
16216 bool result;
16217 void *argp1 = 0 ;
16218 int res1 = 0 ;
16219 PyObject *swig_obj[1] ;
16220
16221 if (!args) SWIG_fail;
16222 swig_obj[0] = args;
16223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16226 }
16227 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16228 {
16229 PyThreadState* __tstate = wxPyBeginAllowThreads();
16230 result = (bool)(arg1)->HasRudder();
16231 wxPyEndAllowThreads(__tstate);
16232 if (PyErr_Occurred()) SWIG_fail;
16233 }
16234 {
16235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16236 }
16237 return resultobj;
16238 fail:
16239 return NULL;
16240 }
16241
16242
16243 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16244 PyObject *resultobj = 0;
16245 wxJoystick *arg1 = (wxJoystick *) 0 ;
16246 bool result;
16247 void *argp1 = 0 ;
16248 int res1 = 0 ;
16249 PyObject *swig_obj[1] ;
16250
16251 if (!args) SWIG_fail;
16252 swig_obj[0] = args;
16253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16254 if (!SWIG_IsOK(res1)) {
16255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16256 }
16257 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = (bool)(arg1)->HasZ();
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 {
16265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16266 }
16267 return resultobj;
16268 fail:
16269 return NULL;
16270 }
16271
16272
16273 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16274 PyObject *resultobj = 0;
16275 wxJoystick *arg1 = (wxJoystick *) 0 ;
16276 bool result;
16277 void *argp1 = 0 ;
16278 int res1 = 0 ;
16279 PyObject *swig_obj[1] ;
16280
16281 if (!args) SWIG_fail;
16282 swig_obj[0] = args;
16283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16284 if (!SWIG_IsOK(res1)) {
16285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16286 }
16287 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 result = (bool)(arg1)->HasU();
16291 wxPyEndAllowThreads(__tstate);
16292 if (PyErr_Occurred()) SWIG_fail;
16293 }
16294 {
16295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16296 }
16297 return resultobj;
16298 fail:
16299 return NULL;
16300 }
16301
16302
16303 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16304 PyObject *resultobj = 0;
16305 wxJoystick *arg1 = (wxJoystick *) 0 ;
16306 bool result;
16307 void *argp1 = 0 ;
16308 int res1 = 0 ;
16309 PyObject *swig_obj[1] ;
16310
16311 if (!args) SWIG_fail;
16312 swig_obj[0] = args;
16313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16314 if (!SWIG_IsOK(res1)) {
16315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16316 }
16317 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16318 {
16319 PyThreadState* __tstate = wxPyBeginAllowThreads();
16320 result = (bool)(arg1)->HasV();
16321 wxPyEndAllowThreads(__tstate);
16322 if (PyErr_Occurred()) SWIG_fail;
16323 }
16324 {
16325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16326 }
16327 return resultobj;
16328 fail:
16329 return NULL;
16330 }
16331
16332
16333 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16334 PyObject *resultobj = 0;
16335 wxJoystick *arg1 = (wxJoystick *) 0 ;
16336 bool result;
16337 void *argp1 = 0 ;
16338 int res1 = 0 ;
16339 PyObject *swig_obj[1] ;
16340
16341 if (!args) SWIG_fail;
16342 swig_obj[0] = args;
16343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16344 if (!SWIG_IsOK(res1)) {
16345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16346 }
16347 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16348 {
16349 PyThreadState* __tstate = wxPyBeginAllowThreads();
16350 result = (bool)(arg1)->HasPOV();
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 {
16355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16356 }
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16364 PyObject *resultobj = 0;
16365 wxJoystick *arg1 = (wxJoystick *) 0 ;
16366 bool result;
16367 void *argp1 = 0 ;
16368 int res1 = 0 ;
16369 PyObject *swig_obj[1] ;
16370
16371 if (!args) SWIG_fail;
16372 swig_obj[0] = args;
16373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16374 if (!SWIG_IsOK(res1)) {
16375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16376 }
16377 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16378 {
16379 PyThreadState* __tstate = wxPyBeginAllowThreads();
16380 result = (bool)(arg1)->HasPOV4Dir();
16381 wxPyEndAllowThreads(__tstate);
16382 if (PyErr_Occurred()) SWIG_fail;
16383 }
16384 {
16385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16386 }
16387 return resultobj;
16388 fail:
16389 return NULL;
16390 }
16391
16392
16393 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16394 PyObject *resultobj = 0;
16395 wxJoystick *arg1 = (wxJoystick *) 0 ;
16396 bool result;
16397 void *argp1 = 0 ;
16398 int res1 = 0 ;
16399 PyObject *swig_obj[1] ;
16400
16401 if (!args) SWIG_fail;
16402 swig_obj[0] = args;
16403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16404 if (!SWIG_IsOK(res1)) {
16405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16406 }
16407 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16408 {
16409 PyThreadState* __tstate = wxPyBeginAllowThreads();
16410 result = (bool)(arg1)->HasPOVCTS();
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 {
16415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16416 }
16417 return resultobj;
16418 fail:
16419 return NULL;
16420 }
16421
16422
16423 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16424 PyObject *resultobj = 0;
16425 wxJoystick *arg1 = (wxJoystick *) 0 ;
16426 wxWindow *arg2 = (wxWindow *) 0 ;
16427 int arg3 = (int) 0 ;
16428 bool result;
16429 void *argp1 = 0 ;
16430 int res1 = 0 ;
16431 void *argp2 = 0 ;
16432 int res2 = 0 ;
16433 int val3 ;
16434 int ecode3 = 0 ;
16435 PyObject * obj0 = 0 ;
16436 PyObject * obj1 = 0 ;
16437 PyObject * obj2 = 0 ;
16438 char * kwnames[] = {
16439 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16440 };
16441
16442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16444 if (!SWIG_IsOK(res1)) {
16445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16446 }
16447 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16448 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16449 if (!SWIG_IsOK(res2)) {
16450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16451 }
16452 arg2 = reinterpret_cast< wxWindow * >(argp2);
16453 if (obj2) {
16454 ecode3 = SWIG_AsVal_int(obj2, &val3);
16455 if (!SWIG_IsOK(ecode3)) {
16456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16457 }
16458 arg3 = static_cast< int >(val3);
16459 }
16460 {
16461 PyThreadState* __tstate = wxPyBeginAllowThreads();
16462 result = (bool)(arg1)->SetCapture(arg2,arg3);
16463 wxPyEndAllowThreads(__tstate);
16464 if (PyErr_Occurred()) SWIG_fail;
16465 }
16466 {
16467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16468 }
16469 return resultobj;
16470 fail:
16471 return NULL;
16472 }
16473
16474
16475 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16476 PyObject *resultobj = 0;
16477 wxJoystick *arg1 = (wxJoystick *) 0 ;
16478 bool result;
16479 void *argp1 = 0 ;
16480 int res1 = 0 ;
16481 PyObject *swig_obj[1] ;
16482
16483 if (!args) SWIG_fail;
16484 swig_obj[0] = args;
16485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16486 if (!SWIG_IsOK(res1)) {
16487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16488 }
16489 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = (bool)(arg1)->ReleaseCapture();
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 {
16497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16498 }
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16506 PyObject *obj;
16507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16508 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16509 return SWIG_Py_Void();
16510 }
16511
16512 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16513 return SWIG_Python_InitShadowInstance(args);
16514 }
16515
16516 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16517 PyObject *resultobj = 0;
16518 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16519 int arg2 = (int) 0 ;
16520 int arg3 = (int) wxJOYSTICK1 ;
16521 int arg4 = (int) 0 ;
16522 wxJoystickEvent *result = 0 ;
16523 int val1 ;
16524 int ecode1 = 0 ;
16525 int val2 ;
16526 int ecode2 = 0 ;
16527 int val3 ;
16528 int ecode3 = 0 ;
16529 int val4 ;
16530 int ecode4 = 0 ;
16531 PyObject * obj0 = 0 ;
16532 PyObject * obj1 = 0 ;
16533 PyObject * obj2 = 0 ;
16534 PyObject * obj3 = 0 ;
16535 char * kwnames[] = {
16536 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16537 };
16538
16539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16540 if (obj0) {
16541 ecode1 = SWIG_AsVal_int(obj0, &val1);
16542 if (!SWIG_IsOK(ecode1)) {
16543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16544 }
16545 arg1 = static_cast< wxEventType >(val1);
16546 }
16547 if (obj1) {
16548 ecode2 = SWIG_AsVal_int(obj1, &val2);
16549 if (!SWIG_IsOK(ecode2)) {
16550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16551 }
16552 arg2 = static_cast< int >(val2);
16553 }
16554 if (obj2) {
16555 ecode3 = SWIG_AsVal_int(obj2, &val3);
16556 if (!SWIG_IsOK(ecode3)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16558 }
16559 arg3 = static_cast< int >(val3);
16560 }
16561 if (obj3) {
16562 ecode4 = SWIG_AsVal_int(obj3, &val4);
16563 if (!SWIG_IsOK(ecode4)) {
16564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16565 }
16566 arg4 = static_cast< int >(val4);
16567 }
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16582 PyObject *resultobj = 0;
16583 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16584 wxPoint result;
16585 void *argp1 = 0 ;
16586 int res1 = 0 ;
16587 PyObject *swig_obj[1] ;
16588
16589 if (!args) SWIG_fail;
16590 swig_obj[0] = args;
16591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16592 if (!SWIG_IsOK(res1)) {
16593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16594 }
16595 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16610 PyObject *resultobj = 0;
16611 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16612 int result;
16613 void *argp1 = 0 ;
16614 int res1 = 0 ;
16615 PyObject *swig_obj[1] ;
16616
16617 if (!args) SWIG_fail;
16618 swig_obj[0] = args;
16619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16620 if (!SWIG_IsOK(res1)) {
16621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16622 }
16623 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 resultobj = SWIG_From_int(static_cast< int >(result));
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16638 PyObject *resultobj = 0;
16639 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16640 int result;
16641 void *argp1 = 0 ;
16642 int res1 = 0 ;
16643 PyObject *swig_obj[1] ;
16644
16645 if (!args) SWIG_fail;
16646 swig_obj[0] = args;
16647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16648 if (!SWIG_IsOK(res1)) {
16649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16650 }
16651 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 resultobj = SWIG_From_int(static_cast< int >(result));
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16666 PyObject *resultobj = 0;
16667 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16668 int result;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 PyObject *swig_obj[1] ;
16672
16673 if (!args) SWIG_fail;
16674 swig_obj[0] = args;
16675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16676 if (!SWIG_IsOK(res1)) {
16677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16678 }
16679 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_From_int(static_cast< int >(result));
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16694 PyObject *resultobj = 0;
16695 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16696 int result;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 PyObject *swig_obj[1] ;
16700
16701 if (!args) SWIG_fail;
16702 swig_obj[0] = args;
16703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16704 if (!SWIG_IsOK(res1)) {
16705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16706 }
16707 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 resultobj = SWIG_From_int(static_cast< int >(result));
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16722 PyObject *resultobj = 0;
16723 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16724 int arg2 ;
16725 void *argp1 = 0 ;
16726 int res1 = 0 ;
16727 int val2 ;
16728 int ecode2 = 0 ;
16729 PyObject * obj0 = 0 ;
16730 PyObject * obj1 = 0 ;
16731 char * kwnames[] = {
16732 (char *) "self",(char *) "stick", NULL
16733 };
16734
16735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16737 if (!SWIG_IsOK(res1)) {
16738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16739 }
16740 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16741 ecode2 = SWIG_AsVal_int(obj1, &val2);
16742 if (!SWIG_IsOK(ecode2)) {
16743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16744 }
16745 arg2 = static_cast< int >(val2);
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 (arg1)->SetJoystick(arg2);
16749 wxPyEndAllowThreads(__tstate);
16750 if (PyErr_Occurred()) SWIG_fail;
16751 }
16752 resultobj = SWIG_Py_Void();
16753 return resultobj;
16754 fail:
16755 return NULL;
16756 }
16757
16758
16759 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16760 PyObject *resultobj = 0;
16761 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16762 int arg2 ;
16763 void *argp1 = 0 ;
16764 int res1 = 0 ;
16765 int val2 ;
16766 int ecode2 = 0 ;
16767 PyObject * obj0 = 0 ;
16768 PyObject * obj1 = 0 ;
16769 char * kwnames[] = {
16770 (char *) "self",(char *) "state", NULL
16771 };
16772
16773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16775 if (!SWIG_IsOK(res1)) {
16776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16777 }
16778 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16779 ecode2 = SWIG_AsVal_int(obj1, &val2);
16780 if (!SWIG_IsOK(ecode2)) {
16781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16782 }
16783 arg2 = static_cast< int >(val2);
16784 {
16785 PyThreadState* __tstate = wxPyBeginAllowThreads();
16786 (arg1)->SetButtonState(arg2);
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 resultobj = SWIG_Py_Void();
16791 return resultobj;
16792 fail:
16793 return NULL;
16794 }
16795
16796
16797 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16798 PyObject *resultobj = 0;
16799 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16800 int arg2 ;
16801 void *argp1 = 0 ;
16802 int res1 = 0 ;
16803 int val2 ;
16804 int ecode2 = 0 ;
16805 PyObject * obj0 = 0 ;
16806 PyObject * obj1 = 0 ;
16807 char * kwnames[] = {
16808 (char *) "self",(char *) "change", NULL
16809 };
16810
16811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16813 if (!SWIG_IsOK(res1)) {
16814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16815 }
16816 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16817 ecode2 = SWIG_AsVal_int(obj1, &val2);
16818 if (!SWIG_IsOK(ecode2)) {
16819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16820 }
16821 arg2 = static_cast< int >(val2);
16822 {
16823 PyThreadState* __tstate = wxPyBeginAllowThreads();
16824 (arg1)->SetButtonChange(arg2);
16825 wxPyEndAllowThreads(__tstate);
16826 if (PyErr_Occurred()) SWIG_fail;
16827 }
16828 resultobj = SWIG_Py_Void();
16829 return resultobj;
16830 fail:
16831 return NULL;
16832 }
16833
16834
16835 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16836 PyObject *resultobj = 0;
16837 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16838 wxPoint *arg2 = 0 ;
16839 void *argp1 = 0 ;
16840 int res1 = 0 ;
16841 wxPoint temp2 ;
16842 PyObject * obj0 = 0 ;
16843 PyObject * obj1 = 0 ;
16844 char * kwnames[] = {
16845 (char *) "self",(char *) "pos", NULL
16846 };
16847
16848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16850 if (!SWIG_IsOK(res1)) {
16851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16852 }
16853 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16854 {
16855 arg2 = &temp2;
16856 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16857 }
16858 {
16859 PyThreadState* __tstate = wxPyBeginAllowThreads();
16860 (arg1)->SetPosition((wxPoint const &)*arg2);
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 resultobj = SWIG_Py_Void();
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16872 PyObject *resultobj = 0;
16873 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16874 int arg2 ;
16875 void *argp1 = 0 ;
16876 int res1 = 0 ;
16877 int val2 ;
16878 int ecode2 = 0 ;
16879 PyObject * obj0 = 0 ;
16880 PyObject * obj1 = 0 ;
16881 char * kwnames[] = {
16882 (char *) "self",(char *) "zPos", NULL
16883 };
16884
16885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16887 if (!SWIG_IsOK(res1)) {
16888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16889 }
16890 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16891 ecode2 = SWIG_AsVal_int(obj1, &val2);
16892 if (!SWIG_IsOK(ecode2)) {
16893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16894 }
16895 arg2 = static_cast< int >(val2);
16896 {
16897 PyThreadState* __tstate = wxPyBeginAllowThreads();
16898 (arg1)->SetZPosition(arg2);
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 resultobj = SWIG_Py_Void();
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16910 PyObject *resultobj = 0;
16911 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16912 bool result;
16913 void *argp1 = 0 ;
16914 int res1 = 0 ;
16915 PyObject *swig_obj[1] ;
16916
16917 if (!args) SWIG_fail;
16918 swig_obj[0] = args;
16919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16920 if (!SWIG_IsOK(res1)) {
16921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16922 }
16923 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 {
16931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16932 }
16933 return resultobj;
16934 fail:
16935 return NULL;
16936 }
16937
16938
16939 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16940 PyObject *resultobj = 0;
16941 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16942 bool result;
16943 void *argp1 = 0 ;
16944 int res1 = 0 ;
16945 PyObject *swig_obj[1] ;
16946
16947 if (!args) SWIG_fail;
16948 swig_obj[0] = args;
16949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16950 if (!SWIG_IsOK(res1)) {
16951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16952 }
16953 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16954 {
16955 PyThreadState* __tstate = wxPyBeginAllowThreads();
16956 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16957 wxPyEndAllowThreads(__tstate);
16958 if (PyErr_Occurred()) SWIG_fail;
16959 }
16960 {
16961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16962 }
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16970 PyObject *resultobj = 0;
16971 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16972 bool result;
16973 void *argp1 = 0 ;
16974 int res1 = 0 ;
16975 PyObject *swig_obj[1] ;
16976
16977 if (!args) SWIG_fail;
16978 swig_obj[0] = args;
16979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16980 if (!SWIG_IsOK(res1)) {
16981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16982 }
16983 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16987 wxPyEndAllowThreads(__tstate);
16988 if (PyErr_Occurred()) SWIG_fail;
16989 }
16990 {
16991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16992 }
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17000 PyObject *resultobj = 0;
17001 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17002 int arg2 = (int) wxJOY_BUTTON_ANY ;
17003 bool result;
17004 void *argp1 = 0 ;
17005 int res1 = 0 ;
17006 int val2 ;
17007 int ecode2 = 0 ;
17008 PyObject * obj0 = 0 ;
17009 PyObject * obj1 = 0 ;
17010 char * kwnames[] = {
17011 (char *) "self",(char *) "but", NULL
17012 };
17013
17014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17016 if (!SWIG_IsOK(res1)) {
17017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17018 }
17019 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17020 if (obj1) {
17021 ecode2 = SWIG_AsVal_int(obj1, &val2);
17022 if (!SWIG_IsOK(ecode2)) {
17023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17024 }
17025 arg2 = static_cast< int >(val2);
17026 }
17027 {
17028 PyThreadState* __tstate = wxPyBeginAllowThreads();
17029 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 {
17034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17035 }
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj = 0;
17044 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17045 int arg2 = (int) wxJOY_BUTTON_ANY ;
17046 bool result;
17047 void *argp1 = 0 ;
17048 int res1 = 0 ;
17049 int val2 ;
17050 int ecode2 = 0 ;
17051 PyObject * obj0 = 0 ;
17052 PyObject * obj1 = 0 ;
17053 char * kwnames[] = {
17054 (char *) "self",(char *) "but", NULL
17055 };
17056
17057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17059 if (!SWIG_IsOK(res1)) {
17060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17061 }
17062 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17063 if (obj1) {
17064 ecode2 = SWIG_AsVal_int(obj1, &val2);
17065 if (!SWIG_IsOK(ecode2)) {
17066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17067 }
17068 arg2 = static_cast< int >(val2);
17069 }
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17073 wxPyEndAllowThreads(__tstate);
17074 if (PyErr_Occurred()) SWIG_fail;
17075 }
17076 {
17077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17078 }
17079 return resultobj;
17080 fail:
17081 return NULL;
17082 }
17083
17084
17085 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17086 PyObject *resultobj = 0;
17087 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17088 int arg2 = (int) wxJOY_BUTTON_ANY ;
17089 bool result;
17090 void *argp1 = 0 ;
17091 int res1 = 0 ;
17092 int val2 ;
17093 int ecode2 = 0 ;
17094 PyObject * obj0 = 0 ;
17095 PyObject * obj1 = 0 ;
17096 char * kwnames[] = {
17097 (char *) "self",(char *) "but", NULL
17098 };
17099
17100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17102 if (!SWIG_IsOK(res1)) {
17103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17104 }
17105 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17106 if (obj1) {
17107 ecode2 = SWIG_AsVal_int(obj1, &val2);
17108 if (!SWIG_IsOK(ecode2)) {
17109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17110 }
17111 arg2 = static_cast< int >(val2);
17112 }
17113 {
17114 PyThreadState* __tstate = wxPyBeginAllowThreads();
17115 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17116 wxPyEndAllowThreads(__tstate);
17117 if (PyErr_Occurred()) SWIG_fail;
17118 }
17119 {
17120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17121 }
17122 return resultobj;
17123 fail:
17124 return NULL;
17125 }
17126
17127
17128 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17129 PyObject *obj;
17130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17131 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17132 return SWIG_Py_Void();
17133 }
17134
17135 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17136 return SWIG_Python_InitShadowInstance(args);
17137 }
17138
17139 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj = 0;
17141 wxString const &arg1_defvalue = wxPyEmptyString ;
17142 wxString *arg1 = (wxString *) &arg1_defvalue ;
17143 wxSound *result = 0 ;
17144 bool temp1 = false ;
17145 PyObject * obj0 = 0 ;
17146 char * kwnames[] = {
17147 (char *) "fileName", NULL
17148 };
17149
17150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17151 if (obj0) {
17152 {
17153 arg1 = wxString_in_helper(obj0);
17154 if (arg1 == NULL) SWIG_fail;
17155 temp1 = true;
17156 }
17157 }
17158 {
17159 if (!wxPyCheckForApp()) SWIG_fail;
17160 PyThreadState* __tstate = wxPyBeginAllowThreads();
17161 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17162 wxPyEndAllowThreads(__tstate);
17163 if (PyErr_Occurred()) SWIG_fail;
17164 }
17165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17166 {
17167 if (temp1)
17168 delete arg1;
17169 }
17170 return resultobj;
17171 fail:
17172 {
17173 if (temp1)
17174 delete arg1;
17175 }
17176 return NULL;
17177 }
17178
17179
17180 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17181 PyObject *resultobj = 0;
17182 PyObject *arg1 = (PyObject *) 0 ;
17183 wxSound *result = 0 ;
17184 PyObject * obj0 = 0 ;
17185 char * kwnames[] = {
17186 (char *) "data", NULL
17187 };
17188
17189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17190 arg1 = obj0;
17191 {
17192 if (!wxPyCheckForApp()) SWIG_fail;
17193 PyThreadState* __tstate = wxPyBeginAllowThreads();
17194 result = (wxSound *)new_wxSound(arg1);
17195 wxPyEndAllowThreads(__tstate);
17196 if (PyErr_Occurred()) SWIG_fail;
17197 }
17198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17206 PyObject *resultobj = 0;
17207 wxSound *arg1 = (wxSound *) 0 ;
17208 void *argp1 = 0 ;
17209 int res1 = 0 ;
17210 PyObject *swig_obj[1] ;
17211
17212 if (!args) SWIG_fail;
17213 swig_obj[0] = args;
17214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17215 if (!SWIG_IsOK(res1)) {
17216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17217 }
17218 arg1 = reinterpret_cast< wxSound * >(argp1);
17219 {
17220 PyThreadState* __tstate = wxPyBeginAllowThreads();
17221 delete arg1;
17222
17223 wxPyEndAllowThreads(__tstate);
17224 if (PyErr_Occurred()) SWIG_fail;
17225 }
17226 resultobj = SWIG_Py_Void();
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17234 PyObject *resultobj = 0;
17235 wxSound *arg1 = (wxSound *) 0 ;
17236 wxString *arg2 = 0 ;
17237 bool result;
17238 void *argp1 = 0 ;
17239 int res1 = 0 ;
17240 bool temp2 = false ;
17241 PyObject * obj0 = 0 ;
17242 PyObject * obj1 = 0 ;
17243 char * kwnames[] = {
17244 (char *) "self",(char *) "fileName", NULL
17245 };
17246
17247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17249 if (!SWIG_IsOK(res1)) {
17250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17251 }
17252 arg1 = reinterpret_cast< wxSound * >(argp1);
17253 {
17254 arg2 = wxString_in_helper(obj1);
17255 if (arg2 == NULL) SWIG_fail;
17256 temp2 = true;
17257 }
17258 {
17259 PyThreadState* __tstate = wxPyBeginAllowThreads();
17260 result = (bool)(arg1)->Create((wxString const &)*arg2);
17261 wxPyEndAllowThreads(__tstate);
17262 if (PyErr_Occurred()) SWIG_fail;
17263 }
17264 {
17265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17266 }
17267 {
17268 if (temp2)
17269 delete arg2;
17270 }
17271 return resultobj;
17272 fail:
17273 {
17274 if (temp2)
17275 delete arg2;
17276 }
17277 return NULL;
17278 }
17279
17280
17281 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17282 PyObject *resultobj = 0;
17283 wxSound *arg1 = (wxSound *) 0 ;
17284 PyObject *arg2 = (PyObject *) 0 ;
17285 bool result;
17286 void *argp1 = 0 ;
17287 int res1 = 0 ;
17288 PyObject * obj0 = 0 ;
17289 PyObject * obj1 = 0 ;
17290 char * kwnames[] = {
17291 (char *) "self",(char *) "data", NULL
17292 };
17293
17294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17296 if (!SWIG_IsOK(res1)) {
17297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17298 }
17299 arg1 = reinterpret_cast< wxSound * >(argp1);
17300 arg2 = obj1;
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (bool)wxSound_CreateFromData(arg1,arg2);
17304 wxPyEndAllowThreads(__tstate);
17305 if (PyErr_Occurred()) SWIG_fail;
17306 }
17307 {
17308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17309 }
17310 return resultobj;
17311 fail:
17312 return NULL;
17313 }
17314
17315
17316 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17317 PyObject *resultobj = 0;
17318 wxSound *arg1 = (wxSound *) 0 ;
17319 bool result;
17320 void *argp1 = 0 ;
17321 int res1 = 0 ;
17322 PyObject *swig_obj[1] ;
17323
17324 if (!args) SWIG_fail;
17325 swig_obj[0] = args;
17326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17327 if (!SWIG_IsOK(res1)) {
17328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17329 }
17330 arg1 = reinterpret_cast< wxSound * >(argp1);
17331 {
17332 PyThreadState* __tstate = wxPyBeginAllowThreads();
17333 result = (bool)(arg1)->IsOk();
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 {
17338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17339 }
17340 return resultobj;
17341 fail:
17342 return NULL;
17343 }
17344
17345
17346 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17347 PyObject *resultobj = 0;
17348 wxSound *arg1 = (wxSound *) 0 ;
17349 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17350 bool result;
17351 void *argp1 = 0 ;
17352 int res1 = 0 ;
17353 unsigned int val2 ;
17354 int ecode2 = 0 ;
17355 PyObject * obj0 = 0 ;
17356 PyObject * obj1 = 0 ;
17357 char * kwnames[] = {
17358 (char *) "self",(char *) "flags", NULL
17359 };
17360
17361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17363 if (!SWIG_IsOK(res1)) {
17364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17365 }
17366 arg1 = reinterpret_cast< wxSound * >(argp1);
17367 if (obj1) {
17368 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17369 if (!SWIG_IsOK(ecode2)) {
17370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17371 }
17372 arg2 = static_cast< unsigned int >(val2);
17373 }
17374 {
17375 if (!wxPyCheckForApp()) SWIG_fail;
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = (bool)((wxSound const *)arg1)->Play(arg2);
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 {
17382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17383 }
17384 return resultobj;
17385 fail:
17386 return NULL;
17387 }
17388
17389
17390 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17391 PyObject *resultobj = 0;
17392 wxString *arg1 = 0 ;
17393 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17394 bool result;
17395 bool temp1 = false ;
17396 unsigned int val2 ;
17397 int ecode2 = 0 ;
17398 PyObject * obj0 = 0 ;
17399 PyObject * obj1 = 0 ;
17400 char * kwnames[] = {
17401 (char *) "filename",(char *) "flags", NULL
17402 };
17403
17404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17405 {
17406 arg1 = wxString_in_helper(obj0);
17407 if (arg1 == NULL) SWIG_fail;
17408 temp1 = true;
17409 }
17410 if (obj1) {
17411 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17412 if (!SWIG_IsOK(ecode2)) {
17413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17414 }
17415 arg2 = static_cast< unsigned int >(val2);
17416 }
17417 {
17418 if (!wxPyCheckForApp()) SWIG_fail;
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 {
17425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17426 }
17427 {
17428 if (temp1)
17429 delete arg1;
17430 }
17431 return resultobj;
17432 fail:
17433 {
17434 if (temp1)
17435 delete arg1;
17436 }
17437 return NULL;
17438 }
17439
17440
17441 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17442 PyObject *resultobj = 0;
17443
17444 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17445 {
17446 if (!wxPyCheckForApp()) SWIG_fail;
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 wxSound::Stop();
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 resultobj = SWIG_Py_Void();
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17460 PyObject *obj;
17461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17462 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17463 return SWIG_Py_Void();
17464 }
17465
17466 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 return SWIG_Python_InitShadowInstance(args);
17468 }
17469
17470 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17471 PyObject *resultobj = 0;
17472 wxString *arg1 = 0 ;
17473 wxString *arg2 = 0 ;
17474 wxString *arg3 = 0 ;
17475 wxString *arg4 = 0 ;
17476 wxFileTypeInfo *result = 0 ;
17477 bool temp1 = false ;
17478 bool temp2 = false ;
17479 bool temp3 = false ;
17480 bool temp4 = false ;
17481 PyObject * obj0 = 0 ;
17482 PyObject * obj1 = 0 ;
17483 PyObject * obj2 = 0 ;
17484 PyObject * obj3 = 0 ;
17485 char * kwnames[] = {
17486 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17487 };
17488
17489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17490 {
17491 arg1 = wxString_in_helper(obj0);
17492 if (arg1 == NULL) SWIG_fail;
17493 temp1 = true;
17494 }
17495 {
17496 arg2 = wxString_in_helper(obj1);
17497 if (arg2 == NULL) SWIG_fail;
17498 temp2 = true;
17499 }
17500 {
17501 arg3 = wxString_in_helper(obj2);
17502 if (arg3 == NULL) SWIG_fail;
17503 temp3 = true;
17504 }
17505 {
17506 arg4 = wxString_in_helper(obj3);
17507 if (arg4 == NULL) SWIG_fail;
17508 temp4 = true;
17509 }
17510 {
17511 PyThreadState* __tstate = wxPyBeginAllowThreads();
17512 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17513 wxPyEndAllowThreads(__tstate);
17514 if (PyErr_Occurred()) SWIG_fail;
17515 }
17516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17517 {
17518 if (temp1)
17519 delete arg1;
17520 }
17521 {
17522 if (temp2)
17523 delete arg2;
17524 }
17525 {
17526 if (temp3)
17527 delete arg3;
17528 }
17529 {
17530 if (temp4)
17531 delete arg4;
17532 }
17533 return resultobj;
17534 fail:
17535 {
17536 if (temp1)
17537 delete arg1;
17538 }
17539 {
17540 if (temp2)
17541 delete arg2;
17542 }
17543 {
17544 if (temp3)
17545 delete arg3;
17546 }
17547 {
17548 if (temp4)
17549 delete arg4;
17550 }
17551 return NULL;
17552 }
17553
17554
17555 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj = 0;
17557 wxArrayString *arg1 = 0 ;
17558 wxFileTypeInfo *result = 0 ;
17559 bool temp1 = false ;
17560 PyObject * obj0 = 0 ;
17561 char * kwnames[] = {
17562 (char *) "sArray", NULL
17563 };
17564
17565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17566 {
17567 if (! PySequence_Check(obj0)) {
17568 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17569 SWIG_fail;
17570 }
17571 arg1 = new wxArrayString;
17572 temp1 = true;
17573 int i, len=PySequence_Length(obj0);
17574 for (i=0; i<len; i++) {
17575 PyObject* item = PySequence_GetItem(obj0, i);
17576 wxString* s = wxString_in_helper(item);
17577 if (PyErr_Occurred()) SWIG_fail;
17578 arg1->Add(*s);
17579 delete s;
17580 Py_DECREF(item);
17581 }
17582 }
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17586 wxPyEndAllowThreads(__tstate);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 }
17589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17590 {
17591 if (temp1) delete arg1;
17592 }
17593 return resultobj;
17594 fail:
17595 {
17596 if (temp1) delete arg1;
17597 }
17598 return NULL;
17599 }
17600
17601
17602 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 PyObject *resultobj = 0;
17604 wxFileTypeInfo *result = 0 ;
17605
17606 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621 PyObject *resultobj = 0;
17622 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17623 bool result;
17624 void *argp1 = 0 ;
17625 int res1 = 0 ;
17626 PyObject *swig_obj[1] ;
17627
17628 if (!args) SWIG_fail;
17629 swig_obj[0] = args;
17630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17631 if (!SWIG_IsOK(res1)) {
17632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17633 }
17634 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17635 {
17636 PyThreadState* __tstate = wxPyBeginAllowThreads();
17637 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17638 wxPyEndAllowThreads(__tstate);
17639 if (PyErr_Occurred()) SWIG_fail;
17640 }
17641 {
17642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17643 }
17644 return resultobj;
17645 fail:
17646 return NULL;
17647 }
17648
17649
17650 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17651 PyObject *resultobj = 0;
17652 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17653 wxString *arg2 = 0 ;
17654 int arg3 = (int) 0 ;
17655 void *argp1 = 0 ;
17656 int res1 = 0 ;
17657 bool temp2 = false ;
17658 int val3 ;
17659 int ecode3 = 0 ;
17660 PyObject * obj0 = 0 ;
17661 PyObject * obj1 = 0 ;
17662 PyObject * obj2 = 0 ;
17663 char * kwnames[] = {
17664 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17665 };
17666
17667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17669 if (!SWIG_IsOK(res1)) {
17670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17671 }
17672 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17673 {
17674 arg2 = wxString_in_helper(obj1);
17675 if (arg2 == NULL) SWIG_fail;
17676 temp2 = true;
17677 }
17678 if (obj2) {
17679 ecode3 = SWIG_AsVal_int(obj2, &val3);
17680 if (!SWIG_IsOK(ecode3)) {
17681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17682 }
17683 arg3 = static_cast< int >(val3);
17684 }
17685 {
17686 PyThreadState* __tstate = wxPyBeginAllowThreads();
17687 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17688 wxPyEndAllowThreads(__tstate);
17689 if (PyErr_Occurred()) SWIG_fail;
17690 }
17691 resultobj = SWIG_Py_Void();
17692 {
17693 if (temp2)
17694 delete arg2;
17695 }
17696 return resultobj;
17697 fail:
17698 {
17699 if (temp2)
17700 delete arg2;
17701 }
17702 return NULL;
17703 }
17704
17705
17706 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17707 PyObject *resultobj = 0;
17708 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17709 wxString *arg2 = 0 ;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 bool temp2 = false ;
17713 PyObject * obj0 = 0 ;
17714 PyObject * obj1 = 0 ;
17715 char * kwnames[] = {
17716 (char *) "self",(char *) "shortDesc", NULL
17717 };
17718
17719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17721 if (!SWIG_IsOK(res1)) {
17722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17723 }
17724 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17725 {
17726 arg2 = wxString_in_helper(obj1);
17727 if (arg2 == NULL) SWIG_fail;
17728 temp2 = true;
17729 }
17730 {
17731 PyThreadState* __tstate = wxPyBeginAllowThreads();
17732 (arg1)->SetShortDesc((wxString const &)*arg2);
17733 wxPyEndAllowThreads(__tstate);
17734 if (PyErr_Occurred()) SWIG_fail;
17735 }
17736 resultobj = SWIG_Py_Void();
17737 {
17738 if (temp2)
17739 delete arg2;
17740 }
17741 return resultobj;
17742 fail:
17743 {
17744 if (temp2)
17745 delete arg2;
17746 }
17747 return NULL;
17748 }
17749
17750
17751 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17752 PyObject *resultobj = 0;
17753 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17754 wxString *result = 0 ;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 PyObject *swig_obj[1] ;
17758
17759 if (!args) SWIG_fail;
17760 swig_obj[0] = args;
17761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17762 if (!SWIG_IsOK(res1)) {
17763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17764 }
17765 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17766 {
17767 PyThreadState* __tstate = wxPyBeginAllowThreads();
17768 {
17769 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17770 result = (wxString *) &_result_ref;
17771 }
17772 wxPyEndAllowThreads(__tstate);
17773 if (PyErr_Occurred()) SWIG_fail;
17774 }
17775 {
17776 #if wxUSE_UNICODE
17777 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17778 #else
17779 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17780 #endif
17781 }
17782 return resultobj;
17783 fail:
17784 return NULL;
17785 }
17786
17787
17788 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17789 PyObject *resultobj = 0;
17790 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17791 wxString *result = 0 ;
17792 void *argp1 = 0 ;
17793 int res1 = 0 ;
17794 PyObject *swig_obj[1] ;
17795
17796 if (!args) SWIG_fail;
17797 swig_obj[0] = args;
17798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17799 if (!SWIG_IsOK(res1)) {
17800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17801 }
17802 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17803 {
17804 PyThreadState* __tstate = wxPyBeginAllowThreads();
17805 {
17806 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17807 result = (wxString *) &_result_ref;
17808 }
17809 wxPyEndAllowThreads(__tstate);
17810 if (PyErr_Occurred()) SWIG_fail;
17811 }
17812 {
17813 #if wxUSE_UNICODE
17814 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17815 #else
17816 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17817 #endif
17818 }
17819 return resultobj;
17820 fail:
17821 return NULL;
17822 }
17823
17824
17825 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17826 PyObject *resultobj = 0;
17827 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17828 wxString *result = 0 ;
17829 void *argp1 = 0 ;
17830 int res1 = 0 ;
17831 PyObject *swig_obj[1] ;
17832
17833 if (!args) SWIG_fail;
17834 swig_obj[0] = args;
17835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17836 if (!SWIG_IsOK(res1)) {
17837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17838 }
17839 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17840 {
17841 PyThreadState* __tstate = wxPyBeginAllowThreads();
17842 {
17843 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17844 result = (wxString *) &_result_ref;
17845 }
17846 wxPyEndAllowThreads(__tstate);
17847 if (PyErr_Occurred()) SWIG_fail;
17848 }
17849 {
17850 #if wxUSE_UNICODE
17851 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17852 #else
17853 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17854 #endif
17855 }
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17863 PyObject *resultobj = 0;
17864 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17865 wxString *result = 0 ;
17866 void *argp1 = 0 ;
17867 int res1 = 0 ;
17868 PyObject *swig_obj[1] ;
17869
17870 if (!args) SWIG_fail;
17871 swig_obj[0] = args;
17872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17873 if (!SWIG_IsOK(res1)) {
17874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17875 }
17876 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17877 {
17878 PyThreadState* __tstate = wxPyBeginAllowThreads();
17879 {
17880 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17881 result = (wxString *) &_result_ref;
17882 }
17883 wxPyEndAllowThreads(__tstate);
17884 if (PyErr_Occurred()) SWIG_fail;
17885 }
17886 {
17887 #if wxUSE_UNICODE
17888 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17889 #else
17890 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17891 #endif
17892 }
17893 return resultobj;
17894 fail:
17895 return NULL;
17896 }
17897
17898
17899 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17900 PyObject *resultobj = 0;
17901 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17902 wxString *result = 0 ;
17903 void *argp1 = 0 ;
17904 int res1 = 0 ;
17905 PyObject *swig_obj[1] ;
17906
17907 if (!args) SWIG_fail;
17908 swig_obj[0] = args;
17909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17910 if (!SWIG_IsOK(res1)) {
17911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17912 }
17913 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17914 {
17915 PyThreadState* __tstate = wxPyBeginAllowThreads();
17916 {
17917 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17918 result = (wxString *) &_result_ref;
17919 }
17920 wxPyEndAllowThreads(__tstate);
17921 if (PyErr_Occurred()) SWIG_fail;
17922 }
17923 {
17924 #if wxUSE_UNICODE
17925 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17926 #else
17927 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17928 #endif
17929 }
17930 return resultobj;
17931 fail:
17932 return NULL;
17933 }
17934
17935
17936 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17937 PyObject *resultobj = 0;
17938 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17939 wxArrayString *result = 0 ;
17940 void *argp1 = 0 ;
17941 int res1 = 0 ;
17942 PyObject *swig_obj[1] ;
17943
17944 if (!args) SWIG_fail;
17945 swig_obj[0] = args;
17946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17947 if (!SWIG_IsOK(res1)) {
17948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17949 }
17950 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 {
17954 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17955 result = (wxArrayString *) &_result_ref;
17956 }
17957 wxPyEndAllowThreads(__tstate);
17958 if (PyErr_Occurred()) SWIG_fail;
17959 }
17960 {
17961 resultobj = wxArrayString2PyList_helper(*result);
17962 }
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17970 PyObject *resultobj = 0;
17971 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17972 size_t result;
17973 void *argp1 = 0 ;
17974 int res1 = 0 ;
17975 PyObject *swig_obj[1] ;
17976
17977 if (!args) SWIG_fail;
17978 swig_obj[0] = args;
17979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17980 if (!SWIG_IsOK(res1)) {
17981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17982 }
17983 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17987 wxPyEndAllowThreads(__tstate);
17988 if (PyErr_Occurred()) SWIG_fail;
17989 }
17990 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17998 PyObject *resultobj = 0;
17999 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18000 wxString *result = 0 ;
18001 void *argp1 = 0 ;
18002 int res1 = 0 ;
18003 PyObject *swig_obj[1] ;
18004
18005 if (!args) SWIG_fail;
18006 swig_obj[0] = args;
18007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18008 if (!SWIG_IsOK(res1)) {
18009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18010 }
18011 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18012 {
18013 PyThreadState* __tstate = wxPyBeginAllowThreads();
18014 {
18015 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18016 result = (wxString *) &_result_ref;
18017 }
18018 wxPyEndAllowThreads(__tstate);
18019 if (PyErr_Occurred()) SWIG_fail;
18020 }
18021 {
18022 #if wxUSE_UNICODE
18023 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18024 #else
18025 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18026 #endif
18027 }
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18035 PyObject *resultobj = 0;
18036 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18037 int result;
18038 void *argp1 = 0 ;
18039 int res1 = 0 ;
18040 PyObject *swig_obj[1] ;
18041
18042 if (!args) SWIG_fail;
18043 swig_obj[0] = args;
18044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18045 if (!SWIG_IsOK(res1)) {
18046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18047 }
18048 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18049 {
18050 PyThreadState* __tstate = wxPyBeginAllowThreads();
18051 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18052 wxPyEndAllowThreads(__tstate);
18053 if (PyErr_Occurred()) SWIG_fail;
18054 }
18055 resultobj = SWIG_From_int(static_cast< int >(result));
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063 PyObject *obj;
18064 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18065 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18066 return SWIG_Py_Void();
18067 }
18068
18069 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18070 return SWIG_Python_InitShadowInstance(args);
18071 }
18072
18073 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18074 PyObject *resultobj = 0;
18075 wxFileTypeInfo *arg1 = 0 ;
18076 wxFileType *result = 0 ;
18077 void *argp1 = 0 ;
18078 int res1 = 0 ;
18079 PyObject * obj0 = 0 ;
18080 char * kwnames[] = {
18081 (char *) "ftInfo", NULL
18082 };
18083
18084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18085 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18088 }
18089 if (!argp1) {
18090 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18091 }
18092 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18093 {
18094 PyThreadState* __tstate = wxPyBeginAllowThreads();
18095 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18096 wxPyEndAllowThreads(__tstate);
18097 if (PyErr_Occurred()) SWIG_fail;
18098 }
18099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18100 return resultobj;
18101 fail:
18102 return NULL;
18103 }
18104
18105
18106 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18107 PyObject *resultobj = 0;
18108 wxFileType *arg1 = (wxFileType *) 0 ;
18109 void *argp1 = 0 ;
18110 int res1 = 0 ;
18111 PyObject *swig_obj[1] ;
18112
18113 if (!args) SWIG_fail;
18114 swig_obj[0] = args;
18115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18116 if (!SWIG_IsOK(res1)) {
18117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18118 }
18119 arg1 = reinterpret_cast< wxFileType * >(argp1);
18120 {
18121 PyThreadState* __tstate = wxPyBeginAllowThreads();
18122 delete arg1;
18123
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 resultobj = SWIG_Py_Void();
18128 return resultobj;
18129 fail:
18130 return NULL;
18131 }
18132
18133
18134 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18135 PyObject *resultobj = 0;
18136 wxFileType *arg1 = (wxFileType *) 0 ;
18137 PyObject *result = 0 ;
18138 void *argp1 = 0 ;
18139 int res1 = 0 ;
18140 PyObject *swig_obj[1] ;
18141
18142 if (!args) SWIG_fail;
18143 swig_obj[0] = args;
18144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18147 }
18148 arg1 = reinterpret_cast< wxFileType * >(argp1);
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 result = (PyObject *)wxFileType_GetMimeType(arg1);
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = result;
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18163 PyObject *resultobj = 0;
18164 wxFileType *arg1 = (wxFileType *) 0 ;
18165 PyObject *result = 0 ;
18166 void *argp1 = 0 ;
18167 int res1 = 0 ;
18168 PyObject *swig_obj[1] ;
18169
18170 if (!args) SWIG_fail;
18171 swig_obj[0] = args;
18172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18173 if (!SWIG_IsOK(res1)) {
18174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18175 }
18176 arg1 = reinterpret_cast< wxFileType * >(argp1);
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = result;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18191 PyObject *resultobj = 0;
18192 wxFileType *arg1 = (wxFileType *) 0 ;
18193 PyObject *result = 0 ;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
18196 PyObject *swig_obj[1] ;
18197
18198 if (!args) SWIG_fail;
18199 swig_obj[0] = args;
18200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18201 if (!SWIG_IsOK(res1)) {
18202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18203 }
18204 arg1 = reinterpret_cast< wxFileType * >(argp1);
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 result = (PyObject *)wxFileType_GetExtensions(arg1);
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 resultobj = result;
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18219 PyObject *resultobj = 0;
18220 wxFileType *arg1 = (wxFileType *) 0 ;
18221 wxIcon *result = 0 ;
18222 void *argp1 = 0 ;
18223 int res1 = 0 ;
18224 PyObject *swig_obj[1] ;
18225
18226 if (!args) SWIG_fail;
18227 swig_obj[0] = args;
18228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18229 if (!SWIG_IsOK(res1)) {
18230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18231 }
18232 arg1 = reinterpret_cast< wxFileType * >(argp1);
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 result = (wxIcon *)wxFileType_GetIcon(arg1);
18236 wxPyEndAllowThreads(__tstate);
18237 if (PyErr_Occurred()) SWIG_fail;
18238 }
18239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18240 return resultobj;
18241 fail:
18242 return NULL;
18243 }
18244
18245
18246 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18247 PyObject *resultobj = 0;
18248 wxFileType *arg1 = (wxFileType *) 0 ;
18249 PyObject *result = 0 ;
18250 void *argp1 = 0 ;
18251 int res1 = 0 ;
18252 PyObject *swig_obj[1] ;
18253
18254 if (!args) SWIG_fail;
18255 swig_obj[0] = args;
18256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18257 if (!SWIG_IsOK(res1)) {
18258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18259 }
18260 arg1 = reinterpret_cast< wxFileType * >(argp1);
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 resultobj = result;
18268 return resultobj;
18269 fail:
18270 return NULL;
18271 }
18272
18273
18274 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18275 PyObject *resultobj = 0;
18276 wxFileType *arg1 = (wxFileType *) 0 ;
18277 PyObject *result = 0 ;
18278 void *argp1 = 0 ;
18279 int res1 = 0 ;
18280 PyObject *swig_obj[1] ;
18281
18282 if (!args) SWIG_fail;
18283 swig_obj[0] = args;
18284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18285 if (!SWIG_IsOK(res1)) {
18286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18287 }
18288 arg1 = reinterpret_cast< wxFileType * >(argp1);
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (PyObject *)wxFileType_GetDescription(arg1);
18292 wxPyEndAllowThreads(__tstate);
18293 if (PyErr_Occurred()) SWIG_fail;
18294 }
18295 resultobj = result;
18296 return resultobj;
18297 fail:
18298 return NULL;
18299 }
18300
18301
18302 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18303 PyObject *resultobj = 0;
18304 wxFileType *arg1 = (wxFileType *) 0 ;
18305 wxString *arg2 = 0 ;
18306 wxString const &arg3_defvalue = wxPyEmptyString ;
18307 wxString *arg3 = (wxString *) &arg3_defvalue ;
18308 PyObject *result = 0 ;
18309 void *argp1 = 0 ;
18310 int res1 = 0 ;
18311 bool temp2 = false ;
18312 bool temp3 = false ;
18313 PyObject * obj0 = 0 ;
18314 PyObject * obj1 = 0 ;
18315 PyObject * obj2 = 0 ;
18316 char * kwnames[] = {
18317 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18318 };
18319
18320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18322 if (!SWIG_IsOK(res1)) {
18323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18324 }
18325 arg1 = reinterpret_cast< wxFileType * >(argp1);
18326 {
18327 arg2 = wxString_in_helper(obj1);
18328 if (arg2 == NULL) SWIG_fail;
18329 temp2 = true;
18330 }
18331 if (obj2) {
18332 {
18333 arg3 = wxString_in_helper(obj2);
18334 if (arg3 == NULL) SWIG_fail;
18335 temp3 = true;
18336 }
18337 }
18338 {
18339 PyThreadState* __tstate = wxPyBeginAllowThreads();
18340 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18341 wxPyEndAllowThreads(__tstate);
18342 if (PyErr_Occurred()) SWIG_fail;
18343 }
18344 resultobj = result;
18345 {
18346 if (temp2)
18347 delete arg2;
18348 }
18349 {
18350 if (temp3)
18351 delete arg3;
18352 }
18353 return resultobj;
18354 fail:
18355 {
18356 if (temp2)
18357 delete arg2;
18358 }
18359 {
18360 if (temp3)
18361 delete arg3;
18362 }
18363 return NULL;
18364 }
18365
18366
18367 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18368 PyObject *resultobj = 0;
18369 wxFileType *arg1 = (wxFileType *) 0 ;
18370 wxString *arg2 = 0 ;
18371 wxString const &arg3_defvalue = wxPyEmptyString ;
18372 wxString *arg3 = (wxString *) &arg3_defvalue ;
18373 PyObject *result = 0 ;
18374 void *argp1 = 0 ;
18375 int res1 = 0 ;
18376 bool temp2 = false ;
18377 bool temp3 = false ;
18378 PyObject * obj0 = 0 ;
18379 PyObject * obj1 = 0 ;
18380 PyObject * obj2 = 0 ;
18381 char * kwnames[] = {
18382 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18383 };
18384
18385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18387 if (!SWIG_IsOK(res1)) {
18388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18389 }
18390 arg1 = reinterpret_cast< wxFileType * >(argp1);
18391 {
18392 arg2 = wxString_in_helper(obj1);
18393 if (arg2 == NULL) SWIG_fail;
18394 temp2 = true;
18395 }
18396 if (obj2) {
18397 {
18398 arg3 = wxString_in_helper(obj2);
18399 if (arg3 == NULL) SWIG_fail;
18400 temp3 = true;
18401 }
18402 }
18403 {
18404 PyThreadState* __tstate = wxPyBeginAllowThreads();
18405 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18406 wxPyEndAllowThreads(__tstate);
18407 if (PyErr_Occurred()) SWIG_fail;
18408 }
18409 resultobj = result;
18410 {
18411 if (temp2)
18412 delete arg2;
18413 }
18414 {
18415 if (temp3)
18416 delete arg3;
18417 }
18418 return resultobj;
18419 fail:
18420 {
18421 if (temp2)
18422 delete arg2;
18423 }
18424 {
18425 if (temp3)
18426 delete arg3;
18427 }
18428 return NULL;
18429 }
18430
18431
18432 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18433 PyObject *resultobj = 0;
18434 wxFileType *arg1 = (wxFileType *) 0 ;
18435 wxString *arg2 = 0 ;
18436 wxString const &arg3_defvalue = wxPyEmptyString ;
18437 wxString *arg3 = (wxString *) &arg3_defvalue ;
18438 PyObject *result = 0 ;
18439 void *argp1 = 0 ;
18440 int res1 = 0 ;
18441 bool temp2 = false ;
18442 bool temp3 = false ;
18443 PyObject * obj0 = 0 ;
18444 PyObject * obj1 = 0 ;
18445 PyObject * obj2 = 0 ;
18446 char * kwnames[] = {
18447 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18448 };
18449
18450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18452 if (!SWIG_IsOK(res1)) {
18453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18454 }
18455 arg1 = reinterpret_cast< wxFileType * >(argp1);
18456 {
18457 arg2 = wxString_in_helper(obj1);
18458 if (arg2 == NULL) SWIG_fail;
18459 temp2 = true;
18460 }
18461 if (obj2) {
18462 {
18463 arg3 = wxString_in_helper(obj2);
18464 if (arg3 == NULL) SWIG_fail;
18465 temp3 = true;
18466 }
18467 }
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 resultobj = result;
18475 {
18476 if (temp2)
18477 delete arg2;
18478 }
18479 {
18480 if (temp3)
18481 delete arg3;
18482 }
18483 return resultobj;
18484 fail:
18485 {
18486 if (temp2)
18487 delete arg2;
18488 }
18489 {
18490 if (temp3)
18491 delete arg3;
18492 }
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18498 PyObject *resultobj = 0;
18499 wxFileType *arg1 = (wxFileType *) 0 ;
18500 wxString *arg2 = 0 ;
18501 wxString *arg3 = 0 ;
18502 bool arg4 = (bool) true ;
18503 bool result;
18504 void *argp1 = 0 ;
18505 int res1 = 0 ;
18506 bool temp2 = false ;
18507 bool temp3 = false ;
18508 bool val4 ;
18509 int ecode4 = 0 ;
18510 PyObject * obj0 = 0 ;
18511 PyObject * obj1 = 0 ;
18512 PyObject * obj2 = 0 ;
18513 PyObject * obj3 = 0 ;
18514 char * kwnames[] = {
18515 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18516 };
18517
18518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18520 if (!SWIG_IsOK(res1)) {
18521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18522 }
18523 arg1 = reinterpret_cast< wxFileType * >(argp1);
18524 {
18525 arg2 = wxString_in_helper(obj1);
18526 if (arg2 == NULL) SWIG_fail;
18527 temp2 = true;
18528 }
18529 {
18530 arg3 = wxString_in_helper(obj2);
18531 if (arg3 == NULL) SWIG_fail;
18532 temp3 = true;
18533 }
18534 if (obj3) {
18535 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18536 if (!SWIG_IsOK(ecode4)) {
18537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18538 }
18539 arg4 = static_cast< bool >(val4);
18540 }
18541 {
18542 PyThreadState* __tstate = wxPyBeginAllowThreads();
18543 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 {
18548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18549 }
18550 {
18551 if (temp2)
18552 delete arg2;
18553 }
18554 {
18555 if (temp3)
18556 delete arg3;
18557 }
18558 return resultobj;
18559 fail:
18560 {
18561 if (temp2)
18562 delete arg2;
18563 }
18564 {
18565 if (temp3)
18566 delete arg3;
18567 }
18568 return NULL;
18569 }
18570
18571
18572 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18573 PyObject *resultobj = 0;
18574 wxFileType *arg1 = (wxFileType *) 0 ;
18575 wxString const &arg2_defvalue = wxPyEmptyString ;
18576 wxString *arg2 = (wxString *) &arg2_defvalue ;
18577 int arg3 = (int) 0 ;
18578 bool result;
18579 void *argp1 = 0 ;
18580 int res1 = 0 ;
18581 bool temp2 = false ;
18582 int val3 ;
18583 int ecode3 = 0 ;
18584 PyObject * obj0 = 0 ;
18585 PyObject * obj1 = 0 ;
18586 PyObject * obj2 = 0 ;
18587 char * kwnames[] = {
18588 (char *) "self",(char *) "cmd",(char *) "index", NULL
18589 };
18590
18591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18593 if (!SWIG_IsOK(res1)) {
18594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18595 }
18596 arg1 = reinterpret_cast< wxFileType * >(argp1);
18597 if (obj1) {
18598 {
18599 arg2 = wxString_in_helper(obj1);
18600 if (arg2 == NULL) SWIG_fail;
18601 temp2 = true;
18602 }
18603 }
18604 if (obj2) {
18605 ecode3 = SWIG_AsVal_int(obj2, &val3);
18606 if (!SWIG_IsOK(ecode3)) {
18607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18608 }
18609 arg3 = static_cast< int >(val3);
18610 }
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18614 wxPyEndAllowThreads(__tstate);
18615 if (PyErr_Occurred()) SWIG_fail;
18616 }
18617 {
18618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18619 }
18620 {
18621 if (temp2)
18622 delete arg2;
18623 }
18624 return resultobj;
18625 fail:
18626 {
18627 if (temp2)
18628 delete arg2;
18629 }
18630 return NULL;
18631 }
18632
18633
18634 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18635 PyObject *resultobj = 0;
18636 wxFileType *arg1 = (wxFileType *) 0 ;
18637 bool result;
18638 void *argp1 = 0 ;
18639 int res1 = 0 ;
18640 PyObject *swig_obj[1] ;
18641
18642 if (!args) SWIG_fail;
18643 swig_obj[0] = args;
18644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18645 if (!SWIG_IsOK(res1)) {
18646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18647 }
18648 arg1 = reinterpret_cast< wxFileType * >(argp1);
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 result = (bool)(arg1)->Unassociate();
18652 wxPyEndAllowThreads(__tstate);
18653 if (PyErr_Occurred()) SWIG_fail;
18654 }
18655 {
18656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18657 }
18658 return resultobj;
18659 fail:
18660 return NULL;
18661 }
18662
18663
18664 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18665 PyObject *resultobj = 0;
18666 wxString *arg1 = 0 ;
18667 wxString *arg2 = 0 ;
18668 wxString const &arg3_defvalue = wxPyEmptyString ;
18669 wxString *arg3 = (wxString *) &arg3_defvalue ;
18670 wxString result;
18671 bool temp1 = false ;
18672 bool temp2 = false ;
18673 bool temp3 = false ;
18674 PyObject * obj0 = 0 ;
18675 PyObject * obj1 = 0 ;
18676 PyObject * obj2 = 0 ;
18677 char * kwnames[] = {
18678 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18679 };
18680
18681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18682 {
18683 arg1 = wxString_in_helper(obj0);
18684 if (arg1 == NULL) SWIG_fail;
18685 temp1 = true;
18686 }
18687 {
18688 arg2 = wxString_in_helper(obj1);
18689 if (arg2 == NULL) SWIG_fail;
18690 temp2 = true;
18691 }
18692 if (obj2) {
18693 {
18694 arg3 = wxString_in_helper(obj2);
18695 if (arg3 == NULL) SWIG_fail;
18696 temp3 = true;
18697 }
18698 }
18699 {
18700 PyThreadState* __tstate = wxPyBeginAllowThreads();
18701 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18702 wxPyEndAllowThreads(__tstate);
18703 if (PyErr_Occurred()) SWIG_fail;
18704 }
18705 {
18706 #if wxUSE_UNICODE
18707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18708 #else
18709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18710 #endif
18711 }
18712 {
18713 if (temp1)
18714 delete arg1;
18715 }
18716 {
18717 if (temp2)
18718 delete arg2;
18719 }
18720 {
18721 if (temp3)
18722 delete arg3;
18723 }
18724 return resultobj;
18725 fail:
18726 {
18727 if (temp1)
18728 delete arg1;
18729 }
18730 {
18731 if (temp2)
18732 delete arg2;
18733 }
18734 {
18735 if (temp3)
18736 delete arg3;
18737 }
18738 return NULL;
18739 }
18740
18741
18742 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18743 PyObject *obj;
18744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18745 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18746 return SWIG_Py_Void();
18747 }
18748
18749 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18750 return SWIG_Python_InitShadowInstance(args);
18751 }
18752
18753 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18754 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18755 return 1;
18756 }
18757
18758
18759 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18760 PyObject *pyobj = 0;
18761
18762 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18763 return pyobj;
18764 }
18765
18766
18767 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18768 PyObject *resultobj = 0;
18769 wxString *arg1 = 0 ;
18770 wxString *arg2 = 0 ;
18771 bool result;
18772 bool temp1 = false ;
18773 bool temp2 = false ;
18774 PyObject * obj0 = 0 ;
18775 PyObject * obj1 = 0 ;
18776 char * kwnames[] = {
18777 (char *) "mimeType",(char *) "wildcard", NULL
18778 };
18779
18780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18781 {
18782 arg1 = wxString_in_helper(obj0);
18783 if (arg1 == NULL) SWIG_fail;
18784 temp1 = true;
18785 }
18786 {
18787 arg2 = wxString_in_helper(obj1);
18788 if (arg2 == NULL) SWIG_fail;
18789 temp2 = true;
18790 }
18791 {
18792 PyThreadState* __tstate = wxPyBeginAllowThreads();
18793 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 {
18798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18799 }
18800 {
18801 if (temp1)
18802 delete arg1;
18803 }
18804 {
18805 if (temp2)
18806 delete arg2;
18807 }
18808 return resultobj;
18809 fail:
18810 {
18811 if (temp1)
18812 delete arg1;
18813 }
18814 {
18815 if (temp2)
18816 delete arg2;
18817 }
18818 return NULL;
18819 }
18820
18821
18822 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18823 PyObject *resultobj = 0;
18824 wxMimeTypesManager *result = 0 ;
18825
18826 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18827 {
18828 PyThreadState* __tstate = wxPyBeginAllowThreads();
18829 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18830 wxPyEndAllowThreads(__tstate);
18831 if (PyErr_Occurred()) SWIG_fail;
18832 }
18833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18841 PyObject *resultobj = 0;
18842 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18843 int arg2 = (int) wxMAILCAP_ALL ;
18844 wxString const &arg3_defvalue = wxPyEmptyString ;
18845 wxString *arg3 = (wxString *) &arg3_defvalue ;
18846 void *argp1 = 0 ;
18847 int res1 = 0 ;
18848 int val2 ;
18849 int ecode2 = 0 ;
18850 bool temp3 = false ;
18851 PyObject * obj0 = 0 ;
18852 PyObject * obj1 = 0 ;
18853 PyObject * obj2 = 0 ;
18854 char * kwnames[] = {
18855 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18856 };
18857
18858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18860 if (!SWIG_IsOK(res1)) {
18861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18862 }
18863 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18864 if (obj1) {
18865 ecode2 = SWIG_AsVal_int(obj1, &val2);
18866 if (!SWIG_IsOK(ecode2)) {
18867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18868 }
18869 arg2 = static_cast< int >(val2);
18870 }
18871 if (obj2) {
18872 {
18873 arg3 = wxString_in_helper(obj2);
18874 if (arg3 == NULL) SWIG_fail;
18875 temp3 = true;
18876 }
18877 }
18878 {
18879 PyThreadState* __tstate = wxPyBeginAllowThreads();
18880 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 resultobj = SWIG_Py_Void();
18885 {
18886 if (temp3)
18887 delete arg3;
18888 }
18889 return resultobj;
18890 fail:
18891 {
18892 if (temp3)
18893 delete arg3;
18894 }
18895 return NULL;
18896 }
18897
18898
18899 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18900 PyObject *resultobj = 0;
18901 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18902 void *argp1 = 0 ;
18903 int res1 = 0 ;
18904 PyObject *swig_obj[1] ;
18905
18906 if (!args) SWIG_fail;
18907 swig_obj[0] = args;
18908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18909 if (!SWIG_IsOK(res1)) {
18910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18911 }
18912 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 (arg1)->ClearData();
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 resultobj = SWIG_Py_Void();
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj = 0;
18928 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18929 wxString *arg2 = 0 ;
18930 wxFileType *result = 0 ;
18931 void *argp1 = 0 ;
18932 int res1 = 0 ;
18933 bool temp2 = false ;
18934 PyObject * obj0 = 0 ;
18935 PyObject * obj1 = 0 ;
18936 char * kwnames[] = {
18937 (char *) "self",(char *) "ext", NULL
18938 };
18939
18940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18942 if (!SWIG_IsOK(res1)) {
18943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18944 }
18945 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18946 {
18947 arg2 = wxString_in_helper(obj1);
18948 if (arg2 == NULL) SWIG_fail;
18949 temp2 = true;
18950 }
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18958 {
18959 if (temp2)
18960 delete arg2;
18961 }
18962 return resultobj;
18963 fail:
18964 {
18965 if (temp2)
18966 delete arg2;
18967 }
18968 return NULL;
18969 }
18970
18971
18972 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18973 PyObject *resultobj = 0;
18974 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18975 wxString *arg2 = 0 ;
18976 wxFileType *result = 0 ;
18977 void *argp1 = 0 ;
18978 int res1 = 0 ;
18979 bool temp2 = false ;
18980 PyObject * obj0 = 0 ;
18981 PyObject * obj1 = 0 ;
18982 char * kwnames[] = {
18983 (char *) "self",(char *) "mimeType", NULL
18984 };
18985
18986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18988 if (!SWIG_IsOK(res1)) {
18989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18990 }
18991 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18992 {
18993 arg2 = wxString_in_helper(obj1);
18994 if (arg2 == NULL) SWIG_fail;
18995 temp2 = true;
18996 }
18997 {
18998 PyThreadState* __tstate = wxPyBeginAllowThreads();
18999 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19000 wxPyEndAllowThreads(__tstate);
19001 if (PyErr_Occurred()) SWIG_fail;
19002 }
19003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19004 {
19005 if (temp2)
19006 delete arg2;
19007 }
19008 return resultobj;
19009 fail:
19010 {
19011 if (temp2)
19012 delete arg2;
19013 }
19014 return NULL;
19015 }
19016
19017
19018 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19019 PyObject *resultobj = 0;
19020 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19021 wxString *arg2 = 0 ;
19022 bool arg3 = (bool) false ;
19023 bool result;
19024 void *argp1 = 0 ;
19025 int res1 = 0 ;
19026 bool temp2 = false ;
19027 bool val3 ;
19028 int ecode3 = 0 ;
19029 PyObject * obj0 = 0 ;
19030 PyObject * obj1 = 0 ;
19031 PyObject * obj2 = 0 ;
19032 char * kwnames[] = {
19033 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19034 };
19035
19036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19038 if (!SWIG_IsOK(res1)) {
19039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19040 }
19041 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19042 {
19043 arg2 = wxString_in_helper(obj1);
19044 if (arg2 == NULL) SWIG_fail;
19045 temp2 = true;
19046 }
19047 if (obj2) {
19048 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19049 if (!SWIG_IsOK(ecode3)) {
19050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19051 }
19052 arg3 = static_cast< bool >(val3);
19053 }
19054 {
19055 PyThreadState* __tstate = wxPyBeginAllowThreads();
19056 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19057 wxPyEndAllowThreads(__tstate);
19058 if (PyErr_Occurred()) SWIG_fail;
19059 }
19060 {
19061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19062 }
19063 {
19064 if (temp2)
19065 delete arg2;
19066 }
19067 return resultobj;
19068 fail:
19069 {
19070 if (temp2)
19071 delete arg2;
19072 }
19073 return NULL;
19074 }
19075
19076
19077 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19078 PyObject *resultobj = 0;
19079 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19080 wxString *arg2 = 0 ;
19081 bool result;
19082 void *argp1 = 0 ;
19083 int res1 = 0 ;
19084 bool temp2 = false ;
19085 PyObject * obj0 = 0 ;
19086 PyObject * obj1 = 0 ;
19087 char * kwnames[] = {
19088 (char *) "self",(char *) "filename", NULL
19089 };
19090
19091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19093 if (!SWIG_IsOK(res1)) {
19094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19095 }
19096 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19097 {
19098 arg2 = wxString_in_helper(obj1);
19099 if (arg2 == NULL) SWIG_fail;
19100 temp2 = true;
19101 }
19102 {
19103 PyThreadState* __tstate = wxPyBeginAllowThreads();
19104 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 {
19109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19110 }
19111 {
19112 if (temp2)
19113 delete arg2;
19114 }
19115 return resultobj;
19116 fail:
19117 {
19118 if (temp2)
19119 delete arg2;
19120 }
19121 return NULL;
19122 }
19123
19124
19125 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19126 PyObject *resultobj = 0;
19127 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19128 PyObject *result = 0 ;
19129 void *argp1 = 0 ;
19130 int res1 = 0 ;
19131 PyObject *swig_obj[1] ;
19132
19133 if (!args) SWIG_fail;
19134 swig_obj[0] = args;
19135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19136 if (!SWIG_IsOK(res1)) {
19137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19138 }
19139 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 resultobj = result;
19147 return resultobj;
19148 fail:
19149 return NULL;
19150 }
19151
19152
19153 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19154 PyObject *resultobj = 0;
19155 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19156 wxFileTypeInfo *arg2 = 0 ;
19157 void *argp1 = 0 ;
19158 int res1 = 0 ;
19159 void *argp2 = 0 ;
19160 int res2 = 0 ;
19161 PyObject * obj0 = 0 ;
19162 PyObject * obj1 = 0 ;
19163 char * kwnames[] = {
19164 (char *) "self",(char *) "ft", NULL
19165 };
19166
19167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19169 if (!SWIG_IsOK(res1)) {
19170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19171 }
19172 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19174 if (!SWIG_IsOK(res2)) {
19175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19176 }
19177 if (!argp2) {
19178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19179 }
19180 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19181 {
19182 PyThreadState* __tstate = wxPyBeginAllowThreads();
19183 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19184 wxPyEndAllowThreads(__tstate);
19185 if (PyErr_Occurred()) SWIG_fail;
19186 }
19187 resultobj = SWIG_Py_Void();
19188 return resultobj;
19189 fail:
19190 return NULL;
19191 }
19192
19193
19194 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19195 PyObject *resultobj = 0;
19196 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19197 wxFileTypeInfo *arg2 = 0 ;
19198 wxFileType *result = 0 ;
19199 void *argp1 = 0 ;
19200 int res1 = 0 ;
19201 void *argp2 = 0 ;
19202 int res2 = 0 ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 char * kwnames[] = {
19206 (char *) "self",(char *) "ftInfo", NULL
19207 };
19208
19209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19213 }
19214 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19216 if (!SWIG_IsOK(res2)) {
19217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19218 }
19219 if (!argp2) {
19220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19221 }
19222 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19223 {
19224 PyThreadState* __tstate = wxPyBeginAllowThreads();
19225 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19237 PyObject *resultobj = 0;
19238 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19239 wxFileType *arg2 = (wxFileType *) 0 ;
19240 bool result;
19241 void *argp1 = 0 ;
19242 int res1 = 0 ;
19243 void *argp2 = 0 ;
19244 int res2 = 0 ;
19245 PyObject * obj0 = 0 ;
19246 PyObject * obj1 = 0 ;
19247 char * kwnames[] = {
19248 (char *) "self",(char *) "ft", NULL
19249 };
19250
19251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19253 if (!SWIG_IsOK(res1)) {
19254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19255 }
19256 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19258 if (!SWIG_IsOK(res2)) {
19259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19260 }
19261 arg2 = reinterpret_cast< wxFileType * >(argp2);
19262 {
19263 PyThreadState* __tstate = wxPyBeginAllowThreads();
19264 result = (bool)(arg1)->Unassociate(arg2);
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 {
19269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19270 }
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19278 PyObject *resultobj = 0;
19279 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19280 void *argp1 = 0 ;
19281 int res1 = 0 ;
19282 PyObject *swig_obj[1] ;
19283
19284 if (!args) SWIG_fail;
19285 swig_obj[0] = args;
19286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19287 if (!SWIG_IsOK(res1)) {
19288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19289 }
19290 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 delete arg1;
19294
19295 wxPyEndAllowThreads(__tstate);
19296 if (PyErr_Occurred()) SWIG_fail;
19297 }
19298 resultobj = SWIG_Py_Void();
19299 return resultobj;
19300 fail:
19301 return NULL;
19302 }
19303
19304
19305 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19306 PyObject *obj;
19307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19308 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19309 return SWIG_Py_Void();
19310 }
19311
19312 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19313 return SWIG_Python_InitShadowInstance(args);
19314 }
19315
19316 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19317 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19318 return 1;
19319 }
19320
19321
19322 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19323 PyObject *pyobj = 0;
19324
19325 {
19326 #if wxUSE_UNICODE
19327 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19328 #else
19329 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19330 #endif
19331 }
19332 return pyobj;
19333 }
19334
19335
19336 SWIGINTERN int ART_MENU_set(PyObject *) {
19337 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19338 return 1;
19339 }
19340
19341
19342 SWIGINTERN PyObject *ART_MENU_get(void) {
19343 PyObject *pyobj = 0;
19344
19345 {
19346 #if wxUSE_UNICODE
19347 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19348 #else
19349 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19350 #endif
19351 }
19352 return pyobj;
19353 }
19354
19355
19356 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19357 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19358 return 1;
19359 }
19360
19361
19362 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19363 PyObject *pyobj = 0;
19364
19365 {
19366 #if wxUSE_UNICODE
19367 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19368 #else
19369 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19370 #endif
19371 }
19372 return pyobj;
19373 }
19374
19375
19376 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19377 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19378 return 1;
19379 }
19380
19381
19382 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19383 PyObject *pyobj = 0;
19384
19385 {
19386 #if wxUSE_UNICODE
19387 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19388 #else
19389 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19390 #endif
19391 }
19392 return pyobj;
19393 }
19394
19395
19396 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19397 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19398 return 1;
19399 }
19400
19401
19402 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19403 PyObject *pyobj = 0;
19404
19405 {
19406 #if wxUSE_UNICODE
19407 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19408 #else
19409 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19410 #endif
19411 }
19412 return pyobj;
19413 }
19414
19415
19416 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19417 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19418 return 1;
19419 }
19420
19421
19422 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19423 PyObject *pyobj = 0;
19424
19425 {
19426 #if wxUSE_UNICODE
19427 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19428 #else
19429 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19430 #endif
19431 }
19432 return pyobj;
19433 }
19434
19435
19436 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19437 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19438 return 1;
19439 }
19440
19441
19442 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19443 PyObject *pyobj = 0;
19444
19445 {
19446 #if wxUSE_UNICODE
19447 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19448 #else
19449 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19450 #endif
19451 }
19452 return pyobj;
19453 }
19454
19455
19456 SWIGINTERN int ART_LIST_set(PyObject *) {
19457 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST is read-only.");
19458 return 1;
19459 }
19460
19461
19462 SWIGINTERN PyObject *ART_LIST_get(void) {
19463 PyObject *pyobj = 0;
19464
19465 {
19466 #if wxUSE_UNICODE
19467 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST)->c_str(), (&wxPyART_LIST)->Len());
19468 #else
19469 pyobj = PyString_FromStringAndSize((&wxPyART_LIST)->c_str(), (&wxPyART_LIST)->Len());
19470 #endif
19471 }
19472 return pyobj;
19473 }
19474
19475
19476 SWIGINTERN int ART_OTHER_set(PyObject *) {
19477 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19478 return 1;
19479 }
19480
19481
19482 SWIGINTERN PyObject *ART_OTHER_get(void) {
19483 PyObject *pyobj = 0;
19484
19485 {
19486 #if wxUSE_UNICODE
19487 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19488 #else
19489 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19490 #endif
19491 }
19492 return pyobj;
19493 }
19494
19495
19496 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19497 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19498 return 1;
19499 }
19500
19501
19502 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19503 PyObject *pyobj = 0;
19504
19505 {
19506 #if wxUSE_UNICODE
19507 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19508 #else
19509 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19510 #endif
19511 }
19512 return pyobj;
19513 }
19514
19515
19516 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19517 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19518 return 1;
19519 }
19520
19521
19522 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19523 PyObject *pyobj = 0;
19524
19525 {
19526 #if wxUSE_UNICODE
19527 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19528 #else
19529 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19530 #endif
19531 }
19532 return pyobj;
19533 }
19534
19535
19536 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19537 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19538 return 1;
19539 }
19540
19541
19542 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19543 PyObject *pyobj = 0;
19544
19545 {
19546 #if wxUSE_UNICODE
19547 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19548 #else
19549 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19550 #endif
19551 }
19552 return pyobj;
19553 }
19554
19555
19556 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19557 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19558 return 1;
19559 }
19560
19561
19562 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19563 PyObject *pyobj = 0;
19564
19565 {
19566 #if wxUSE_UNICODE
19567 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19568 #else
19569 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19570 #endif
19571 }
19572 return pyobj;
19573 }
19574
19575
19576 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19577 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19578 return 1;
19579 }
19580
19581
19582 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19583 PyObject *pyobj = 0;
19584
19585 {
19586 #if wxUSE_UNICODE
19587 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19588 #else
19589 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19590 #endif
19591 }
19592 return pyobj;
19593 }
19594
19595
19596 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19597 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19598 return 1;
19599 }
19600
19601
19602 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19603 PyObject *pyobj = 0;
19604
19605 {
19606 #if wxUSE_UNICODE
19607 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19608 #else
19609 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19610 #endif
19611 }
19612 return pyobj;
19613 }
19614
19615
19616 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19617 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19618 return 1;
19619 }
19620
19621
19622 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19623 PyObject *pyobj = 0;
19624
19625 {
19626 #if wxUSE_UNICODE
19627 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19628 #else
19629 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19630 #endif
19631 }
19632 return pyobj;
19633 }
19634
19635
19636 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19637 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19638 return 1;
19639 }
19640
19641
19642 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19643 PyObject *pyobj = 0;
19644
19645 {
19646 #if wxUSE_UNICODE
19647 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19648 #else
19649 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19650 #endif
19651 }
19652 return pyobj;
19653 }
19654
19655
19656 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19657 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19658 return 1;
19659 }
19660
19661
19662 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19663 PyObject *pyobj = 0;
19664
19665 {
19666 #if wxUSE_UNICODE
19667 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19668 #else
19669 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19670 #endif
19671 }
19672 return pyobj;
19673 }
19674
19675
19676 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19677 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19678 return 1;
19679 }
19680
19681
19682 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19683 PyObject *pyobj = 0;
19684
19685 {
19686 #if wxUSE_UNICODE
19687 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19688 #else
19689 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19690 #endif
19691 }
19692 return pyobj;
19693 }
19694
19695
19696 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19697 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19698 return 1;
19699 }
19700
19701
19702 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19703 PyObject *pyobj = 0;
19704
19705 {
19706 #if wxUSE_UNICODE
19707 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19708 #else
19709 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19710 #endif
19711 }
19712 return pyobj;
19713 }
19714
19715
19716 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19717 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19718 return 1;
19719 }
19720
19721
19722 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19723 PyObject *pyobj = 0;
19724
19725 {
19726 #if wxUSE_UNICODE
19727 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19728 #else
19729 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19730 #endif
19731 }
19732 return pyobj;
19733 }
19734
19735
19736 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19737 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19738 return 1;
19739 }
19740
19741
19742 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19743 PyObject *pyobj = 0;
19744
19745 {
19746 #if wxUSE_UNICODE
19747 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19748 #else
19749 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19750 #endif
19751 }
19752 return pyobj;
19753 }
19754
19755
19756 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19757 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19758 return 1;
19759 }
19760
19761
19762 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19763 PyObject *pyobj = 0;
19764
19765 {
19766 #if wxUSE_UNICODE
19767 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19768 #else
19769 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19770 #endif
19771 }
19772 return pyobj;
19773 }
19774
19775
19776 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19777 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19778 return 1;
19779 }
19780
19781
19782 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19783 PyObject *pyobj = 0;
19784
19785 {
19786 #if wxUSE_UNICODE
19787 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19788 #else
19789 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19790 #endif
19791 }
19792 return pyobj;
19793 }
19794
19795
19796 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19797 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19798 return 1;
19799 }
19800
19801
19802 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19803 PyObject *pyobj = 0;
19804
19805 {
19806 #if wxUSE_UNICODE
19807 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19808 #else
19809 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19810 #endif
19811 }
19812 return pyobj;
19813 }
19814
19815
19816 SWIGINTERN int ART_PRINT_set(PyObject *) {
19817 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19818 return 1;
19819 }
19820
19821
19822 SWIGINTERN PyObject *ART_PRINT_get(void) {
19823 PyObject *pyobj = 0;
19824
19825 {
19826 #if wxUSE_UNICODE
19827 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19828 #else
19829 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19830 #endif
19831 }
19832 return pyobj;
19833 }
19834
19835
19836 SWIGINTERN int ART_HELP_set(PyObject *) {
19837 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19838 return 1;
19839 }
19840
19841
19842 SWIGINTERN PyObject *ART_HELP_get(void) {
19843 PyObject *pyobj = 0;
19844
19845 {
19846 #if wxUSE_UNICODE
19847 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19848 #else
19849 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19850 #endif
19851 }
19852 return pyobj;
19853 }
19854
19855
19856 SWIGINTERN int ART_TIP_set(PyObject *) {
19857 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19858 return 1;
19859 }
19860
19861
19862 SWIGINTERN PyObject *ART_TIP_get(void) {
19863 PyObject *pyobj = 0;
19864
19865 {
19866 #if wxUSE_UNICODE
19867 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19868 #else
19869 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19870 #endif
19871 }
19872 return pyobj;
19873 }
19874
19875
19876 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19877 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19878 return 1;
19879 }
19880
19881
19882 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19883 PyObject *pyobj = 0;
19884
19885 {
19886 #if wxUSE_UNICODE
19887 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19888 #else
19889 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19890 #endif
19891 }
19892 return pyobj;
19893 }
19894
19895
19896 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19897 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19898 return 1;
19899 }
19900
19901
19902 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19903 PyObject *pyobj = 0;
19904
19905 {
19906 #if wxUSE_UNICODE
19907 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19908 #else
19909 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19910 #endif
19911 }
19912 return pyobj;
19913 }
19914
19915
19916 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19917 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19918 return 1;
19919 }
19920
19921
19922 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19923 PyObject *pyobj = 0;
19924
19925 {
19926 #if wxUSE_UNICODE
19927 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19928 #else
19929 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19930 #endif
19931 }
19932 return pyobj;
19933 }
19934
19935
19936 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19937 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19938 return 1;
19939 }
19940
19941
19942 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19943 PyObject *pyobj = 0;
19944
19945 {
19946 #if wxUSE_UNICODE
19947 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19948 #else
19949 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19950 #endif
19951 }
19952 return pyobj;
19953 }
19954
19955
19956 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19957 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19958 return 1;
19959 }
19960
19961
19962 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19963 PyObject *pyobj = 0;
19964
19965 {
19966 #if wxUSE_UNICODE
19967 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19968 #else
19969 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19970 #endif
19971 }
19972 return pyobj;
19973 }
19974
19975
19976 SWIGINTERN int ART_CDROM_set(PyObject *) {
19977 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19978 return 1;
19979 }
19980
19981
19982 SWIGINTERN PyObject *ART_CDROM_get(void) {
19983 PyObject *pyobj = 0;
19984
19985 {
19986 #if wxUSE_UNICODE
19987 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19988 #else
19989 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19990 #endif
19991 }
19992 return pyobj;
19993 }
19994
19995
19996 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19997 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19998 return 1;
19999 }
20000
20001
20002 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20003 PyObject *pyobj = 0;
20004
20005 {
20006 #if wxUSE_UNICODE
20007 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20008 #else
20009 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20010 #endif
20011 }
20012 return pyobj;
20013 }
20014
20015
20016 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20017 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20018 return 1;
20019 }
20020
20021
20022 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20023 PyObject *pyobj = 0;
20024
20025 {
20026 #if wxUSE_UNICODE
20027 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20028 #else
20029 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20030 #endif
20031 }
20032 return pyobj;
20033 }
20034
20035
20036 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20037 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20038 return 1;
20039 }
20040
20041
20042 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20043 PyObject *pyobj = 0;
20044
20045 {
20046 #if wxUSE_UNICODE
20047 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20048 #else
20049 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20050 #endif
20051 }
20052 return pyobj;
20053 }
20054
20055
20056 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20057 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20058 return 1;
20059 }
20060
20061
20062 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20063 PyObject *pyobj = 0;
20064
20065 {
20066 #if wxUSE_UNICODE
20067 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20068 #else
20069 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20070 #endif
20071 }
20072 return pyobj;
20073 }
20074
20075
20076 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20077 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20078 return 1;
20079 }
20080
20081
20082 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20083 PyObject *pyobj = 0;
20084
20085 {
20086 #if wxUSE_UNICODE
20087 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20088 #else
20089 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20090 #endif
20091 }
20092 return pyobj;
20093 }
20094
20095
20096 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20097 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20098 return 1;
20099 }
20100
20101
20102 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20103 PyObject *pyobj = 0;
20104
20105 {
20106 #if wxUSE_UNICODE
20107 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20108 #else
20109 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20110 #endif
20111 }
20112 return pyobj;
20113 }
20114
20115
20116 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20117 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20118 return 1;
20119 }
20120
20121
20122 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20123 PyObject *pyobj = 0;
20124
20125 {
20126 #if wxUSE_UNICODE
20127 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20128 #else
20129 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20130 #endif
20131 }
20132 return pyobj;
20133 }
20134
20135
20136 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20137 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20138 return 1;
20139 }
20140
20141
20142 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20143 PyObject *pyobj = 0;
20144
20145 {
20146 #if wxUSE_UNICODE
20147 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20148 #else
20149 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20150 #endif
20151 }
20152 return pyobj;
20153 }
20154
20155
20156 SWIGINTERN int ART_ERROR_set(PyObject *) {
20157 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20158 return 1;
20159 }
20160
20161
20162 SWIGINTERN PyObject *ART_ERROR_get(void) {
20163 PyObject *pyobj = 0;
20164
20165 {
20166 #if wxUSE_UNICODE
20167 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20168 #else
20169 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20170 #endif
20171 }
20172 return pyobj;
20173 }
20174
20175
20176 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20177 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20178 return 1;
20179 }
20180
20181
20182 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20183 PyObject *pyobj = 0;
20184
20185 {
20186 #if wxUSE_UNICODE
20187 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20188 #else
20189 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20190 #endif
20191 }
20192 return pyobj;
20193 }
20194
20195
20196 SWIGINTERN int ART_WARNING_set(PyObject *) {
20197 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20198 return 1;
20199 }
20200
20201
20202 SWIGINTERN PyObject *ART_WARNING_get(void) {
20203 PyObject *pyobj = 0;
20204
20205 {
20206 #if wxUSE_UNICODE
20207 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20208 #else
20209 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20210 #endif
20211 }
20212 return pyobj;
20213 }
20214
20215
20216 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20217 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20218 return 1;
20219 }
20220
20221
20222 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20223 PyObject *pyobj = 0;
20224
20225 {
20226 #if wxUSE_UNICODE
20227 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20228 #else
20229 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20230 #endif
20231 }
20232 return pyobj;
20233 }
20234
20235
20236 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20237 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20238 return 1;
20239 }
20240
20241
20242 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20243 PyObject *pyobj = 0;
20244
20245 {
20246 #if wxUSE_UNICODE
20247 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20248 #else
20249 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20250 #endif
20251 }
20252 return pyobj;
20253 }
20254
20255
20256 SWIGINTERN int ART_COPY_set(PyObject *) {
20257 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20258 return 1;
20259 }
20260
20261
20262 SWIGINTERN PyObject *ART_COPY_get(void) {
20263 PyObject *pyobj = 0;
20264
20265 {
20266 #if wxUSE_UNICODE
20267 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20268 #else
20269 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20270 #endif
20271 }
20272 return pyobj;
20273 }
20274
20275
20276 SWIGINTERN int ART_CUT_set(PyObject *) {
20277 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20278 return 1;
20279 }
20280
20281
20282 SWIGINTERN PyObject *ART_CUT_get(void) {
20283 PyObject *pyobj = 0;
20284
20285 {
20286 #if wxUSE_UNICODE
20287 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20288 #else
20289 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20290 #endif
20291 }
20292 return pyobj;
20293 }
20294
20295
20296 SWIGINTERN int ART_PASTE_set(PyObject *) {
20297 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20298 return 1;
20299 }
20300
20301
20302 SWIGINTERN PyObject *ART_PASTE_get(void) {
20303 PyObject *pyobj = 0;
20304
20305 {
20306 #if wxUSE_UNICODE
20307 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20308 #else
20309 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20310 #endif
20311 }
20312 return pyobj;
20313 }
20314
20315
20316 SWIGINTERN int ART_DELETE_set(PyObject *) {
20317 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20318 return 1;
20319 }
20320
20321
20322 SWIGINTERN PyObject *ART_DELETE_get(void) {
20323 PyObject *pyobj = 0;
20324
20325 {
20326 #if wxUSE_UNICODE
20327 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20328 #else
20329 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20330 #endif
20331 }
20332 return pyobj;
20333 }
20334
20335
20336 SWIGINTERN int ART_NEW_set(PyObject *) {
20337 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20338 return 1;
20339 }
20340
20341
20342 SWIGINTERN PyObject *ART_NEW_get(void) {
20343 PyObject *pyobj = 0;
20344
20345 {
20346 #if wxUSE_UNICODE
20347 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20348 #else
20349 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20350 #endif
20351 }
20352 return pyobj;
20353 }
20354
20355
20356 SWIGINTERN int ART_UNDO_set(PyObject *) {
20357 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20358 return 1;
20359 }
20360
20361
20362 SWIGINTERN PyObject *ART_UNDO_get(void) {
20363 PyObject *pyobj = 0;
20364
20365 {
20366 #if wxUSE_UNICODE
20367 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20368 #else
20369 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20370 #endif
20371 }
20372 return pyobj;
20373 }
20374
20375
20376 SWIGINTERN int ART_REDO_set(PyObject *) {
20377 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20378 return 1;
20379 }
20380
20381
20382 SWIGINTERN PyObject *ART_REDO_get(void) {
20383 PyObject *pyobj = 0;
20384
20385 {
20386 #if wxUSE_UNICODE
20387 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20388 #else
20389 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20390 #endif
20391 }
20392 return pyobj;
20393 }
20394
20395
20396 SWIGINTERN int ART_QUIT_set(PyObject *) {
20397 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20398 return 1;
20399 }
20400
20401
20402 SWIGINTERN PyObject *ART_QUIT_get(void) {
20403 PyObject *pyobj = 0;
20404
20405 {
20406 #if wxUSE_UNICODE
20407 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20408 #else
20409 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20410 #endif
20411 }
20412 return pyobj;
20413 }
20414
20415
20416 SWIGINTERN int ART_FIND_set(PyObject *) {
20417 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20418 return 1;
20419 }
20420
20421
20422 SWIGINTERN PyObject *ART_FIND_get(void) {
20423 PyObject *pyobj = 0;
20424
20425 {
20426 #if wxUSE_UNICODE
20427 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20428 #else
20429 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20430 #endif
20431 }
20432 return pyobj;
20433 }
20434
20435
20436 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20437 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20438 return 1;
20439 }
20440
20441
20442 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20443 PyObject *pyobj = 0;
20444
20445 {
20446 #if wxUSE_UNICODE
20447 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20448 #else
20449 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20450 #endif
20451 }
20452 return pyobj;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 PyObject *resultobj = 0;
20458 wxPyArtProvider *result = 0 ;
20459
20460 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20461 {
20462 if (!wxPyCheckForApp()) SWIG_fail;
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 result = (wxPyArtProvider *)new wxPyArtProvider();
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20476 PyObject *resultobj = 0;
20477 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20478 void *argp1 = 0 ;
20479 int res1 = 0 ;
20480 PyObject *swig_obj[1] ;
20481
20482 if (!args) SWIG_fail;
20483 swig_obj[0] = args;
20484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20485 if (!SWIG_IsOK(res1)) {
20486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20487 }
20488 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20489 {
20490 PyThreadState* __tstate = wxPyBeginAllowThreads();
20491 delete arg1;
20492
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 resultobj = SWIG_Py_Void();
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20504 PyObject *resultobj = 0;
20505 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20506 PyObject *arg2 = (PyObject *) 0 ;
20507 PyObject *arg3 = (PyObject *) 0 ;
20508 void *argp1 = 0 ;
20509 int res1 = 0 ;
20510 PyObject * obj0 = 0 ;
20511 PyObject * obj1 = 0 ;
20512 PyObject * obj2 = 0 ;
20513 char * kwnames[] = {
20514 (char *) "self",(char *) "self",(char *) "_class", NULL
20515 };
20516
20517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20519 if (!SWIG_IsOK(res1)) {
20520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20521 }
20522 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20523 arg2 = obj1;
20524 arg3 = obj2;
20525 {
20526 PyThreadState* __tstate = wxPyBeginAllowThreads();
20527 (arg1)->_setCallbackInfo(arg2,arg3);
20528 wxPyEndAllowThreads(__tstate);
20529 if (PyErr_Occurred()) SWIG_fail;
20530 }
20531 resultobj = SWIG_Py_Void();
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20539 PyObject *resultobj = 0;
20540 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20541 int res1 = 0 ;
20542 PyObject * obj0 = 0 ;
20543 char * kwnames[] = {
20544 (char *) "provider", NULL
20545 };
20546
20547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20548 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20549 if (!SWIG_IsOK(res1)) {
20550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20551 }
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 wxPyArtProvider::Push(arg1);
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 resultobj = SWIG_Py_Void();
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj = 0;
20567 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20568 int res1 = 0 ;
20569 PyObject * obj0 = 0 ;
20570 char * kwnames[] = {
20571 (char *) "provider", NULL
20572 };
20573
20574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20575 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20576 if (!SWIG_IsOK(res1)) {
20577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20578 }
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 wxPyArtProvider::Insert(arg1);
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 resultobj = SWIG_Py_Void();
20586 return resultobj;
20587 fail:
20588 return NULL;
20589 }
20590
20591
20592 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20593 PyObject *resultobj = 0;
20594 bool result;
20595
20596 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (bool)wxPyArtProvider::Pop();
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 {
20604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20605 }
20606 return resultobj;
20607 fail:
20608 return NULL;
20609 }
20610
20611
20612 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20613 PyObject *resultobj = 0;
20614 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20615 bool result;
20616 void *argp1 = 0 ;
20617 int res1 = 0 ;
20618 PyObject * obj0 = 0 ;
20619 char * kwnames[] = {
20620 (char *) "provider", NULL
20621 };
20622
20623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20625 if (!SWIG_IsOK(res1)) {
20626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20627 }
20628 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (bool)wxPyArtProvider::Delete(arg1);
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20645 PyObject *resultobj = 0;
20646 wxString *arg1 = 0 ;
20647 wxString const &arg2_defvalue = wxPyART_OTHER ;
20648 wxString *arg2 = (wxString *) &arg2_defvalue ;
20649 wxSize const &arg3_defvalue = wxDefaultSize ;
20650 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20651 wxBitmap result;
20652 bool temp1 = false ;
20653 bool temp2 = false ;
20654 wxSize temp3 ;
20655 PyObject * obj0 = 0 ;
20656 PyObject * obj1 = 0 ;
20657 PyObject * obj2 = 0 ;
20658 char * kwnames[] = {
20659 (char *) "id",(char *) "client",(char *) "size", NULL
20660 };
20661
20662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20663 {
20664 arg1 = wxString_in_helper(obj0);
20665 if (arg1 == NULL) SWIG_fail;
20666 temp1 = true;
20667 }
20668 if (obj1) {
20669 {
20670 arg2 = wxString_in_helper(obj1);
20671 if (arg2 == NULL) SWIG_fail;
20672 temp2 = true;
20673 }
20674 }
20675 if (obj2) {
20676 {
20677 arg3 = &temp3;
20678 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20679 }
20680 }
20681 {
20682 if (!wxPyCheckForApp()) SWIG_fail;
20683 PyThreadState* __tstate = wxPyBeginAllowThreads();
20684 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20689 {
20690 if (temp1)
20691 delete arg1;
20692 }
20693 {
20694 if (temp2)
20695 delete arg2;
20696 }
20697 return resultobj;
20698 fail:
20699 {
20700 if (temp1)
20701 delete arg1;
20702 }
20703 {
20704 if (temp2)
20705 delete arg2;
20706 }
20707 return NULL;
20708 }
20709
20710
20711 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20712 PyObject *resultobj = 0;
20713 wxString *arg1 = 0 ;
20714 wxString const &arg2_defvalue = wxPyART_OTHER ;
20715 wxString *arg2 = (wxString *) &arg2_defvalue ;
20716 wxSize const &arg3_defvalue = wxDefaultSize ;
20717 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20718 wxIcon result;
20719 bool temp1 = false ;
20720 bool temp2 = false ;
20721 wxSize temp3 ;
20722 PyObject * obj0 = 0 ;
20723 PyObject * obj1 = 0 ;
20724 PyObject * obj2 = 0 ;
20725 char * kwnames[] = {
20726 (char *) "id",(char *) "client",(char *) "size", NULL
20727 };
20728
20729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20730 {
20731 arg1 = wxString_in_helper(obj0);
20732 if (arg1 == NULL) SWIG_fail;
20733 temp1 = true;
20734 }
20735 if (obj1) {
20736 {
20737 arg2 = wxString_in_helper(obj1);
20738 if (arg2 == NULL) SWIG_fail;
20739 temp2 = true;
20740 }
20741 }
20742 if (obj2) {
20743 {
20744 arg3 = &temp3;
20745 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20746 }
20747 }
20748 {
20749 if (!wxPyCheckForApp()) SWIG_fail;
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20752 wxPyEndAllowThreads(__tstate);
20753 if (PyErr_Occurred()) SWIG_fail;
20754 }
20755 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20756 {
20757 if (temp1)
20758 delete arg1;
20759 }
20760 {
20761 if (temp2)
20762 delete arg2;
20763 }
20764 return resultobj;
20765 fail:
20766 {
20767 if (temp1)
20768 delete arg1;
20769 }
20770 {
20771 if (temp2)
20772 delete arg2;
20773 }
20774 return NULL;
20775 }
20776
20777
20778 SWIGINTERN PyObject *_wrap_ArtProvider_GetIconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20779 PyObject *resultobj = 0;
20780 wxArtID *arg1 = 0 ;
20781 wxArtClient const &arg2_defvalue = wxART_OTHER ;
20782 wxArtClient *arg2 = (wxArtClient *) &arg2_defvalue ;
20783 wxIconBundle result;
20784 void *argp1 = 0 ;
20785 int res1 = 0 ;
20786 void *argp2 = 0 ;
20787 int res2 = 0 ;
20788 PyObject * obj0 = 0 ;
20789 PyObject * obj1 = 0 ;
20790 char * kwnames[] = {
20791 (char *) "id",(char *) "client", NULL
20792 };
20793
20794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetIconBundle",kwnames,&obj0,&obj1)) SWIG_fail;
20795 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxArtID, 0 | 0);
20796 if (!SWIG_IsOK(res1)) {
20797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_GetIconBundle" "', expected argument " "1"" of type '" "wxArtID const &""'");
20798 }
20799 if (!argp1) {
20800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArtProvider_GetIconBundle" "', expected argument " "1"" of type '" "wxArtID const &""'");
20801 }
20802 arg1 = reinterpret_cast< wxArtID * >(argp1);
20803 if (obj1) {
20804 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxArtClient, 0 | 0);
20805 if (!SWIG_IsOK(res2)) {
20806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArtProvider_GetIconBundle" "', expected argument " "2"" of type '" "wxArtClient const &""'");
20807 }
20808 if (!argp2) {
20809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArtProvider_GetIconBundle" "', expected argument " "2"" of type '" "wxArtClient const &""'");
20810 }
20811 arg2 = reinterpret_cast< wxArtClient * >(argp2);
20812 }
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = wxPyArtProvider::GetIconBundle((wxArtID const &)*arg1,(wxArtClient const &)*arg2);
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj((new wxIconBundle(static_cast< const wxIconBundle& >(result))), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj = 0;
20828 wxString *arg1 = 0 ;
20829 bool arg2 = (bool) false ;
20830 wxSize result;
20831 bool temp1 = false ;
20832 bool val2 ;
20833 int ecode2 = 0 ;
20834 PyObject * obj0 = 0 ;
20835 PyObject * obj1 = 0 ;
20836 char * kwnames[] = {
20837 (char *) "client",(char *) "platform_dependent", NULL
20838 };
20839
20840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20841 {
20842 arg1 = wxString_in_helper(obj0);
20843 if (arg1 == NULL) SWIG_fail;
20844 temp1 = true;
20845 }
20846 if (obj1) {
20847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20848 if (!SWIG_IsOK(ecode2)) {
20849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20850 }
20851 arg2 = static_cast< bool >(val2);
20852 }
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20860 {
20861 if (temp1)
20862 delete arg1;
20863 }
20864 return resultobj;
20865 fail:
20866 {
20867 if (temp1)
20868 delete arg1;
20869 }
20870 return NULL;
20871 }
20872
20873
20874 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20875 PyObject *resultobj = 0;
20876 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20877 void *argp1 = 0 ;
20878 int res1 = 0 ;
20879 PyObject *swig_obj[1] ;
20880
20881 if (!args) SWIG_fail;
20882 swig_obj[0] = args;
20883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20884 if (!SWIG_IsOK(res1)) {
20885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20886 }
20887 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 wxPyArtProvider_Destroy(arg1);
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 resultobj = SWIG_Py_Void();
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20902 PyObject *obj;
20903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20904 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20905 return SWIG_Py_Void();
20906 }
20907
20908 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20909 return SWIG_Python_InitShadowInstance(args);
20910 }
20911
20912 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20913 PyObject *resultobj = 0;
20914 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20915 void *argp1 = 0 ;
20916 int res1 = 0 ;
20917 PyObject *swig_obj[1] ;
20918
20919 if (!args) SWIG_fail;
20920 swig_obj[0] = args;
20921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20922 if (!SWIG_IsOK(res1)) {
20923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20924 }
20925 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 delete arg1;
20929
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 resultobj = SWIG_Py_Void();
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20941 PyObject *resultobj = 0;
20942 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20943 wxConfigBase *result = 0 ;
20944 int res1 = 0 ;
20945 PyObject * obj0 = 0 ;
20946 char * kwnames[] = {
20947 (char *) "config", NULL
20948 };
20949
20950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20951 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20952 if (!SWIG_IsOK(res1)) {
20953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20954 }
20955 {
20956 PyThreadState* __tstate = wxPyBeginAllowThreads();
20957 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj = 0;
20970 bool arg1 = (bool) true ;
20971 wxConfigBase *result = 0 ;
20972 bool val1 ;
20973 int ecode1 = 0 ;
20974 PyObject * obj0 = 0 ;
20975 char * kwnames[] = {
20976 (char *) "createOnDemand", NULL
20977 };
20978
20979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20980 if (obj0) {
20981 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20982 if (!SWIG_IsOK(ecode1)) {
20983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20984 }
20985 arg1 = static_cast< bool >(val1);
20986 }
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21001 PyObject *resultobj = 0;
21002 wxConfigBase *result = 0 ;
21003
21004 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (wxConfigBase *)wxConfigBase::Create();
21008 wxPyEndAllowThreads(__tstate);
21009 if (PyErr_Occurred()) SWIG_fail;
21010 }
21011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
21012 return resultobj;
21013 fail:
21014 return NULL;
21015 }
21016
21017
21018 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21019 PyObject *resultobj = 0;
21020
21021 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
21022 {
21023 PyThreadState* __tstate = wxPyBeginAllowThreads();
21024 wxConfigBase::DontCreateOnDemand();
21025 wxPyEndAllowThreads(__tstate);
21026 if (PyErr_Occurred()) SWIG_fail;
21027 }
21028 resultobj = SWIG_Py_Void();
21029 return resultobj;
21030 fail:
21031 return NULL;
21032 }
21033
21034
21035 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21036 PyObject *resultobj = 0;
21037 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21038 wxString *arg2 = 0 ;
21039 void *argp1 = 0 ;
21040 int res1 = 0 ;
21041 bool temp2 = false ;
21042 PyObject * obj0 = 0 ;
21043 PyObject * obj1 = 0 ;
21044 char * kwnames[] = {
21045 (char *) "self",(char *) "path", NULL
21046 };
21047
21048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21050 if (!SWIG_IsOK(res1)) {
21051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21052 }
21053 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21054 {
21055 arg2 = wxString_in_helper(obj1);
21056 if (arg2 == NULL) SWIG_fail;
21057 temp2 = true;
21058 }
21059 {
21060 PyThreadState* __tstate = wxPyBeginAllowThreads();
21061 (arg1)->SetPath((wxString const &)*arg2);
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 resultobj = SWIG_Py_Void();
21066 {
21067 if (temp2)
21068 delete arg2;
21069 }
21070 return resultobj;
21071 fail:
21072 {
21073 if (temp2)
21074 delete arg2;
21075 }
21076 return NULL;
21077 }
21078
21079
21080 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21081 PyObject *resultobj = 0;
21082 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21083 wxString *result = 0 ;
21084 void *argp1 = 0 ;
21085 int res1 = 0 ;
21086 PyObject *swig_obj[1] ;
21087
21088 if (!args) SWIG_fail;
21089 swig_obj[0] = args;
21090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21091 if (!SWIG_IsOK(res1)) {
21092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21093 }
21094 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 {
21098 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21099 result = (wxString *) &_result_ref;
21100 }
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 {
21105 #if wxUSE_UNICODE
21106 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21107 #else
21108 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21109 #endif
21110 }
21111 return resultobj;
21112 fail:
21113 return NULL;
21114 }
21115
21116
21117 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21118 PyObject *resultobj = 0;
21119 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21120 PyObject *result = 0 ;
21121 void *argp1 = 0 ;
21122 int res1 = 0 ;
21123 PyObject *swig_obj[1] ;
21124
21125 if (!args) SWIG_fail;
21126 swig_obj[0] = args;
21127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21128 if (!SWIG_IsOK(res1)) {
21129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21130 }
21131 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21135 wxPyEndAllowThreads(__tstate);
21136 if (PyErr_Occurred()) SWIG_fail;
21137 }
21138 resultobj = result;
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21146 PyObject *resultobj = 0;
21147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21148 long arg2 ;
21149 PyObject *result = 0 ;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 long val2 ;
21153 int ecode2 = 0 ;
21154 PyObject * obj0 = 0 ;
21155 PyObject * obj1 = 0 ;
21156 char * kwnames[] = {
21157 (char *) "self",(char *) "index", NULL
21158 };
21159
21160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21162 if (!SWIG_IsOK(res1)) {
21163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21164 }
21165 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21166 ecode2 = SWIG_AsVal_long(obj1, &val2);
21167 if (!SWIG_IsOK(ecode2)) {
21168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21169 }
21170 arg2 = static_cast< long >(val2);
21171 {
21172 PyThreadState* __tstate = wxPyBeginAllowThreads();
21173 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 resultobj = result;
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21185 PyObject *resultobj = 0;
21186 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21187 PyObject *result = 0 ;
21188 void *argp1 = 0 ;
21189 int res1 = 0 ;
21190 PyObject *swig_obj[1] ;
21191
21192 if (!args) SWIG_fail;
21193 swig_obj[0] = args;
21194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21195 if (!SWIG_IsOK(res1)) {
21196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21197 }
21198 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21199 {
21200 PyThreadState* __tstate = wxPyBeginAllowThreads();
21201 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21202 wxPyEndAllowThreads(__tstate);
21203 if (PyErr_Occurred()) SWIG_fail;
21204 }
21205 resultobj = result;
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21213 PyObject *resultobj = 0;
21214 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21215 long arg2 ;
21216 PyObject *result = 0 ;
21217 void *argp1 = 0 ;
21218 int res1 = 0 ;
21219 long val2 ;
21220 int ecode2 = 0 ;
21221 PyObject * obj0 = 0 ;
21222 PyObject * obj1 = 0 ;
21223 char * kwnames[] = {
21224 (char *) "self",(char *) "index", NULL
21225 };
21226
21227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21229 if (!SWIG_IsOK(res1)) {
21230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21231 }
21232 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21233 ecode2 = SWIG_AsVal_long(obj1, &val2);
21234 if (!SWIG_IsOK(ecode2)) {
21235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21236 }
21237 arg2 = static_cast< long >(val2);
21238 {
21239 PyThreadState* __tstate = wxPyBeginAllowThreads();
21240 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 resultobj = result;
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21252 PyObject *resultobj = 0;
21253 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21254 bool arg2 = (bool) false ;
21255 size_t result;
21256 void *argp1 = 0 ;
21257 int res1 = 0 ;
21258 bool val2 ;
21259 int ecode2 = 0 ;
21260 PyObject * obj0 = 0 ;
21261 PyObject * obj1 = 0 ;
21262 char * kwnames[] = {
21263 (char *) "self",(char *) "recursive", NULL
21264 };
21265
21266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21268 if (!SWIG_IsOK(res1)) {
21269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21270 }
21271 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21272 if (obj1) {
21273 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21274 if (!SWIG_IsOK(ecode2)) {
21275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21276 }
21277 arg2 = static_cast< bool >(val2);
21278 }
21279 {
21280 PyThreadState* __tstate = wxPyBeginAllowThreads();
21281 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21282 wxPyEndAllowThreads(__tstate);
21283 if (PyErr_Occurred()) SWIG_fail;
21284 }
21285 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21286 return resultobj;
21287 fail:
21288 return NULL;
21289 }
21290
21291
21292 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21293 PyObject *resultobj = 0;
21294 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21295 bool arg2 = (bool) false ;
21296 size_t result;
21297 void *argp1 = 0 ;
21298 int res1 = 0 ;
21299 bool val2 ;
21300 int ecode2 = 0 ;
21301 PyObject * obj0 = 0 ;
21302 PyObject * obj1 = 0 ;
21303 char * kwnames[] = {
21304 (char *) "self",(char *) "recursive", NULL
21305 };
21306
21307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21311 }
21312 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21313 if (obj1) {
21314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21315 if (!SWIG_IsOK(ecode2)) {
21316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21317 }
21318 arg2 = static_cast< bool >(val2);
21319 }
21320 {
21321 PyThreadState* __tstate = wxPyBeginAllowThreads();
21322 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21323 wxPyEndAllowThreads(__tstate);
21324 if (PyErr_Occurred()) SWIG_fail;
21325 }
21326 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21327 return resultobj;
21328 fail:
21329 return NULL;
21330 }
21331
21332
21333 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21334 PyObject *resultobj = 0;
21335 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21336 wxString *arg2 = 0 ;
21337 bool result;
21338 void *argp1 = 0 ;
21339 int res1 = 0 ;
21340 bool temp2 = false ;
21341 PyObject * obj0 = 0 ;
21342 PyObject * obj1 = 0 ;
21343 char * kwnames[] = {
21344 (char *) "self",(char *) "name", NULL
21345 };
21346
21347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21349 if (!SWIG_IsOK(res1)) {
21350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21351 }
21352 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21353 {
21354 arg2 = wxString_in_helper(obj1);
21355 if (arg2 == NULL) SWIG_fail;
21356 temp2 = true;
21357 }
21358 {
21359 PyThreadState* __tstate = wxPyBeginAllowThreads();
21360 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21361 wxPyEndAllowThreads(__tstate);
21362 if (PyErr_Occurred()) SWIG_fail;
21363 }
21364 {
21365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21366 }
21367 {
21368 if (temp2)
21369 delete arg2;
21370 }
21371 return resultobj;
21372 fail:
21373 {
21374 if (temp2)
21375 delete arg2;
21376 }
21377 return NULL;
21378 }
21379
21380
21381 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21382 PyObject *resultobj = 0;
21383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21384 wxString *arg2 = 0 ;
21385 bool result;
21386 void *argp1 = 0 ;
21387 int res1 = 0 ;
21388 bool temp2 = false ;
21389 PyObject * obj0 = 0 ;
21390 PyObject * obj1 = 0 ;
21391 char * kwnames[] = {
21392 (char *) "self",(char *) "name", NULL
21393 };
21394
21395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21397 if (!SWIG_IsOK(res1)) {
21398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21399 }
21400 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21401 {
21402 arg2 = wxString_in_helper(obj1);
21403 if (arg2 == NULL) SWIG_fail;
21404 temp2 = true;
21405 }
21406 {
21407 PyThreadState* __tstate = wxPyBeginAllowThreads();
21408 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21409 wxPyEndAllowThreads(__tstate);
21410 if (PyErr_Occurred()) SWIG_fail;
21411 }
21412 {
21413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21414 }
21415 {
21416 if (temp2)
21417 delete arg2;
21418 }
21419 return resultobj;
21420 fail:
21421 {
21422 if (temp2)
21423 delete arg2;
21424 }
21425 return NULL;
21426 }
21427
21428
21429 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21430 PyObject *resultobj = 0;
21431 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21432 wxString *arg2 = 0 ;
21433 bool result;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 bool temp2 = false ;
21437 PyObject * obj0 = 0 ;
21438 PyObject * obj1 = 0 ;
21439 char * kwnames[] = {
21440 (char *) "self",(char *) "name", NULL
21441 };
21442
21443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21445 if (!SWIG_IsOK(res1)) {
21446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21447 }
21448 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21449 {
21450 arg2 = wxString_in_helper(obj1);
21451 if (arg2 == NULL) SWIG_fail;
21452 temp2 = true;
21453 }
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 {
21461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21462 }
21463 {
21464 if (temp2)
21465 delete arg2;
21466 }
21467 return resultobj;
21468 fail:
21469 {
21470 if (temp2)
21471 delete arg2;
21472 }
21473 return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21478 PyObject *resultobj = 0;
21479 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21480 wxString *arg2 = 0 ;
21481 wxConfigBase::EntryType result;
21482 void *argp1 = 0 ;
21483 int res1 = 0 ;
21484 bool temp2 = false ;
21485 PyObject * obj0 = 0 ;
21486 PyObject * obj1 = 0 ;
21487 char * kwnames[] = {
21488 (char *) "self",(char *) "name", NULL
21489 };
21490
21491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21493 if (!SWIG_IsOK(res1)) {
21494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21495 }
21496 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21497 {
21498 arg2 = wxString_in_helper(obj1);
21499 if (arg2 == NULL) SWIG_fail;
21500 temp2 = true;
21501 }
21502 {
21503 PyThreadState* __tstate = wxPyBeginAllowThreads();
21504 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21505 wxPyEndAllowThreads(__tstate);
21506 if (PyErr_Occurred()) SWIG_fail;
21507 }
21508 resultobj = SWIG_From_int(static_cast< int >(result));
21509 {
21510 if (temp2)
21511 delete arg2;
21512 }
21513 return resultobj;
21514 fail:
21515 {
21516 if (temp2)
21517 delete arg2;
21518 }
21519 return NULL;
21520 }
21521
21522
21523 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21524 PyObject *resultobj = 0;
21525 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21526 wxString *arg2 = 0 ;
21527 wxString const &arg3_defvalue = wxPyEmptyString ;
21528 wxString *arg3 = (wxString *) &arg3_defvalue ;
21529 wxString result;
21530 void *argp1 = 0 ;
21531 int res1 = 0 ;
21532 bool temp2 = false ;
21533 bool temp3 = false ;
21534 PyObject * obj0 = 0 ;
21535 PyObject * obj1 = 0 ;
21536 PyObject * obj2 = 0 ;
21537 char * kwnames[] = {
21538 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21539 };
21540
21541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21543 if (!SWIG_IsOK(res1)) {
21544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21545 }
21546 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21547 {
21548 arg2 = wxString_in_helper(obj1);
21549 if (arg2 == NULL) SWIG_fail;
21550 temp2 = true;
21551 }
21552 if (obj2) {
21553 {
21554 arg3 = wxString_in_helper(obj2);
21555 if (arg3 == NULL) SWIG_fail;
21556 temp3 = true;
21557 }
21558 }
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21562 wxPyEndAllowThreads(__tstate);
21563 if (PyErr_Occurred()) SWIG_fail;
21564 }
21565 {
21566 #if wxUSE_UNICODE
21567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21568 #else
21569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21570 #endif
21571 }
21572 {
21573 if (temp2)
21574 delete arg2;
21575 }
21576 {
21577 if (temp3)
21578 delete arg3;
21579 }
21580 return resultobj;
21581 fail:
21582 {
21583 if (temp2)
21584 delete arg2;
21585 }
21586 {
21587 if (temp3)
21588 delete arg3;
21589 }
21590 return NULL;
21591 }
21592
21593
21594 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21595 PyObject *resultobj = 0;
21596 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21597 wxString *arg2 = 0 ;
21598 long arg3 = (long) 0 ;
21599 long result;
21600 void *argp1 = 0 ;
21601 int res1 = 0 ;
21602 bool temp2 = false ;
21603 long val3 ;
21604 int ecode3 = 0 ;
21605 PyObject * obj0 = 0 ;
21606 PyObject * obj1 = 0 ;
21607 PyObject * obj2 = 0 ;
21608 char * kwnames[] = {
21609 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21610 };
21611
21612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21614 if (!SWIG_IsOK(res1)) {
21615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21616 }
21617 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21618 {
21619 arg2 = wxString_in_helper(obj1);
21620 if (arg2 == NULL) SWIG_fail;
21621 temp2 = true;
21622 }
21623 if (obj2) {
21624 ecode3 = SWIG_AsVal_long(obj2, &val3);
21625 if (!SWIG_IsOK(ecode3)) {
21626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21627 }
21628 arg3 = static_cast< long >(val3);
21629 }
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21633 wxPyEndAllowThreads(__tstate);
21634 if (PyErr_Occurred()) SWIG_fail;
21635 }
21636 resultobj = SWIG_From_long(static_cast< long >(result));
21637 {
21638 if (temp2)
21639 delete arg2;
21640 }
21641 return resultobj;
21642 fail:
21643 {
21644 if (temp2)
21645 delete arg2;
21646 }
21647 return NULL;
21648 }
21649
21650
21651 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21652 PyObject *resultobj = 0;
21653 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21654 wxString *arg2 = 0 ;
21655 double arg3 = (double) 0.0 ;
21656 double result;
21657 void *argp1 = 0 ;
21658 int res1 = 0 ;
21659 bool temp2 = false ;
21660 double val3 ;
21661 int ecode3 = 0 ;
21662 PyObject * obj0 = 0 ;
21663 PyObject * obj1 = 0 ;
21664 PyObject * obj2 = 0 ;
21665 char * kwnames[] = {
21666 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21667 };
21668
21669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21671 if (!SWIG_IsOK(res1)) {
21672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21673 }
21674 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21675 {
21676 arg2 = wxString_in_helper(obj1);
21677 if (arg2 == NULL) SWIG_fail;
21678 temp2 = true;
21679 }
21680 if (obj2) {
21681 ecode3 = SWIG_AsVal_double(obj2, &val3);
21682 if (!SWIG_IsOK(ecode3)) {
21683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21684 }
21685 arg3 = static_cast< double >(val3);
21686 }
21687 {
21688 PyThreadState* __tstate = wxPyBeginAllowThreads();
21689 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 resultobj = SWIG_From_double(static_cast< double >(result));
21694 {
21695 if (temp2)
21696 delete arg2;
21697 }
21698 return resultobj;
21699 fail:
21700 {
21701 if (temp2)
21702 delete arg2;
21703 }
21704 return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj = 0;
21710 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21711 wxString *arg2 = 0 ;
21712 bool arg3 = (bool) false ;
21713 bool result;
21714 void *argp1 = 0 ;
21715 int res1 = 0 ;
21716 bool temp2 = false ;
21717 bool val3 ;
21718 int ecode3 = 0 ;
21719 PyObject * obj0 = 0 ;
21720 PyObject * obj1 = 0 ;
21721 PyObject * obj2 = 0 ;
21722 char * kwnames[] = {
21723 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21724 };
21725
21726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21728 if (!SWIG_IsOK(res1)) {
21729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21730 }
21731 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21732 {
21733 arg2 = wxString_in_helper(obj1);
21734 if (arg2 == NULL) SWIG_fail;
21735 temp2 = true;
21736 }
21737 if (obj2) {
21738 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21739 if (!SWIG_IsOK(ecode3)) {
21740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21741 }
21742 arg3 = static_cast< bool >(val3);
21743 }
21744 {
21745 PyThreadState* __tstate = wxPyBeginAllowThreads();
21746 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21747 wxPyEndAllowThreads(__tstate);
21748 if (PyErr_Occurred()) SWIG_fail;
21749 }
21750 {
21751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21752 }
21753 {
21754 if (temp2)
21755 delete arg2;
21756 }
21757 return resultobj;
21758 fail:
21759 {
21760 if (temp2)
21761 delete arg2;
21762 }
21763 return NULL;
21764 }
21765
21766
21767 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21768 PyObject *resultobj = 0;
21769 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21770 wxString *arg2 = 0 ;
21771 wxString *arg3 = 0 ;
21772 bool result;
21773 void *argp1 = 0 ;
21774 int res1 = 0 ;
21775 bool temp2 = false ;
21776 bool temp3 = false ;
21777 PyObject * obj0 = 0 ;
21778 PyObject * obj1 = 0 ;
21779 PyObject * obj2 = 0 ;
21780 char * kwnames[] = {
21781 (char *) "self",(char *) "key",(char *) "value", NULL
21782 };
21783
21784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21786 if (!SWIG_IsOK(res1)) {
21787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21788 }
21789 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21790 {
21791 arg2 = wxString_in_helper(obj1);
21792 if (arg2 == NULL) SWIG_fail;
21793 temp2 = true;
21794 }
21795 {
21796 arg3 = wxString_in_helper(obj2);
21797 if (arg3 == NULL) SWIG_fail;
21798 temp3 = true;
21799 }
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 {
21807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21808 }
21809 {
21810 if (temp2)
21811 delete arg2;
21812 }
21813 {
21814 if (temp3)
21815 delete arg3;
21816 }
21817 return resultobj;
21818 fail:
21819 {
21820 if (temp2)
21821 delete arg2;
21822 }
21823 {
21824 if (temp3)
21825 delete arg3;
21826 }
21827 return NULL;
21828 }
21829
21830
21831 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21832 PyObject *resultobj = 0;
21833 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21834 wxString *arg2 = 0 ;
21835 long arg3 ;
21836 bool result;
21837 void *argp1 = 0 ;
21838 int res1 = 0 ;
21839 bool temp2 = false ;
21840 long val3 ;
21841 int ecode3 = 0 ;
21842 PyObject * obj0 = 0 ;
21843 PyObject * obj1 = 0 ;
21844 PyObject * obj2 = 0 ;
21845 char * kwnames[] = {
21846 (char *) "self",(char *) "key",(char *) "value", NULL
21847 };
21848
21849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21851 if (!SWIG_IsOK(res1)) {
21852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21853 }
21854 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21855 {
21856 arg2 = wxString_in_helper(obj1);
21857 if (arg2 == NULL) SWIG_fail;
21858 temp2 = true;
21859 }
21860 ecode3 = SWIG_AsVal_long(obj2, &val3);
21861 if (!SWIG_IsOK(ecode3)) {
21862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21863 }
21864 arg3 = static_cast< long >(val3);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 {
21872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21873 }
21874 {
21875 if (temp2)
21876 delete arg2;
21877 }
21878 return resultobj;
21879 fail:
21880 {
21881 if (temp2)
21882 delete arg2;
21883 }
21884 return NULL;
21885 }
21886
21887
21888 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21889 PyObject *resultobj = 0;
21890 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21891 wxString *arg2 = 0 ;
21892 double arg3 ;
21893 bool result;
21894 void *argp1 = 0 ;
21895 int res1 = 0 ;
21896 bool temp2 = false ;
21897 double val3 ;
21898 int ecode3 = 0 ;
21899 PyObject * obj0 = 0 ;
21900 PyObject * obj1 = 0 ;
21901 PyObject * obj2 = 0 ;
21902 char * kwnames[] = {
21903 (char *) "self",(char *) "key",(char *) "value", NULL
21904 };
21905
21906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21908 if (!SWIG_IsOK(res1)) {
21909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21910 }
21911 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21912 {
21913 arg2 = wxString_in_helper(obj1);
21914 if (arg2 == NULL) SWIG_fail;
21915 temp2 = true;
21916 }
21917 ecode3 = SWIG_AsVal_double(obj2, &val3);
21918 if (!SWIG_IsOK(ecode3)) {
21919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21920 }
21921 arg3 = static_cast< double >(val3);
21922 {
21923 PyThreadState* __tstate = wxPyBeginAllowThreads();
21924 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21925 wxPyEndAllowThreads(__tstate);
21926 if (PyErr_Occurred()) SWIG_fail;
21927 }
21928 {
21929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21930 }
21931 {
21932 if (temp2)
21933 delete arg2;
21934 }
21935 return resultobj;
21936 fail:
21937 {
21938 if (temp2)
21939 delete arg2;
21940 }
21941 return NULL;
21942 }
21943
21944
21945 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21946 PyObject *resultobj = 0;
21947 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21948 wxString *arg2 = 0 ;
21949 bool arg3 ;
21950 bool result;
21951 void *argp1 = 0 ;
21952 int res1 = 0 ;
21953 bool temp2 = false ;
21954 bool val3 ;
21955 int ecode3 = 0 ;
21956 PyObject * obj0 = 0 ;
21957 PyObject * obj1 = 0 ;
21958 PyObject * obj2 = 0 ;
21959 char * kwnames[] = {
21960 (char *) "self",(char *) "key",(char *) "value", NULL
21961 };
21962
21963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21965 if (!SWIG_IsOK(res1)) {
21966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21967 }
21968 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21969 {
21970 arg2 = wxString_in_helper(obj1);
21971 if (arg2 == NULL) SWIG_fail;
21972 temp2 = true;
21973 }
21974 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21975 if (!SWIG_IsOK(ecode3)) {
21976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21977 }
21978 arg3 = static_cast< bool >(val3);
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 {
21986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21987 }
21988 {
21989 if (temp2)
21990 delete arg2;
21991 }
21992 return resultobj;
21993 fail:
21994 {
21995 if (temp2)
21996 delete arg2;
21997 }
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22003 PyObject *resultobj = 0;
22004 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22005 bool arg2 = (bool) false ;
22006 bool result;
22007 void *argp1 = 0 ;
22008 int res1 = 0 ;
22009 bool val2 ;
22010 int ecode2 = 0 ;
22011 PyObject * obj0 = 0 ;
22012 PyObject * obj1 = 0 ;
22013 char * kwnames[] = {
22014 (char *) "self",(char *) "currentOnly", NULL
22015 };
22016
22017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
22018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22019 if (!SWIG_IsOK(res1)) {
22020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22021 }
22022 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22023 if (obj1) {
22024 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22025 if (!SWIG_IsOK(ecode2)) {
22026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
22027 }
22028 arg2 = static_cast< bool >(val2);
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (bool)(arg1)->Flush(arg2);
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 {
22037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22038 }
22039 return resultobj;
22040 fail:
22041 return NULL;
22042 }
22043
22044
22045 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22046 PyObject *resultobj = 0;
22047 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22048 wxString *arg2 = 0 ;
22049 wxString *arg3 = 0 ;
22050 bool result;
22051 void *argp1 = 0 ;
22052 int res1 = 0 ;
22053 bool temp2 = false ;
22054 bool temp3 = false ;
22055 PyObject * obj0 = 0 ;
22056 PyObject * obj1 = 0 ;
22057 PyObject * obj2 = 0 ;
22058 char * kwnames[] = {
22059 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22060 };
22061
22062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22064 if (!SWIG_IsOK(res1)) {
22065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22066 }
22067 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22068 {
22069 arg2 = wxString_in_helper(obj1);
22070 if (arg2 == NULL) SWIG_fail;
22071 temp2 = true;
22072 }
22073 {
22074 arg3 = wxString_in_helper(obj2);
22075 if (arg3 == NULL) SWIG_fail;
22076 temp3 = true;
22077 }
22078 {
22079 PyThreadState* __tstate = wxPyBeginAllowThreads();
22080 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22081 wxPyEndAllowThreads(__tstate);
22082 if (PyErr_Occurred()) SWIG_fail;
22083 }
22084 {
22085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22086 }
22087 {
22088 if (temp2)
22089 delete arg2;
22090 }
22091 {
22092 if (temp3)
22093 delete arg3;
22094 }
22095 return resultobj;
22096 fail:
22097 {
22098 if (temp2)
22099 delete arg2;
22100 }
22101 {
22102 if (temp3)
22103 delete arg3;
22104 }
22105 return NULL;
22106 }
22107
22108
22109 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22110 PyObject *resultobj = 0;
22111 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22112 wxString *arg2 = 0 ;
22113 wxString *arg3 = 0 ;
22114 bool result;
22115 void *argp1 = 0 ;
22116 int res1 = 0 ;
22117 bool temp2 = false ;
22118 bool temp3 = false ;
22119 PyObject * obj0 = 0 ;
22120 PyObject * obj1 = 0 ;
22121 PyObject * obj2 = 0 ;
22122 char * kwnames[] = {
22123 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22124 };
22125
22126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22130 }
22131 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22132 {
22133 arg2 = wxString_in_helper(obj1);
22134 if (arg2 == NULL) SWIG_fail;
22135 temp2 = true;
22136 }
22137 {
22138 arg3 = wxString_in_helper(obj2);
22139 if (arg3 == NULL) SWIG_fail;
22140 temp3 = true;
22141 }
22142 {
22143 PyThreadState* __tstate = wxPyBeginAllowThreads();
22144 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 {
22149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22150 }
22151 {
22152 if (temp2)
22153 delete arg2;
22154 }
22155 {
22156 if (temp3)
22157 delete arg3;
22158 }
22159 return resultobj;
22160 fail:
22161 {
22162 if (temp2)
22163 delete arg2;
22164 }
22165 {
22166 if (temp3)
22167 delete arg3;
22168 }
22169 return NULL;
22170 }
22171
22172
22173 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22174 PyObject *resultobj = 0;
22175 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22176 wxString *arg2 = 0 ;
22177 bool arg3 = (bool) true ;
22178 bool result;
22179 void *argp1 = 0 ;
22180 int res1 = 0 ;
22181 bool temp2 = false ;
22182 bool val3 ;
22183 int ecode3 = 0 ;
22184 PyObject * obj0 = 0 ;
22185 PyObject * obj1 = 0 ;
22186 PyObject * obj2 = 0 ;
22187 char * kwnames[] = {
22188 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22189 };
22190
22191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22193 if (!SWIG_IsOK(res1)) {
22194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22195 }
22196 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22197 {
22198 arg2 = wxString_in_helper(obj1);
22199 if (arg2 == NULL) SWIG_fail;
22200 temp2 = true;
22201 }
22202 if (obj2) {
22203 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22204 if (!SWIG_IsOK(ecode3)) {
22205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22206 }
22207 arg3 = static_cast< bool >(val3);
22208 }
22209 {
22210 PyThreadState* __tstate = wxPyBeginAllowThreads();
22211 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 {
22216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22217 }
22218 {
22219 if (temp2)
22220 delete arg2;
22221 }
22222 return resultobj;
22223 fail:
22224 {
22225 if (temp2)
22226 delete arg2;
22227 }
22228 return NULL;
22229 }
22230
22231
22232 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22233 PyObject *resultobj = 0;
22234 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22235 wxString *arg2 = 0 ;
22236 bool result;
22237 void *argp1 = 0 ;
22238 int res1 = 0 ;
22239 bool temp2 = false ;
22240 PyObject * obj0 = 0 ;
22241 PyObject * obj1 = 0 ;
22242 char * kwnames[] = {
22243 (char *) "self",(char *) "key", NULL
22244 };
22245
22246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22248 if (!SWIG_IsOK(res1)) {
22249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22250 }
22251 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22252 {
22253 arg2 = wxString_in_helper(obj1);
22254 if (arg2 == NULL) SWIG_fail;
22255 temp2 = true;
22256 }
22257 {
22258 PyThreadState* __tstate = wxPyBeginAllowThreads();
22259 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 {
22264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22265 }
22266 {
22267 if (temp2)
22268 delete arg2;
22269 }
22270 return resultobj;
22271 fail:
22272 {
22273 if (temp2)
22274 delete arg2;
22275 }
22276 return NULL;
22277 }
22278
22279
22280 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22281 PyObject *resultobj = 0;
22282 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22283 bool result;
22284 void *argp1 = 0 ;
22285 int res1 = 0 ;
22286 PyObject *swig_obj[1] ;
22287
22288 if (!args) SWIG_fail;
22289 swig_obj[0] = args;
22290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22291 if (!SWIG_IsOK(res1)) {
22292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22293 }
22294 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22295 {
22296 PyThreadState* __tstate = wxPyBeginAllowThreads();
22297 result = (bool)(arg1)->DeleteAll();
22298 wxPyEndAllowThreads(__tstate);
22299 if (PyErr_Occurred()) SWIG_fail;
22300 }
22301 {
22302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22303 }
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22311 PyObject *resultobj = 0;
22312 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22313 bool arg2 = (bool) true ;
22314 void *argp1 = 0 ;
22315 int res1 = 0 ;
22316 bool val2 ;
22317 int ecode2 = 0 ;
22318 PyObject * obj0 = 0 ;
22319 PyObject * obj1 = 0 ;
22320 char * kwnames[] = {
22321 (char *) "self",(char *) "doIt", NULL
22322 };
22323
22324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22326 if (!SWIG_IsOK(res1)) {
22327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22328 }
22329 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22330 if (obj1) {
22331 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22332 if (!SWIG_IsOK(ecode2)) {
22333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22334 }
22335 arg2 = static_cast< bool >(val2);
22336 }
22337 {
22338 PyThreadState* __tstate = wxPyBeginAllowThreads();
22339 (arg1)->SetExpandEnvVars(arg2);
22340 wxPyEndAllowThreads(__tstate);
22341 if (PyErr_Occurred()) SWIG_fail;
22342 }
22343 resultobj = SWIG_Py_Void();
22344 return resultobj;
22345 fail:
22346 return NULL;
22347 }
22348
22349
22350 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22351 PyObject *resultobj = 0;
22352 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22353 bool result;
22354 void *argp1 = 0 ;
22355 int res1 = 0 ;
22356 PyObject *swig_obj[1] ;
22357
22358 if (!args) SWIG_fail;
22359 swig_obj[0] = args;
22360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22361 if (!SWIG_IsOK(res1)) {
22362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22363 }
22364 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22368 wxPyEndAllowThreads(__tstate);
22369 if (PyErr_Occurred()) SWIG_fail;
22370 }
22371 {
22372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22373 }
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22381 PyObject *resultobj = 0;
22382 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22383 bool arg2 = (bool) true ;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 bool val2 ;
22387 int ecode2 = 0 ;
22388 PyObject * obj0 = 0 ;
22389 PyObject * obj1 = 0 ;
22390 char * kwnames[] = {
22391 (char *) "self",(char *) "doIt", NULL
22392 };
22393
22394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22396 if (!SWIG_IsOK(res1)) {
22397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22398 }
22399 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22400 if (obj1) {
22401 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22402 if (!SWIG_IsOK(ecode2)) {
22403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22404 }
22405 arg2 = static_cast< bool >(val2);
22406 }
22407 {
22408 PyThreadState* __tstate = wxPyBeginAllowThreads();
22409 (arg1)->SetRecordDefaults(arg2);
22410 wxPyEndAllowThreads(__tstate);
22411 if (PyErr_Occurred()) SWIG_fail;
22412 }
22413 resultobj = SWIG_Py_Void();
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22421 PyObject *resultobj = 0;
22422 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22423 bool result;
22424 void *argp1 = 0 ;
22425 int res1 = 0 ;
22426 PyObject *swig_obj[1] ;
22427
22428 if (!args) SWIG_fail;
22429 swig_obj[0] = args;
22430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22431 if (!SWIG_IsOK(res1)) {
22432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22433 }
22434 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22438 wxPyEndAllowThreads(__tstate);
22439 if (PyErr_Occurred()) SWIG_fail;
22440 }
22441 {
22442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22443 }
22444 return resultobj;
22445 fail:
22446 return NULL;
22447 }
22448
22449
22450 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22451 PyObject *resultobj = 0;
22452 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22453 wxString *arg2 = 0 ;
22454 wxString result;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 bool temp2 = false ;
22458 PyObject * obj0 = 0 ;
22459 PyObject * obj1 = 0 ;
22460 char * kwnames[] = {
22461 (char *) "self",(char *) "str", NULL
22462 };
22463
22464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22466 if (!SWIG_IsOK(res1)) {
22467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22468 }
22469 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22470 {
22471 arg2 = wxString_in_helper(obj1);
22472 if (arg2 == NULL) SWIG_fail;
22473 temp2 = true;
22474 }
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 {
22482 #if wxUSE_UNICODE
22483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22484 #else
22485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22486 #endif
22487 }
22488 {
22489 if (temp2)
22490 delete arg2;
22491 }
22492 return resultobj;
22493 fail:
22494 {
22495 if (temp2)
22496 delete arg2;
22497 }
22498 return NULL;
22499 }
22500
22501
22502 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22503 PyObject *resultobj = 0;
22504 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22505 wxString result;
22506 void *argp1 = 0 ;
22507 int res1 = 0 ;
22508 PyObject *swig_obj[1] ;
22509
22510 if (!args) SWIG_fail;
22511 swig_obj[0] = args;
22512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22513 if (!SWIG_IsOK(res1)) {
22514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22515 }
22516 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22517 {
22518 PyThreadState* __tstate = wxPyBeginAllowThreads();
22519 result = ((wxConfigBase const *)arg1)->GetAppName();
22520 wxPyEndAllowThreads(__tstate);
22521 if (PyErr_Occurred()) SWIG_fail;
22522 }
22523 {
22524 #if wxUSE_UNICODE
22525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22526 #else
22527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22528 #endif
22529 }
22530 return resultobj;
22531 fail:
22532 return NULL;
22533 }
22534
22535
22536 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22537 PyObject *resultobj = 0;
22538 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22539 wxString result;
22540 void *argp1 = 0 ;
22541 int res1 = 0 ;
22542 PyObject *swig_obj[1] ;
22543
22544 if (!args) SWIG_fail;
22545 swig_obj[0] = args;
22546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22547 if (!SWIG_IsOK(res1)) {
22548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22549 }
22550 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22551 {
22552 PyThreadState* __tstate = wxPyBeginAllowThreads();
22553 result = ((wxConfigBase const *)arg1)->GetVendorName();
22554 wxPyEndAllowThreads(__tstate);
22555 if (PyErr_Occurred()) SWIG_fail;
22556 }
22557 {
22558 #if wxUSE_UNICODE
22559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22560 #else
22561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22562 #endif
22563 }
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22571 PyObject *resultobj = 0;
22572 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22573 wxString *arg2 = 0 ;
22574 void *argp1 = 0 ;
22575 int res1 = 0 ;
22576 bool temp2 = false ;
22577 PyObject * obj0 = 0 ;
22578 PyObject * obj1 = 0 ;
22579 char * kwnames[] = {
22580 (char *) "self",(char *) "appName", NULL
22581 };
22582
22583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22585 if (!SWIG_IsOK(res1)) {
22586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22587 }
22588 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22589 {
22590 arg2 = wxString_in_helper(obj1);
22591 if (arg2 == NULL) SWIG_fail;
22592 temp2 = true;
22593 }
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 (arg1)->SetAppName((wxString const &)*arg2);
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 resultobj = SWIG_Py_Void();
22601 {
22602 if (temp2)
22603 delete arg2;
22604 }
22605 return resultobj;
22606 fail:
22607 {
22608 if (temp2)
22609 delete arg2;
22610 }
22611 return NULL;
22612 }
22613
22614
22615 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22616 PyObject *resultobj = 0;
22617 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22618 wxString *arg2 = 0 ;
22619 void *argp1 = 0 ;
22620 int res1 = 0 ;
22621 bool temp2 = false ;
22622 PyObject * obj0 = 0 ;
22623 PyObject * obj1 = 0 ;
22624 char * kwnames[] = {
22625 (char *) "self",(char *) "vendorName", NULL
22626 };
22627
22628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22630 if (!SWIG_IsOK(res1)) {
22631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22632 }
22633 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22634 {
22635 arg2 = wxString_in_helper(obj1);
22636 if (arg2 == NULL) SWIG_fail;
22637 temp2 = true;
22638 }
22639 {
22640 PyThreadState* __tstate = wxPyBeginAllowThreads();
22641 (arg1)->SetVendorName((wxString const &)*arg2);
22642 wxPyEndAllowThreads(__tstate);
22643 if (PyErr_Occurred()) SWIG_fail;
22644 }
22645 resultobj = SWIG_Py_Void();
22646 {
22647 if (temp2)
22648 delete arg2;
22649 }
22650 return resultobj;
22651 fail:
22652 {
22653 if (temp2)
22654 delete arg2;
22655 }
22656 return NULL;
22657 }
22658
22659
22660 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22661 PyObject *resultobj = 0;
22662 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22663 long arg2 ;
22664 void *argp1 = 0 ;
22665 int res1 = 0 ;
22666 long val2 ;
22667 int ecode2 = 0 ;
22668 PyObject * obj0 = 0 ;
22669 PyObject * obj1 = 0 ;
22670 char * kwnames[] = {
22671 (char *) "self",(char *) "style", NULL
22672 };
22673
22674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22676 if (!SWIG_IsOK(res1)) {
22677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22678 }
22679 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22680 ecode2 = SWIG_AsVal_long(obj1, &val2);
22681 if (!SWIG_IsOK(ecode2)) {
22682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22683 }
22684 arg2 = static_cast< long >(val2);
22685 {
22686 PyThreadState* __tstate = wxPyBeginAllowThreads();
22687 (arg1)->SetStyle(arg2);
22688 wxPyEndAllowThreads(__tstate);
22689 if (PyErr_Occurred()) SWIG_fail;
22690 }
22691 resultobj = SWIG_Py_Void();
22692 return resultobj;
22693 fail:
22694 return NULL;
22695 }
22696
22697
22698 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22699 PyObject *resultobj = 0;
22700 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22701 long result;
22702 void *argp1 = 0 ;
22703 int res1 = 0 ;
22704 PyObject *swig_obj[1] ;
22705
22706 if (!args) SWIG_fail;
22707 swig_obj[0] = args;
22708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22709 if (!SWIG_IsOK(res1)) {
22710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22711 }
22712 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22713 {
22714 PyThreadState* __tstate = wxPyBeginAllowThreads();
22715 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22716 wxPyEndAllowThreads(__tstate);
22717 if (PyErr_Occurred()) SWIG_fail;
22718 }
22719 resultobj = SWIG_From_long(static_cast< long >(result));
22720 return resultobj;
22721 fail:
22722 return NULL;
22723 }
22724
22725
22726 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22727 PyObject *obj;
22728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22729 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22730 return SWIG_Py_Void();
22731 }
22732
22733 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22734 PyObject *resultobj = 0;
22735 wxString const &arg1_defvalue = wxPyEmptyString ;
22736 wxString *arg1 = (wxString *) &arg1_defvalue ;
22737 wxString const &arg2_defvalue = wxPyEmptyString ;
22738 wxString *arg2 = (wxString *) &arg2_defvalue ;
22739 wxString const &arg3_defvalue = wxPyEmptyString ;
22740 wxString *arg3 = (wxString *) &arg3_defvalue ;
22741 wxString const &arg4_defvalue = wxPyEmptyString ;
22742 wxString *arg4 = (wxString *) &arg4_defvalue ;
22743 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22744 wxConfig *result = 0 ;
22745 bool temp1 = false ;
22746 bool temp2 = false ;
22747 bool temp3 = false ;
22748 bool temp4 = false ;
22749 long val5 ;
22750 int ecode5 = 0 ;
22751 PyObject * obj0 = 0 ;
22752 PyObject * obj1 = 0 ;
22753 PyObject * obj2 = 0 ;
22754 PyObject * obj3 = 0 ;
22755 PyObject * obj4 = 0 ;
22756 char * kwnames[] = {
22757 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22758 };
22759
22760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22761 if (obj0) {
22762 {
22763 arg1 = wxString_in_helper(obj0);
22764 if (arg1 == NULL) SWIG_fail;
22765 temp1 = true;
22766 }
22767 }
22768 if (obj1) {
22769 {
22770 arg2 = wxString_in_helper(obj1);
22771 if (arg2 == NULL) SWIG_fail;
22772 temp2 = true;
22773 }
22774 }
22775 if (obj2) {
22776 {
22777 arg3 = wxString_in_helper(obj2);
22778 if (arg3 == NULL) SWIG_fail;
22779 temp3 = true;
22780 }
22781 }
22782 if (obj3) {
22783 {
22784 arg4 = wxString_in_helper(obj3);
22785 if (arg4 == NULL) SWIG_fail;
22786 temp4 = true;
22787 }
22788 }
22789 if (obj4) {
22790 ecode5 = SWIG_AsVal_long(obj4, &val5);
22791 if (!SWIG_IsOK(ecode5)) {
22792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22793 }
22794 arg5 = static_cast< long >(val5);
22795 }
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22803 {
22804 if (temp1)
22805 delete arg1;
22806 }
22807 {
22808 if (temp2)
22809 delete arg2;
22810 }
22811 {
22812 if (temp3)
22813 delete arg3;
22814 }
22815 {
22816 if (temp4)
22817 delete arg4;
22818 }
22819 return resultobj;
22820 fail:
22821 {
22822 if (temp1)
22823 delete arg1;
22824 }
22825 {
22826 if (temp2)
22827 delete arg2;
22828 }
22829 {
22830 if (temp3)
22831 delete arg3;
22832 }
22833 {
22834 if (temp4)
22835 delete arg4;
22836 }
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22842 PyObject *resultobj = 0;
22843 wxConfig *arg1 = (wxConfig *) 0 ;
22844 void *argp1 = 0 ;
22845 int res1 = 0 ;
22846 PyObject *swig_obj[1] ;
22847
22848 if (!args) SWIG_fail;
22849 swig_obj[0] = args;
22850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22851 if (!SWIG_IsOK(res1)) {
22852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22853 }
22854 arg1 = reinterpret_cast< wxConfig * >(argp1);
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 delete arg1;
22858
22859 wxPyEndAllowThreads(__tstate);
22860 if (PyErr_Occurred()) SWIG_fail;
22861 }
22862 resultobj = SWIG_Py_Void();
22863 return resultobj;
22864 fail:
22865 return NULL;
22866 }
22867
22868
22869 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22870 PyObject *obj;
22871 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22872 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22873 return SWIG_Py_Void();
22874 }
22875
22876 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22877 return SWIG_Python_InitShadowInstance(args);
22878 }
22879
22880 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22881 PyObject *resultobj = 0;
22882 wxString const &arg1_defvalue = wxPyEmptyString ;
22883 wxString *arg1 = (wxString *) &arg1_defvalue ;
22884 wxString const &arg2_defvalue = wxPyEmptyString ;
22885 wxString *arg2 = (wxString *) &arg2_defvalue ;
22886 wxString const &arg3_defvalue = wxPyEmptyString ;
22887 wxString *arg3 = (wxString *) &arg3_defvalue ;
22888 wxString const &arg4_defvalue = wxPyEmptyString ;
22889 wxString *arg4 = (wxString *) &arg4_defvalue ;
22890 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22891 wxFileConfig *result = 0 ;
22892 bool temp1 = false ;
22893 bool temp2 = false ;
22894 bool temp3 = false ;
22895 bool temp4 = false ;
22896 long val5 ;
22897 int ecode5 = 0 ;
22898 PyObject * obj0 = 0 ;
22899 PyObject * obj1 = 0 ;
22900 PyObject * obj2 = 0 ;
22901 PyObject * obj3 = 0 ;
22902 PyObject * obj4 = 0 ;
22903 char * kwnames[] = {
22904 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22905 };
22906
22907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22908 if (obj0) {
22909 {
22910 arg1 = wxString_in_helper(obj0);
22911 if (arg1 == NULL) SWIG_fail;
22912 temp1 = true;
22913 }
22914 }
22915 if (obj1) {
22916 {
22917 arg2 = wxString_in_helper(obj1);
22918 if (arg2 == NULL) SWIG_fail;
22919 temp2 = true;
22920 }
22921 }
22922 if (obj2) {
22923 {
22924 arg3 = wxString_in_helper(obj2);
22925 if (arg3 == NULL) SWIG_fail;
22926 temp3 = true;
22927 }
22928 }
22929 if (obj3) {
22930 {
22931 arg4 = wxString_in_helper(obj3);
22932 if (arg4 == NULL) SWIG_fail;
22933 temp4 = true;
22934 }
22935 }
22936 if (obj4) {
22937 ecode5 = SWIG_AsVal_long(obj4, &val5);
22938 if (!SWIG_IsOK(ecode5)) {
22939 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22940 }
22941 arg5 = static_cast< long >(val5);
22942 }
22943 {
22944 PyThreadState* __tstate = wxPyBeginAllowThreads();
22945 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22946 wxPyEndAllowThreads(__tstate);
22947 if (PyErr_Occurred()) SWIG_fail;
22948 }
22949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22950 {
22951 if (temp1)
22952 delete arg1;
22953 }
22954 {
22955 if (temp2)
22956 delete arg2;
22957 }
22958 {
22959 if (temp3)
22960 delete arg3;
22961 }
22962 {
22963 if (temp4)
22964 delete arg4;
22965 }
22966 return resultobj;
22967 fail:
22968 {
22969 if (temp1)
22970 delete arg1;
22971 }
22972 {
22973 if (temp2)
22974 delete arg2;
22975 }
22976 {
22977 if (temp3)
22978 delete arg3;
22979 }
22980 {
22981 if (temp4)
22982 delete arg4;
22983 }
22984 return NULL;
22985 }
22986
22987
22988 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22989 PyObject *resultobj = 0;
22990 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22991 void *argp1 = 0 ;
22992 int res1 = 0 ;
22993 PyObject *swig_obj[1] ;
22994
22995 if (!args) SWIG_fail;
22996 swig_obj[0] = args;
22997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22998 if (!SWIG_IsOK(res1)) {
22999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
23000 }
23001 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
23002 {
23003 PyThreadState* __tstate = wxPyBeginAllowThreads();
23004 delete arg1;
23005
23006 wxPyEndAllowThreads(__tstate);
23007 if (PyErr_Occurred()) SWIG_fail;
23008 }
23009 resultobj = SWIG_Py_Void();
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_FileConfig_GetGlobalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23017 PyObject *resultobj = 0;
23018 wxString *arg1 = 0 ;
23019 wxString result;
23020 bool temp1 = false ;
23021 PyObject * obj0 = 0 ;
23022 char * kwnames[] = {
23023 (char *) "szFile", NULL
23024 };
23025
23026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileConfig_GetGlobalFileName",kwnames,&obj0)) SWIG_fail;
23027 {
23028 arg1 = wxString_in_helper(obj0);
23029 if (arg1 == NULL) SWIG_fail;
23030 temp1 = true;
23031 }
23032 {
23033 PyThreadState* __tstate = wxPyBeginAllowThreads();
23034 result = wxFileConfig::GetGlobalFileName((wxString const &)*arg1);
23035 wxPyEndAllowThreads(__tstate);
23036 if (PyErr_Occurred()) SWIG_fail;
23037 }
23038 {
23039 #if wxUSE_UNICODE
23040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23041 #else
23042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23043 #endif
23044 }
23045 {
23046 if (temp1)
23047 delete arg1;
23048 }
23049 return resultobj;
23050 fail:
23051 {
23052 if (temp1)
23053 delete arg1;
23054 }
23055 return NULL;
23056 }
23057
23058
23059 SWIGINTERN PyObject *_wrap_FileConfig_GetLocalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23060 PyObject *resultobj = 0;
23061 wxString *arg1 = 0 ;
23062 int arg2 = (int) 0 ;
23063 wxString result;
23064 bool temp1 = false ;
23065 int val2 ;
23066 int ecode2 = 0 ;
23067 PyObject * obj0 = 0 ;
23068 PyObject * obj1 = 0 ;
23069 char * kwnames[] = {
23070 (char *) "szFile",(char *) "style", NULL
23071 };
23072
23073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FileConfig_GetLocalFileName",kwnames,&obj0,&obj1)) SWIG_fail;
23074 {
23075 arg1 = wxString_in_helper(obj0);
23076 if (arg1 == NULL) SWIG_fail;
23077 temp1 = true;
23078 }
23079 if (obj1) {
23080 ecode2 = SWIG_AsVal_int(obj1, &val2);
23081 if (!SWIG_IsOK(ecode2)) {
23082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileConfig_GetLocalFileName" "', expected argument " "2"" of type '" "int""'");
23083 }
23084 arg2 = static_cast< int >(val2);
23085 }
23086 {
23087 PyThreadState* __tstate = wxPyBeginAllowThreads();
23088 result = wxFileConfig::GetLocalFileName((wxString const &)*arg1,arg2);
23089 wxPyEndAllowThreads(__tstate);
23090 if (PyErr_Occurred()) SWIG_fail;
23091 }
23092 {
23093 #if wxUSE_UNICODE
23094 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23095 #else
23096 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23097 #endif
23098 }
23099 {
23100 if (temp1)
23101 delete arg1;
23102 }
23103 return resultobj;
23104 fail:
23105 {
23106 if (temp1)
23107 delete arg1;
23108 }
23109 return NULL;
23110 }
23111
23112
23113 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23114 PyObject *obj;
23115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23116 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
23117 return SWIG_Py_Void();
23118 }
23119
23120 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23121 return SWIG_Python_InitShadowInstance(args);
23122 }
23123
23124 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23125 PyObject *resultobj = 0;
23126 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
23127 wxString *arg2 = 0 ;
23128 wxConfigPathChanger *result = 0 ;
23129 void *argp1 = 0 ;
23130 int res1 = 0 ;
23131 bool temp2 = false ;
23132 PyObject * obj0 = 0 ;
23133 PyObject * obj1 = 0 ;
23134 char * kwnames[] = {
23135 (char *) "config",(char *) "entry", NULL
23136 };
23137
23138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
23139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
23140 if (!SWIG_IsOK(res1)) {
23141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
23142 }
23143 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23144 {
23145 arg2 = wxString_in_helper(obj1);
23146 if (arg2 == NULL) SWIG_fail;
23147 temp2 = true;
23148 }
23149 {
23150 PyThreadState* __tstate = wxPyBeginAllowThreads();
23151 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23156 {
23157 if (temp2)
23158 delete arg2;
23159 }
23160 return resultobj;
23161 fail:
23162 {
23163 if (temp2)
23164 delete arg2;
23165 }
23166 return NULL;
23167 }
23168
23169
23170 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23171 PyObject *resultobj = 0;
23172 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23173 void *argp1 = 0 ;
23174 int res1 = 0 ;
23175 PyObject *swig_obj[1] ;
23176
23177 if (!args) SWIG_fail;
23178 swig_obj[0] = args;
23179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23180 if (!SWIG_IsOK(res1)) {
23181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23182 }
23183 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23184 {
23185 PyThreadState* __tstate = wxPyBeginAllowThreads();
23186 delete arg1;
23187
23188 wxPyEndAllowThreads(__tstate);
23189 if (PyErr_Occurred()) SWIG_fail;
23190 }
23191 resultobj = SWIG_Py_Void();
23192 return resultobj;
23193 fail:
23194 return NULL;
23195 }
23196
23197
23198 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23199 PyObject *resultobj = 0;
23200 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23201 wxString *result = 0 ;
23202 void *argp1 = 0 ;
23203 int res1 = 0 ;
23204 PyObject *swig_obj[1] ;
23205
23206 if (!args) SWIG_fail;
23207 swig_obj[0] = args;
23208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23209 if (!SWIG_IsOK(res1)) {
23210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23211 }
23212 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23213 {
23214 PyThreadState* __tstate = wxPyBeginAllowThreads();
23215 {
23216 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23217 result = (wxString *) &_result_ref;
23218 }
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 {
23223 #if wxUSE_UNICODE
23224 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23225 #else
23226 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23227 #endif
23228 }
23229 return resultobj;
23230 fail:
23231 return NULL;
23232 }
23233
23234
23235 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23236 PyObject *obj;
23237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23238 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23239 return SWIG_Py_Void();
23240 }
23241
23242 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23243 return SWIG_Python_InitShadowInstance(args);
23244 }
23245
23246 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23247 PyObject *resultobj = 0;
23248 wxString *arg1 = 0 ;
23249 wxString result;
23250 bool temp1 = false ;
23251 PyObject * obj0 = 0 ;
23252 char * kwnames[] = {
23253 (char *) "sz", NULL
23254 };
23255
23256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23257 {
23258 arg1 = wxString_in_helper(obj0);
23259 if (arg1 == NULL) SWIG_fail;
23260 temp1 = true;
23261 }
23262 {
23263 PyThreadState* __tstate = wxPyBeginAllowThreads();
23264 result = wxExpandEnvVars((wxString const &)*arg1);
23265 wxPyEndAllowThreads(__tstate);
23266 if (PyErr_Occurred()) SWIG_fail;
23267 }
23268 {
23269 #if wxUSE_UNICODE
23270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23271 #else
23272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23273 #endif
23274 }
23275 {
23276 if (temp1)
23277 delete arg1;
23278 }
23279 return resultobj;
23280 fail:
23281 {
23282 if (temp1)
23283 delete arg1;
23284 }
23285 return NULL;
23286 }
23287
23288
23289 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23290 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23291 return 1;
23292 }
23293
23294
23295 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23296 PyObject *pyobj = 0;
23297
23298 {
23299 #if wxUSE_UNICODE
23300 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23301 #else
23302 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23303 #endif
23304 }
23305 return pyobj;
23306 }
23307
23308
23309 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23310 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23311 return 1;
23312 }
23313
23314
23315 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23316 PyObject *pyobj = 0;
23317
23318 {
23319 #if wxUSE_UNICODE
23320 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23321 #else
23322 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23323 #endif
23324 }
23325 return pyobj;
23326 }
23327
23328
23329 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23330 PyObject *resultobj = 0;
23331 wxDateTime::Country arg1 ;
23332 int val1 ;
23333 int ecode1 = 0 ;
23334 PyObject * obj0 = 0 ;
23335 char * kwnames[] = {
23336 (char *) "country", NULL
23337 };
23338
23339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23340 ecode1 = SWIG_AsVal_int(obj0, &val1);
23341 if (!SWIG_IsOK(ecode1)) {
23342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23343 }
23344 arg1 = static_cast< wxDateTime::Country >(val1);
23345 {
23346 PyThreadState* __tstate = wxPyBeginAllowThreads();
23347 wxDateTime::SetCountry(arg1);
23348 wxPyEndAllowThreads(__tstate);
23349 if (PyErr_Occurred()) SWIG_fail;
23350 }
23351 resultobj = SWIG_Py_Void();
23352 return resultobj;
23353 fail:
23354 return NULL;
23355 }
23356
23357
23358 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23359 PyObject *resultobj = 0;
23360 wxDateTime::Country result;
23361
23362 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23363 {
23364 PyThreadState* __tstate = wxPyBeginAllowThreads();
23365 result = (wxDateTime::Country)wxDateTime::GetCountry();
23366 wxPyEndAllowThreads(__tstate);
23367 if (PyErr_Occurred()) SWIG_fail;
23368 }
23369 resultobj = SWIG_From_int(static_cast< int >(result));
23370 return resultobj;
23371 fail:
23372 return NULL;
23373 }
23374
23375
23376 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23377 PyObject *resultobj = 0;
23378 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23379 bool result;
23380 int val1 ;
23381 int ecode1 = 0 ;
23382 PyObject * obj0 = 0 ;
23383 char * kwnames[] = {
23384 (char *) "country", NULL
23385 };
23386
23387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23388 if (obj0) {
23389 ecode1 = SWIG_AsVal_int(obj0, &val1);
23390 if (!SWIG_IsOK(ecode1)) {
23391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23392 }
23393 arg1 = static_cast< wxDateTime::Country >(val1);
23394 }
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 {
23402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23403 }
23404 return resultobj;
23405 fail:
23406 return NULL;
23407 }
23408
23409
23410 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23411 PyObject *resultobj = 0;
23412 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23413 int result;
23414 int val1 ;
23415 int ecode1 = 0 ;
23416 PyObject * obj0 = 0 ;
23417 char * kwnames[] = {
23418 (char *) "cal", NULL
23419 };
23420
23421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23422 if (obj0) {
23423 ecode1 = SWIG_AsVal_int(obj0, &val1);
23424 if (!SWIG_IsOK(ecode1)) {
23425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23426 }
23427 arg1 = static_cast< wxDateTime::Calendar >(val1);
23428 }
23429 {
23430 PyThreadState* __tstate = wxPyBeginAllowThreads();
23431 result = (int)wxDateTime::GetCurrentYear(arg1);
23432 wxPyEndAllowThreads(__tstate);
23433 if (PyErr_Occurred()) SWIG_fail;
23434 }
23435 resultobj = SWIG_From_int(static_cast< int >(result));
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj = 0;
23444 int arg1 ;
23445 int result;
23446 int val1 ;
23447 int ecode1 = 0 ;
23448 PyObject * obj0 = 0 ;
23449 char * kwnames[] = {
23450 (char *) "year", NULL
23451 };
23452
23453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23454 ecode1 = SWIG_AsVal_int(obj0, &val1);
23455 if (!SWIG_IsOK(ecode1)) {
23456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23457 }
23458 arg1 = static_cast< int >(val1);
23459 {
23460 PyThreadState* __tstate = wxPyBeginAllowThreads();
23461 result = (int)wxDateTime::ConvertYearToBC(arg1);
23462 wxPyEndAllowThreads(__tstate);
23463 if (PyErr_Occurred()) SWIG_fail;
23464 }
23465 resultobj = SWIG_From_int(static_cast< int >(result));
23466 return resultobj;
23467 fail:
23468 return NULL;
23469 }
23470
23471
23472 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23473 PyObject *resultobj = 0;
23474 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23475 wxDateTime::Month result;
23476 int val1 ;
23477 int ecode1 = 0 ;
23478 PyObject * obj0 = 0 ;
23479 char * kwnames[] = {
23480 (char *) "cal", NULL
23481 };
23482
23483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23484 if (obj0) {
23485 ecode1 = SWIG_AsVal_int(obj0, &val1);
23486 if (!SWIG_IsOK(ecode1)) {
23487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23488 }
23489 arg1 = static_cast< wxDateTime::Calendar >(val1);
23490 }
23491 {
23492 PyThreadState* __tstate = wxPyBeginAllowThreads();
23493 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23494 wxPyEndAllowThreads(__tstate);
23495 if (PyErr_Occurred()) SWIG_fail;
23496 }
23497 resultobj = SWIG_From_int(static_cast< int >(result));
23498 return resultobj;
23499 fail:
23500 return NULL;
23501 }
23502
23503
23504 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23505 PyObject *resultobj = 0;
23506 int arg1 = (int) wxDateTime::Inv_Year ;
23507 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23508 bool result;
23509 int val1 ;
23510 int ecode1 = 0 ;
23511 int val2 ;
23512 int ecode2 = 0 ;
23513 PyObject * obj0 = 0 ;
23514 PyObject * obj1 = 0 ;
23515 char * kwnames[] = {
23516 (char *) "year",(char *) "cal", NULL
23517 };
23518
23519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23520 if (obj0) {
23521 ecode1 = SWIG_AsVal_int(obj0, &val1);
23522 if (!SWIG_IsOK(ecode1)) {
23523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23524 }
23525 arg1 = static_cast< int >(val1);
23526 }
23527 if (obj1) {
23528 ecode2 = SWIG_AsVal_int(obj1, &val2);
23529 if (!SWIG_IsOK(ecode2)) {
23530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23531 }
23532 arg2 = static_cast< wxDateTime::Calendar >(val2);
23533 }
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23537 wxPyEndAllowThreads(__tstate);
23538 if (PyErr_Occurred()) SWIG_fail;
23539 }
23540 {
23541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23542 }
23543 return resultobj;
23544 fail:
23545 return NULL;
23546 }
23547
23548
23549 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23550 PyObject *resultobj = 0;
23551 int arg1 = (int) wxDateTime::Inv_Year ;
23552 int result;
23553 int val1 ;
23554 int ecode1 = 0 ;
23555 PyObject * obj0 = 0 ;
23556 char * kwnames[] = {
23557 (char *) "year", NULL
23558 };
23559
23560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23561 if (obj0) {
23562 ecode1 = SWIG_AsVal_int(obj0, &val1);
23563 if (!SWIG_IsOK(ecode1)) {
23564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23565 }
23566 arg1 = static_cast< int >(val1);
23567 }
23568 {
23569 PyThreadState* __tstate = wxPyBeginAllowThreads();
23570 result = (int)wxDateTime::GetCentury(arg1);
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 resultobj = SWIG_From_int(static_cast< int >(result));
23575 return resultobj;
23576 fail:
23577 return NULL;
23578 }
23579
23580
23581 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23582 PyObject *resultobj = 0;
23583 int arg1 ;
23584 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23585 int result;
23586 int val1 ;
23587 int ecode1 = 0 ;
23588 int val2 ;
23589 int ecode2 = 0 ;
23590 PyObject * obj0 = 0 ;
23591 PyObject * obj1 = 0 ;
23592 char * kwnames[] = {
23593 (char *) "year",(char *) "cal", NULL
23594 };
23595
23596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23597 ecode1 = SWIG_AsVal_int(obj0, &val1);
23598 if (!SWIG_IsOK(ecode1)) {
23599 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23600 }
23601 arg1 = static_cast< int >(val1);
23602 if (obj1) {
23603 ecode2 = SWIG_AsVal_int(obj1, &val2);
23604 if (!SWIG_IsOK(ecode2)) {
23605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23606 }
23607 arg2 = static_cast< wxDateTime::Calendar >(val2);
23608 }
23609 {
23610 PyThreadState* __tstate = wxPyBeginAllowThreads();
23611 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23612 wxPyEndAllowThreads(__tstate);
23613 if (PyErr_Occurred()) SWIG_fail;
23614 }
23615 resultobj = SWIG_From_int(static_cast< int >(result));
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23623 PyObject *resultobj = 0;
23624 wxDateTime::Month arg1 ;
23625 int arg2 = (int) wxDateTime::Inv_Year ;
23626 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23627 int result;
23628 int val1 ;
23629 int ecode1 = 0 ;
23630 int val2 ;
23631 int ecode2 = 0 ;
23632 int val3 ;
23633 int ecode3 = 0 ;
23634 PyObject * obj0 = 0 ;
23635 PyObject * obj1 = 0 ;
23636 PyObject * obj2 = 0 ;
23637 char * kwnames[] = {
23638 (char *) "month",(char *) "year",(char *) "cal", NULL
23639 };
23640
23641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23642 ecode1 = SWIG_AsVal_int(obj0, &val1);
23643 if (!SWIG_IsOK(ecode1)) {
23644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23645 }
23646 arg1 = static_cast< wxDateTime::Month >(val1);
23647 if (obj1) {
23648 ecode2 = SWIG_AsVal_int(obj1, &val2);
23649 if (!SWIG_IsOK(ecode2)) {
23650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23651 }
23652 arg2 = static_cast< int >(val2);
23653 }
23654 if (obj2) {
23655 ecode3 = SWIG_AsVal_int(obj2, &val3);
23656 if (!SWIG_IsOK(ecode3)) {
23657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23658 }
23659 arg3 = static_cast< wxDateTime::Calendar >(val3);
23660 }
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 resultobj = SWIG_From_int(static_cast< int >(result));
23668 return resultobj;
23669 fail:
23670 return NULL;
23671 }
23672
23673
23674 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23675 PyObject *resultobj = 0;
23676 wxDateTime::Month arg1 ;
23677 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23678 wxString result;
23679 int val1 ;
23680 int ecode1 = 0 ;
23681 int val2 ;
23682 int ecode2 = 0 ;
23683 PyObject * obj0 = 0 ;
23684 PyObject * obj1 = 0 ;
23685 char * kwnames[] = {
23686 (char *) "month",(char *) "flags", NULL
23687 };
23688
23689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23690 ecode1 = SWIG_AsVal_int(obj0, &val1);
23691 if (!SWIG_IsOK(ecode1)) {
23692 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23693 }
23694 arg1 = static_cast< wxDateTime::Month >(val1);
23695 if (obj1) {
23696 ecode2 = SWIG_AsVal_int(obj1, &val2);
23697 if (!SWIG_IsOK(ecode2)) {
23698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23699 }
23700 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23701 }
23702 {
23703 PyThreadState* __tstate = wxPyBeginAllowThreads();
23704 result = wxDateTime::GetMonthName(arg1,arg2);
23705 wxPyEndAllowThreads(__tstate);
23706 if (PyErr_Occurred()) SWIG_fail;
23707 }
23708 {
23709 #if wxUSE_UNICODE
23710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23711 #else
23712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23713 #endif
23714 }
23715 return resultobj;
23716 fail:
23717 return NULL;
23718 }
23719
23720
23721 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23722 PyObject *resultobj = 0;
23723 wxDateTime::WeekDay arg1 ;
23724 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23725 wxString result;
23726 int val1 ;
23727 int ecode1 = 0 ;
23728 int val2 ;
23729 int ecode2 = 0 ;
23730 PyObject * obj0 = 0 ;
23731 PyObject * obj1 = 0 ;
23732 char * kwnames[] = {
23733 (char *) "weekday",(char *) "flags", NULL
23734 };
23735
23736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23737 ecode1 = SWIG_AsVal_int(obj0, &val1);
23738 if (!SWIG_IsOK(ecode1)) {
23739 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23740 }
23741 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23742 if (obj1) {
23743 ecode2 = SWIG_AsVal_int(obj1, &val2);
23744 if (!SWIG_IsOK(ecode2)) {
23745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23746 }
23747 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23748 }
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = wxDateTime::GetWeekDayName(arg1,arg2);
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 {
23756 #if wxUSE_UNICODE
23757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23758 #else
23759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23760 #endif
23761 }
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23769 PyObject *resultobj = 0;
23770 PyObject *result = 0 ;
23771
23772 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23773 {
23774 PyThreadState* __tstate = wxPyBeginAllowThreads();
23775 result = (PyObject *)wxDateTime_GetAmPmStrings();
23776 wxPyEndAllowThreads(__tstate);
23777 if (PyErr_Occurred()) SWIG_fail;
23778 }
23779 resultobj = result;
23780 return resultobj;
23781 fail:
23782 return NULL;
23783 }
23784
23785
23786 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj = 0;
23788 int arg1 = (int) wxDateTime::Inv_Year ;
23789 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23790 bool result;
23791 int val1 ;
23792 int ecode1 = 0 ;
23793 int val2 ;
23794 int ecode2 = 0 ;
23795 PyObject * obj0 = 0 ;
23796 PyObject * obj1 = 0 ;
23797 char * kwnames[] = {
23798 (char *) "year",(char *) "country", NULL
23799 };
23800
23801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23802 if (obj0) {
23803 ecode1 = SWIG_AsVal_int(obj0, &val1);
23804 if (!SWIG_IsOK(ecode1)) {
23805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23806 }
23807 arg1 = static_cast< int >(val1);
23808 }
23809 if (obj1) {
23810 ecode2 = SWIG_AsVal_int(obj1, &val2);
23811 if (!SWIG_IsOK(ecode2)) {
23812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23813 }
23814 arg2 = static_cast< wxDateTime::Country >(val2);
23815 }
23816 {
23817 PyThreadState* __tstate = wxPyBeginAllowThreads();
23818 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23819 wxPyEndAllowThreads(__tstate);
23820 if (PyErr_Occurred()) SWIG_fail;
23821 }
23822 {
23823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23824 }
23825 return resultobj;
23826 fail:
23827 return NULL;
23828 }
23829
23830
23831 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23832 PyObject *resultobj = 0;
23833 int arg1 = (int) wxDateTime::Inv_Year ;
23834 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23835 wxDateTime result;
23836 int val1 ;
23837 int ecode1 = 0 ;
23838 int val2 ;
23839 int ecode2 = 0 ;
23840 PyObject * obj0 = 0 ;
23841 PyObject * obj1 = 0 ;
23842 char * kwnames[] = {
23843 (char *) "year",(char *) "country", NULL
23844 };
23845
23846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23847 if (obj0) {
23848 ecode1 = SWIG_AsVal_int(obj0, &val1);
23849 if (!SWIG_IsOK(ecode1)) {
23850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23851 }
23852 arg1 = static_cast< int >(val1);
23853 }
23854 if (obj1) {
23855 ecode2 = SWIG_AsVal_int(obj1, &val2);
23856 if (!SWIG_IsOK(ecode2)) {
23857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23858 }
23859 arg2 = static_cast< wxDateTime::Country >(val2);
23860 }
23861 {
23862 PyThreadState* __tstate = wxPyBeginAllowThreads();
23863 result = wxDateTime::GetBeginDST(arg1,arg2);
23864 wxPyEndAllowThreads(__tstate);
23865 if (PyErr_Occurred()) SWIG_fail;
23866 }
23867 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23868 return resultobj;
23869 fail:
23870 return NULL;
23871 }
23872
23873
23874 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj = 0;
23876 int arg1 = (int) wxDateTime::Inv_Year ;
23877 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23878 wxDateTime result;
23879 int val1 ;
23880 int ecode1 = 0 ;
23881 int val2 ;
23882 int ecode2 = 0 ;
23883 PyObject * obj0 = 0 ;
23884 PyObject * obj1 = 0 ;
23885 char * kwnames[] = {
23886 (char *) "year",(char *) "country", NULL
23887 };
23888
23889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23890 if (obj0) {
23891 ecode1 = SWIG_AsVal_int(obj0, &val1);
23892 if (!SWIG_IsOK(ecode1)) {
23893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23894 }
23895 arg1 = static_cast< int >(val1);
23896 }
23897 if (obj1) {
23898 ecode2 = SWIG_AsVal_int(obj1, &val2);
23899 if (!SWIG_IsOK(ecode2)) {
23900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23901 }
23902 arg2 = static_cast< wxDateTime::Country >(val2);
23903 }
23904 {
23905 PyThreadState* __tstate = wxPyBeginAllowThreads();
23906 result = wxDateTime::GetEndDST(arg1,arg2);
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23911 return resultobj;
23912 fail:
23913 return NULL;
23914 }
23915
23916
23917 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23918 PyObject *resultobj = 0;
23919 wxDateTime result;
23920
23921 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 result = wxDateTime::Now();
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23936 PyObject *resultobj = 0;
23937 wxDateTime result;
23938
23939 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 result = wxDateTime::UNow();
23943 wxPyEndAllowThreads(__tstate);
23944 if (PyErr_Occurred()) SWIG_fail;
23945 }
23946 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23954 PyObject *resultobj = 0;
23955 wxDateTime result;
23956
23957 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23958 {
23959 PyThreadState* __tstate = wxPyBeginAllowThreads();
23960 result = wxDateTime::Today();
23961 wxPyEndAllowThreads(__tstate);
23962 if (PyErr_Occurred()) SWIG_fail;
23963 }
23964 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23965 return resultobj;
23966 fail:
23967 return NULL;
23968 }
23969
23970
23971 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23972 PyObject *resultobj = 0;
23973 wxDateTime *result = 0 ;
23974
23975 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23976 {
23977 PyThreadState* __tstate = wxPyBeginAllowThreads();
23978 result = (wxDateTime *)new wxDateTime();
23979 wxPyEndAllowThreads(__tstate);
23980 if (PyErr_Occurred()) SWIG_fail;
23981 }
23982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23990 PyObject *resultobj = 0;
23991 time_t arg1 ;
23992 wxDateTime *result = 0 ;
23993 unsigned int val1 ;
23994 int ecode1 = 0 ;
23995 PyObject * obj0 = 0 ;
23996 char * kwnames[] = {
23997 (char *) "timet", NULL
23998 };
23999
24000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
24001 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
24002 if (!SWIG_IsOK(ecode1)) {
24003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
24004 }
24005 arg1 = static_cast< time_t >(val1);
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (wxDateTime *)new wxDateTime(arg1);
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24020 PyObject *resultobj = 0;
24021 double arg1 ;
24022 wxDateTime *result = 0 ;
24023 double val1 ;
24024 int ecode1 = 0 ;
24025 PyObject * obj0 = 0 ;
24026 char * kwnames[] = {
24027 (char *) "jdn", NULL
24028 };
24029
24030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
24031 ecode1 = SWIG_AsVal_double(obj0, &val1);
24032 if (!SWIG_IsOK(ecode1)) {
24033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
24034 }
24035 arg1 = static_cast< double >(val1);
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = (wxDateTime *)new wxDateTime(arg1);
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24050 PyObject *resultobj = 0;
24051 int arg1 ;
24052 int arg2 = (int) 0 ;
24053 int arg3 = (int) 0 ;
24054 int arg4 = (int) 0 ;
24055 wxDateTime *result = 0 ;
24056 int val1 ;
24057 int ecode1 = 0 ;
24058 int val2 ;
24059 int ecode2 = 0 ;
24060 int val3 ;
24061 int ecode3 = 0 ;
24062 int val4 ;
24063 int ecode4 = 0 ;
24064 PyObject * obj0 = 0 ;
24065 PyObject * obj1 = 0 ;
24066 PyObject * obj2 = 0 ;
24067 PyObject * obj3 = 0 ;
24068 char * kwnames[] = {
24069 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24070 };
24071
24072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24073 ecode1 = SWIG_AsVal_int(obj0, &val1);
24074 if (!SWIG_IsOK(ecode1)) {
24075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
24076 }
24077 arg1 = static_cast< int >(val1);
24078 if (obj1) {
24079 ecode2 = SWIG_AsVal_int(obj1, &val2);
24080 if (!SWIG_IsOK(ecode2)) {
24081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
24082 }
24083 arg2 = static_cast< int >(val2);
24084 }
24085 if (obj2) {
24086 ecode3 = SWIG_AsVal_int(obj2, &val3);
24087 if (!SWIG_IsOK(ecode3)) {
24088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
24089 }
24090 arg3 = static_cast< int >(val3);
24091 }
24092 if (obj3) {
24093 ecode4 = SWIG_AsVal_int(obj3, &val4);
24094 if (!SWIG_IsOK(ecode4)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
24096 }
24097 arg4 = static_cast< int >(val4);
24098 }
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24113 PyObject *resultobj = 0;
24114 int arg1 ;
24115 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24116 int arg3 = (int) wxDateTime::Inv_Year ;
24117 int arg4 = (int) 0 ;
24118 int arg5 = (int) 0 ;
24119 int arg6 = (int) 0 ;
24120 int arg7 = (int) 0 ;
24121 wxDateTime *result = 0 ;
24122 int val1 ;
24123 int ecode1 = 0 ;
24124 int val2 ;
24125 int ecode2 = 0 ;
24126 int val3 ;
24127 int ecode3 = 0 ;
24128 int val4 ;
24129 int ecode4 = 0 ;
24130 int val5 ;
24131 int ecode5 = 0 ;
24132 int val6 ;
24133 int ecode6 = 0 ;
24134 int val7 ;
24135 int ecode7 = 0 ;
24136 PyObject * obj0 = 0 ;
24137 PyObject * obj1 = 0 ;
24138 PyObject * obj2 = 0 ;
24139 PyObject * obj3 = 0 ;
24140 PyObject * obj4 = 0 ;
24141 PyObject * obj5 = 0 ;
24142 PyObject * obj6 = 0 ;
24143 char * kwnames[] = {
24144 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24145 };
24146
24147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24148 ecode1 = SWIG_AsVal_int(obj0, &val1);
24149 if (!SWIG_IsOK(ecode1)) {
24150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24151 }
24152 arg1 = static_cast< int >(val1);
24153 if (obj1) {
24154 ecode2 = SWIG_AsVal_int(obj1, &val2);
24155 if (!SWIG_IsOK(ecode2)) {
24156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24157 }
24158 arg2 = static_cast< wxDateTime::Month >(val2);
24159 }
24160 if (obj2) {
24161 ecode3 = SWIG_AsVal_int(obj2, &val3);
24162 if (!SWIG_IsOK(ecode3)) {
24163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24164 }
24165 arg3 = static_cast< int >(val3);
24166 }
24167 if (obj3) {
24168 ecode4 = SWIG_AsVal_int(obj3, &val4);
24169 if (!SWIG_IsOK(ecode4)) {
24170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24171 }
24172 arg4 = static_cast< int >(val4);
24173 }
24174 if (obj4) {
24175 ecode5 = SWIG_AsVal_int(obj4, &val5);
24176 if (!SWIG_IsOK(ecode5)) {
24177 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24178 }
24179 arg5 = static_cast< int >(val5);
24180 }
24181 if (obj5) {
24182 ecode6 = SWIG_AsVal_int(obj5, &val6);
24183 if (!SWIG_IsOK(ecode6)) {
24184 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24185 }
24186 arg6 = static_cast< int >(val6);
24187 }
24188 if (obj6) {
24189 ecode7 = SWIG_AsVal_int(obj6, &val7);
24190 if (!SWIG_IsOK(ecode7)) {
24191 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24192 }
24193 arg7 = static_cast< int >(val7);
24194 }
24195 {
24196 PyThreadState* __tstate = wxPyBeginAllowThreads();
24197 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24198 wxPyEndAllowThreads(__tstate);
24199 if (PyErr_Occurred()) SWIG_fail;
24200 }
24201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24202 return resultobj;
24203 fail:
24204 return NULL;
24205 }
24206
24207
24208 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24209 PyObject *resultobj = 0;
24210 wxDateTime *arg1 = 0 ;
24211 wxDateTime *result = 0 ;
24212 void *argp1 = 0 ;
24213 int res1 = 0 ;
24214 PyObject * obj0 = 0 ;
24215 char * kwnames[] = {
24216 (char *) "date", NULL
24217 };
24218
24219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24220 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24221 if (!SWIG_IsOK(res1)) {
24222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24223 }
24224 if (!argp1) {
24225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24226 }
24227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24228 {
24229 PyThreadState* __tstate = wxPyBeginAllowThreads();
24230 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24231 wxPyEndAllowThreads(__tstate);
24232 if (PyErr_Occurred()) SWIG_fail;
24233 }
24234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24235 return resultobj;
24236 fail:
24237 return NULL;
24238 }
24239
24240
24241 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24242 PyObject *resultobj = 0;
24243 wxDateTime *arg1 = (wxDateTime *) 0 ;
24244 void *argp1 = 0 ;
24245 int res1 = 0 ;
24246 PyObject *swig_obj[1] ;
24247
24248 if (!args) SWIG_fail;
24249 swig_obj[0] = args;
24250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24251 if (!SWIG_IsOK(res1)) {
24252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24253 }
24254 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24255 {
24256 PyThreadState* __tstate = wxPyBeginAllowThreads();
24257 delete arg1;
24258
24259 wxPyEndAllowThreads(__tstate);
24260 if (PyErr_Occurred()) SWIG_fail;
24261 }
24262 resultobj = SWIG_Py_Void();
24263 return resultobj;
24264 fail:
24265 return NULL;
24266 }
24267
24268
24269 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24270 PyObject *resultobj = 0;
24271 wxDateTime *arg1 = (wxDateTime *) 0 ;
24272 wxDateTime *result = 0 ;
24273 void *argp1 = 0 ;
24274 int res1 = 0 ;
24275 PyObject *swig_obj[1] ;
24276
24277 if (!args) SWIG_fail;
24278 swig_obj[0] = args;
24279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24280 if (!SWIG_IsOK(res1)) {
24281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24282 }
24283 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24284 {
24285 PyThreadState* __tstate = wxPyBeginAllowThreads();
24286 {
24287 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24288 result = (wxDateTime *) &_result_ref;
24289 }
24290 wxPyEndAllowThreads(__tstate);
24291 if (PyErr_Occurred()) SWIG_fail;
24292 }
24293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24294 return resultobj;
24295 fail:
24296 return NULL;
24297 }
24298
24299
24300 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24301 PyObject *resultobj = 0;
24302 wxDateTime *arg1 = (wxDateTime *) 0 ;
24303 time_t arg2 ;
24304 wxDateTime *result = 0 ;
24305 void *argp1 = 0 ;
24306 int res1 = 0 ;
24307 unsigned int val2 ;
24308 int ecode2 = 0 ;
24309 PyObject * obj0 = 0 ;
24310 PyObject * obj1 = 0 ;
24311 char * kwnames[] = {
24312 (char *) "self",(char *) "timet", NULL
24313 };
24314
24315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24317 if (!SWIG_IsOK(res1)) {
24318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24319 }
24320 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24321 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24322 if (!SWIG_IsOK(ecode2)) {
24323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24324 }
24325 arg2 = static_cast< time_t >(val2);
24326 {
24327 PyThreadState* __tstate = wxPyBeginAllowThreads();
24328 {
24329 wxDateTime &_result_ref = (arg1)->Set(arg2);
24330 result = (wxDateTime *) &_result_ref;
24331 }
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24343 PyObject *resultobj = 0;
24344 wxDateTime *arg1 = (wxDateTime *) 0 ;
24345 double arg2 ;
24346 wxDateTime *result = 0 ;
24347 void *argp1 = 0 ;
24348 int res1 = 0 ;
24349 double val2 ;
24350 int ecode2 = 0 ;
24351 PyObject * obj0 = 0 ;
24352 PyObject * obj1 = 0 ;
24353 char * kwnames[] = {
24354 (char *) "self",(char *) "jdn", NULL
24355 };
24356
24357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24359 if (!SWIG_IsOK(res1)) {
24360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24361 }
24362 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24363 ecode2 = SWIG_AsVal_double(obj1, &val2);
24364 if (!SWIG_IsOK(ecode2)) {
24365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24366 }
24367 arg2 = static_cast< double >(val2);
24368 {
24369 PyThreadState* __tstate = wxPyBeginAllowThreads();
24370 {
24371 wxDateTime &_result_ref = (arg1)->Set(arg2);
24372 result = (wxDateTime *) &_result_ref;
24373 }
24374 wxPyEndAllowThreads(__tstate);
24375 if (PyErr_Occurred()) SWIG_fail;
24376 }
24377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24378 return resultobj;
24379 fail:
24380 return NULL;
24381 }
24382
24383
24384 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24385 PyObject *resultobj = 0;
24386 wxDateTime *arg1 = (wxDateTime *) 0 ;
24387 int arg2 ;
24388 int arg3 = (int) 0 ;
24389 int arg4 = (int) 0 ;
24390 int arg5 = (int) 0 ;
24391 wxDateTime *result = 0 ;
24392 void *argp1 = 0 ;
24393 int res1 = 0 ;
24394 int val2 ;
24395 int ecode2 = 0 ;
24396 int val3 ;
24397 int ecode3 = 0 ;
24398 int val4 ;
24399 int ecode4 = 0 ;
24400 int val5 ;
24401 int ecode5 = 0 ;
24402 PyObject * obj0 = 0 ;
24403 PyObject * obj1 = 0 ;
24404 PyObject * obj2 = 0 ;
24405 PyObject * obj3 = 0 ;
24406 PyObject * obj4 = 0 ;
24407 char * kwnames[] = {
24408 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24409 };
24410
24411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24413 if (!SWIG_IsOK(res1)) {
24414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24415 }
24416 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24417 ecode2 = SWIG_AsVal_int(obj1, &val2);
24418 if (!SWIG_IsOK(ecode2)) {
24419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24420 }
24421 arg2 = static_cast< int >(val2);
24422 if (obj2) {
24423 ecode3 = SWIG_AsVal_int(obj2, &val3);
24424 if (!SWIG_IsOK(ecode3)) {
24425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24426 }
24427 arg3 = static_cast< int >(val3);
24428 }
24429 if (obj3) {
24430 ecode4 = SWIG_AsVal_int(obj3, &val4);
24431 if (!SWIG_IsOK(ecode4)) {
24432 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24433 }
24434 arg4 = static_cast< int >(val4);
24435 }
24436 if (obj4) {
24437 ecode5 = SWIG_AsVal_int(obj4, &val5);
24438 if (!SWIG_IsOK(ecode5)) {
24439 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24440 }
24441 arg5 = static_cast< int >(val5);
24442 }
24443 {
24444 PyThreadState* __tstate = wxPyBeginAllowThreads();
24445 {
24446 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24447 result = (wxDateTime *) &_result_ref;
24448 }
24449 wxPyEndAllowThreads(__tstate);
24450 if (PyErr_Occurred()) SWIG_fail;
24451 }
24452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24460 PyObject *resultobj = 0;
24461 wxDateTime *arg1 = (wxDateTime *) 0 ;
24462 int arg2 ;
24463 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24464 int arg4 = (int) wxDateTime::Inv_Year ;
24465 int arg5 = (int) 0 ;
24466 int arg6 = (int) 0 ;
24467 int arg7 = (int) 0 ;
24468 int arg8 = (int) 0 ;
24469 wxDateTime *result = 0 ;
24470 void *argp1 = 0 ;
24471 int res1 = 0 ;
24472 int val2 ;
24473 int ecode2 = 0 ;
24474 int val3 ;
24475 int ecode3 = 0 ;
24476 int val4 ;
24477 int ecode4 = 0 ;
24478 int val5 ;
24479 int ecode5 = 0 ;
24480 int val6 ;
24481 int ecode6 = 0 ;
24482 int val7 ;
24483 int ecode7 = 0 ;
24484 int val8 ;
24485 int ecode8 = 0 ;
24486 PyObject * obj0 = 0 ;
24487 PyObject * obj1 = 0 ;
24488 PyObject * obj2 = 0 ;
24489 PyObject * obj3 = 0 ;
24490 PyObject * obj4 = 0 ;
24491 PyObject * obj5 = 0 ;
24492 PyObject * obj6 = 0 ;
24493 PyObject * obj7 = 0 ;
24494 char * kwnames[] = {
24495 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24496 };
24497
24498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24500 if (!SWIG_IsOK(res1)) {
24501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24502 }
24503 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24504 ecode2 = SWIG_AsVal_int(obj1, &val2);
24505 if (!SWIG_IsOK(ecode2)) {
24506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24507 }
24508 arg2 = static_cast< int >(val2);
24509 if (obj2) {
24510 ecode3 = SWIG_AsVal_int(obj2, &val3);
24511 if (!SWIG_IsOK(ecode3)) {
24512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24513 }
24514 arg3 = static_cast< wxDateTime::Month >(val3);
24515 }
24516 if (obj3) {
24517 ecode4 = SWIG_AsVal_int(obj3, &val4);
24518 if (!SWIG_IsOK(ecode4)) {
24519 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24520 }
24521 arg4 = static_cast< int >(val4);
24522 }
24523 if (obj4) {
24524 ecode5 = SWIG_AsVal_int(obj4, &val5);
24525 if (!SWIG_IsOK(ecode5)) {
24526 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24527 }
24528 arg5 = static_cast< int >(val5);
24529 }
24530 if (obj5) {
24531 ecode6 = SWIG_AsVal_int(obj5, &val6);
24532 if (!SWIG_IsOK(ecode6)) {
24533 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24534 }
24535 arg6 = static_cast< int >(val6);
24536 }
24537 if (obj6) {
24538 ecode7 = SWIG_AsVal_int(obj6, &val7);
24539 if (!SWIG_IsOK(ecode7)) {
24540 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24541 }
24542 arg7 = static_cast< int >(val7);
24543 }
24544 if (obj7) {
24545 ecode8 = SWIG_AsVal_int(obj7, &val8);
24546 if (!SWIG_IsOK(ecode8)) {
24547 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24548 }
24549 arg8 = static_cast< int >(val8);
24550 }
24551 {
24552 PyThreadState* __tstate = wxPyBeginAllowThreads();
24553 {
24554 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24555 result = (wxDateTime *) &_result_ref;
24556 }
24557 wxPyEndAllowThreads(__tstate);
24558 if (PyErr_Occurred()) SWIG_fail;
24559 }
24560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24561 return resultobj;
24562 fail:
24563 return NULL;
24564 }
24565
24566
24567 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24568 PyObject *resultobj = 0;
24569 wxDateTime *arg1 = (wxDateTime *) 0 ;
24570 wxDateTime *result = 0 ;
24571 void *argp1 = 0 ;
24572 int res1 = 0 ;
24573 PyObject *swig_obj[1] ;
24574
24575 if (!args) SWIG_fail;
24576 swig_obj[0] = args;
24577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24578 if (!SWIG_IsOK(res1)) {
24579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24580 }
24581 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24582 {
24583 PyThreadState* __tstate = wxPyBeginAllowThreads();
24584 {
24585 wxDateTime &_result_ref = (arg1)->ResetTime();
24586 result = (wxDateTime *) &_result_ref;
24587 }
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 SWIGINTERN PyObject *_wrap_DateTime_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 PyObject *resultobj = 0;
24600 wxDateTime *arg1 = (wxDateTime *) 0 ;
24601 wxDateTime result;
24602 void *argp1 = 0 ;
24603 int res1 = 0 ;
24604 PyObject *swig_obj[1] ;
24605
24606 if (!args) SWIG_fail;
24607 swig_obj[0] = args;
24608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24611 }
24612 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 result = ((wxDateTime const *)arg1)->GetDateOnly();
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24620 return resultobj;
24621 fail:
24622 return NULL;
24623 }
24624
24625
24626 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24627 PyObject *resultobj = 0;
24628 wxDateTime *arg1 = (wxDateTime *) 0 ;
24629 int arg2 ;
24630 wxDateTime *result = 0 ;
24631 void *argp1 = 0 ;
24632 int res1 = 0 ;
24633 int val2 ;
24634 int ecode2 = 0 ;
24635 PyObject * obj0 = 0 ;
24636 PyObject * obj1 = 0 ;
24637 char * kwnames[] = {
24638 (char *) "self",(char *) "year", NULL
24639 };
24640
24641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24643 if (!SWIG_IsOK(res1)) {
24644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24645 }
24646 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24647 ecode2 = SWIG_AsVal_int(obj1, &val2);
24648 if (!SWIG_IsOK(ecode2)) {
24649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24650 }
24651 arg2 = static_cast< int >(val2);
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 {
24655 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24656 result = (wxDateTime *) &_result_ref;
24657 }
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj = 0;
24670 wxDateTime *arg1 = (wxDateTime *) 0 ;
24671 wxDateTime::Month arg2 ;
24672 wxDateTime *result = 0 ;
24673 void *argp1 = 0 ;
24674 int res1 = 0 ;
24675 int val2 ;
24676 int ecode2 = 0 ;
24677 PyObject * obj0 = 0 ;
24678 PyObject * obj1 = 0 ;
24679 char * kwnames[] = {
24680 (char *) "self",(char *) "month", NULL
24681 };
24682
24683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24685 if (!SWIG_IsOK(res1)) {
24686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24687 }
24688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24689 ecode2 = SWIG_AsVal_int(obj1, &val2);
24690 if (!SWIG_IsOK(ecode2)) {
24691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24692 }
24693 arg2 = static_cast< wxDateTime::Month >(val2);
24694 {
24695 PyThreadState* __tstate = wxPyBeginAllowThreads();
24696 {
24697 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24698 result = (wxDateTime *) &_result_ref;
24699 }
24700 wxPyEndAllowThreads(__tstate);
24701 if (PyErr_Occurred()) SWIG_fail;
24702 }
24703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24704 return resultobj;
24705 fail:
24706 return NULL;
24707 }
24708
24709
24710 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24711 PyObject *resultobj = 0;
24712 wxDateTime *arg1 = (wxDateTime *) 0 ;
24713 int arg2 ;
24714 wxDateTime *result = 0 ;
24715 void *argp1 = 0 ;
24716 int res1 = 0 ;
24717 int val2 ;
24718 int ecode2 = 0 ;
24719 PyObject * obj0 = 0 ;
24720 PyObject * obj1 = 0 ;
24721 char * kwnames[] = {
24722 (char *) "self",(char *) "day", NULL
24723 };
24724
24725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24727 if (!SWIG_IsOK(res1)) {
24728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24729 }
24730 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24731 ecode2 = SWIG_AsVal_int(obj1, &val2);
24732 if (!SWIG_IsOK(ecode2)) {
24733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24734 }
24735 arg2 = static_cast< int >(val2);
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 {
24739 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24740 result = (wxDateTime *) &_result_ref;
24741 }
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24753 PyObject *resultobj = 0;
24754 wxDateTime *arg1 = (wxDateTime *) 0 ;
24755 int arg2 ;
24756 wxDateTime *result = 0 ;
24757 void *argp1 = 0 ;
24758 int res1 = 0 ;
24759 int val2 ;
24760 int ecode2 = 0 ;
24761 PyObject * obj0 = 0 ;
24762 PyObject * obj1 = 0 ;
24763 char * kwnames[] = {
24764 (char *) "self",(char *) "hour", NULL
24765 };
24766
24767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24769 if (!SWIG_IsOK(res1)) {
24770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24771 }
24772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24773 ecode2 = SWIG_AsVal_int(obj1, &val2);
24774 if (!SWIG_IsOK(ecode2)) {
24775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24776 }
24777 arg2 = static_cast< int >(val2);
24778 {
24779 PyThreadState* __tstate = wxPyBeginAllowThreads();
24780 {
24781 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24782 result = (wxDateTime *) &_result_ref;
24783 }
24784 wxPyEndAllowThreads(__tstate);
24785 if (PyErr_Occurred()) SWIG_fail;
24786 }
24787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24788 return resultobj;
24789 fail:
24790 return NULL;
24791 }
24792
24793
24794 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj = 0;
24796 wxDateTime *arg1 = (wxDateTime *) 0 ;
24797 int arg2 ;
24798 wxDateTime *result = 0 ;
24799 void *argp1 = 0 ;
24800 int res1 = 0 ;
24801 int val2 ;
24802 int ecode2 = 0 ;
24803 PyObject * obj0 = 0 ;
24804 PyObject * obj1 = 0 ;
24805 char * kwnames[] = {
24806 (char *) "self",(char *) "minute", NULL
24807 };
24808
24809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24811 if (!SWIG_IsOK(res1)) {
24812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24813 }
24814 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24815 ecode2 = SWIG_AsVal_int(obj1, &val2);
24816 if (!SWIG_IsOK(ecode2)) {
24817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24818 }
24819 arg2 = static_cast< int >(val2);
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 {
24823 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24824 result = (wxDateTime *) &_result_ref;
24825 }
24826 wxPyEndAllowThreads(__tstate);
24827 if (PyErr_Occurred()) SWIG_fail;
24828 }
24829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24837 PyObject *resultobj = 0;
24838 wxDateTime *arg1 = (wxDateTime *) 0 ;
24839 int arg2 ;
24840 wxDateTime *result = 0 ;
24841 void *argp1 = 0 ;
24842 int res1 = 0 ;
24843 int val2 ;
24844 int ecode2 = 0 ;
24845 PyObject * obj0 = 0 ;
24846 PyObject * obj1 = 0 ;
24847 char * kwnames[] = {
24848 (char *) "self",(char *) "second", NULL
24849 };
24850
24851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24853 if (!SWIG_IsOK(res1)) {
24854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24855 }
24856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24857 ecode2 = SWIG_AsVal_int(obj1, &val2);
24858 if (!SWIG_IsOK(ecode2)) {
24859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24860 }
24861 arg2 = static_cast< int >(val2);
24862 {
24863 PyThreadState* __tstate = wxPyBeginAllowThreads();
24864 {
24865 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24866 result = (wxDateTime *) &_result_ref;
24867 }
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj = 0;
24880 wxDateTime *arg1 = (wxDateTime *) 0 ;
24881 int arg2 ;
24882 wxDateTime *result = 0 ;
24883 void *argp1 = 0 ;
24884 int res1 = 0 ;
24885 int val2 ;
24886 int ecode2 = 0 ;
24887 PyObject * obj0 = 0 ;
24888 PyObject * obj1 = 0 ;
24889 char * kwnames[] = {
24890 (char *) "self",(char *) "millisecond", NULL
24891 };
24892
24893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24895 if (!SWIG_IsOK(res1)) {
24896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24897 }
24898 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24899 ecode2 = SWIG_AsVal_int(obj1, &val2);
24900 if (!SWIG_IsOK(ecode2)) {
24901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24902 }
24903 arg2 = static_cast< int >(val2);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 {
24907 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24908 result = (wxDateTime *) &_result_ref;
24909 }
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj = 0;
24922 wxDateTime *arg1 = (wxDateTime *) 0 ;
24923 wxDateTime::WeekDay arg2 ;
24924 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24925 wxDateTime *result = 0 ;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 int val2 ;
24929 int ecode2 = 0 ;
24930 int val3 ;
24931 int ecode3 = 0 ;
24932 PyObject * obj0 = 0 ;
24933 PyObject * obj1 = 0 ;
24934 PyObject * obj2 = 0 ;
24935 char * kwnames[] = {
24936 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24937 };
24938
24939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24941 if (!SWIG_IsOK(res1)) {
24942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24943 }
24944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24945 ecode2 = SWIG_AsVal_int(obj1, &val2);
24946 if (!SWIG_IsOK(ecode2)) {
24947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24948 }
24949 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24950 if (obj2) {
24951 ecode3 = SWIG_AsVal_int(obj2, &val3);
24952 if (!SWIG_IsOK(ecode3)) {
24953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24954 }
24955 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24956 }
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 {
24960 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24961 result = (wxDateTime *) &_result_ref;
24962 }
24963 wxPyEndAllowThreads(__tstate);
24964 if (PyErr_Occurred()) SWIG_fail;
24965 }
24966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24974 PyObject *resultobj = 0;
24975 wxDateTime *arg1 = (wxDateTime *) 0 ;
24976 wxDateTime::WeekDay arg2 ;
24977 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24978 wxDateTime result;
24979 void *argp1 = 0 ;
24980 int res1 = 0 ;
24981 int val2 ;
24982 int ecode2 = 0 ;
24983 int val3 ;
24984 int ecode3 = 0 ;
24985 PyObject * obj0 = 0 ;
24986 PyObject * obj1 = 0 ;
24987 PyObject * obj2 = 0 ;
24988 char * kwnames[] = {
24989 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24990 };
24991
24992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24994 if (!SWIG_IsOK(res1)) {
24995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24996 }
24997 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24998 ecode2 = SWIG_AsVal_int(obj1, &val2);
24999 if (!SWIG_IsOK(ecode2)) {
25000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25001 }
25002 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25003 if (obj2) {
25004 ecode3 = SWIG_AsVal_int(obj2, &val3);
25005 if (!SWIG_IsOK(ecode3)) {
25006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
25007 }
25008 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
25009 }
25010 {
25011 PyThreadState* __tstate = wxPyBeginAllowThreads();
25012 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25017 return resultobj;
25018 fail:
25019 return NULL;
25020 }
25021
25022
25023 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25024 PyObject *resultobj = 0;
25025 wxDateTime *arg1 = (wxDateTime *) 0 ;
25026 wxDateTime::WeekDay arg2 ;
25027 wxDateTime *result = 0 ;
25028 void *argp1 = 0 ;
25029 int res1 = 0 ;
25030 int val2 ;
25031 int ecode2 = 0 ;
25032 PyObject * obj0 = 0 ;
25033 PyObject * obj1 = 0 ;
25034 char * kwnames[] = {
25035 (char *) "self",(char *) "weekday", NULL
25036 };
25037
25038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25040 if (!SWIG_IsOK(res1)) {
25041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25042 }
25043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25044 ecode2 = SWIG_AsVal_int(obj1, &val2);
25045 if (!SWIG_IsOK(ecode2)) {
25046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25047 }
25048 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25049 {
25050 PyThreadState* __tstate = wxPyBeginAllowThreads();
25051 {
25052 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
25053 result = (wxDateTime *) &_result_ref;
25054 }
25055 wxPyEndAllowThreads(__tstate);
25056 if (PyErr_Occurred()) SWIG_fail;
25057 }
25058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj = 0;
25067 wxDateTime *arg1 = (wxDateTime *) 0 ;
25068 wxDateTime::WeekDay arg2 ;
25069 wxDateTime result;
25070 void *argp1 = 0 ;
25071 int res1 = 0 ;
25072 int val2 ;
25073 int ecode2 = 0 ;
25074 PyObject * obj0 = 0 ;
25075 PyObject * obj1 = 0 ;
25076 char * kwnames[] = {
25077 (char *) "self",(char *) "weekday", NULL
25078 };
25079
25080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25082 if (!SWIG_IsOK(res1)) {
25083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25084 }
25085 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25086 ecode2 = SWIG_AsVal_int(obj1, &val2);
25087 if (!SWIG_IsOK(ecode2)) {
25088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25089 }
25090 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25091 {
25092 PyThreadState* __tstate = wxPyBeginAllowThreads();
25093 result = (arg1)->GetNextWeekDay(arg2);
25094 wxPyEndAllowThreads(__tstate);
25095 if (PyErr_Occurred()) SWIG_fail;
25096 }
25097 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25098 return resultobj;
25099 fail:
25100 return NULL;
25101 }
25102
25103
25104 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25105 PyObject *resultobj = 0;
25106 wxDateTime *arg1 = (wxDateTime *) 0 ;
25107 wxDateTime::WeekDay arg2 ;
25108 wxDateTime *result = 0 ;
25109 void *argp1 = 0 ;
25110 int res1 = 0 ;
25111 int val2 ;
25112 int ecode2 = 0 ;
25113 PyObject * obj0 = 0 ;
25114 PyObject * obj1 = 0 ;
25115 char * kwnames[] = {
25116 (char *) "self",(char *) "weekday", NULL
25117 };
25118
25119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25121 if (!SWIG_IsOK(res1)) {
25122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25123 }
25124 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25125 ecode2 = SWIG_AsVal_int(obj1, &val2);
25126 if (!SWIG_IsOK(ecode2)) {
25127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25128 }
25129 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25130 {
25131 PyThreadState* __tstate = wxPyBeginAllowThreads();
25132 {
25133 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
25134 result = (wxDateTime *) &_result_ref;
25135 }
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25147 PyObject *resultobj = 0;
25148 wxDateTime *arg1 = (wxDateTime *) 0 ;
25149 wxDateTime::WeekDay arg2 ;
25150 wxDateTime result;
25151 void *argp1 = 0 ;
25152 int res1 = 0 ;
25153 int val2 ;
25154 int ecode2 = 0 ;
25155 PyObject * obj0 = 0 ;
25156 PyObject * obj1 = 0 ;
25157 char * kwnames[] = {
25158 (char *) "self",(char *) "weekday", NULL
25159 };
25160
25161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25163 if (!SWIG_IsOK(res1)) {
25164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25165 }
25166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25167 ecode2 = SWIG_AsVal_int(obj1, &val2);
25168 if (!SWIG_IsOK(ecode2)) {
25169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25170 }
25171 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25172 {
25173 PyThreadState* __tstate = wxPyBeginAllowThreads();
25174 result = (arg1)->GetPrevWeekDay(arg2);
25175 wxPyEndAllowThreads(__tstate);
25176 if (PyErr_Occurred()) SWIG_fail;
25177 }
25178 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25179 return resultobj;
25180 fail:
25181 return NULL;
25182 }
25183
25184
25185 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25186 PyObject *resultobj = 0;
25187 wxDateTime *arg1 = (wxDateTime *) 0 ;
25188 wxDateTime::WeekDay arg2 ;
25189 int arg3 = (int) 1 ;
25190 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25191 int arg5 = (int) wxDateTime::Inv_Year ;
25192 bool result;
25193 void *argp1 = 0 ;
25194 int res1 = 0 ;
25195 int val2 ;
25196 int ecode2 = 0 ;
25197 int val3 ;
25198 int ecode3 = 0 ;
25199 int val4 ;
25200 int ecode4 = 0 ;
25201 int val5 ;
25202 int ecode5 = 0 ;
25203 PyObject * obj0 = 0 ;
25204 PyObject * obj1 = 0 ;
25205 PyObject * obj2 = 0 ;
25206 PyObject * obj3 = 0 ;
25207 PyObject * obj4 = 0 ;
25208 char * kwnames[] = {
25209 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25210 };
25211
25212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25214 if (!SWIG_IsOK(res1)) {
25215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25216 }
25217 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25218 ecode2 = SWIG_AsVal_int(obj1, &val2);
25219 if (!SWIG_IsOK(ecode2)) {
25220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25221 }
25222 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25223 if (obj2) {
25224 ecode3 = SWIG_AsVal_int(obj2, &val3);
25225 if (!SWIG_IsOK(ecode3)) {
25226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25227 }
25228 arg3 = static_cast< int >(val3);
25229 }
25230 if (obj3) {
25231 ecode4 = SWIG_AsVal_int(obj3, &val4);
25232 if (!SWIG_IsOK(ecode4)) {
25233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25234 }
25235 arg4 = static_cast< wxDateTime::Month >(val4);
25236 }
25237 if (obj4) {
25238 ecode5 = SWIG_AsVal_int(obj4, &val5);
25239 if (!SWIG_IsOK(ecode5)) {
25240 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25241 }
25242 arg5 = static_cast< int >(val5);
25243 }
25244 {
25245 PyThreadState* __tstate = wxPyBeginAllowThreads();
25246 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 {
25251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25252 }
25253 return resultobj;
25254 fail:
25255 return NULL;
25256 }
25257
25258
25259 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25260 PyObject *resultobj = 0;
25261 wxDateTime *arg1 = (wxDateTime *) 0 ;
25262 wxDateTime::WeekDay arg2 ;
25263 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25264 int arg4 = (int) wxDateTime::Inv_Year ;
25265 bool result;
25266 void *argp1 = 0 ;
25267 int res1 = 0 ;
25268 int val2 ;
25269 int ecode2 = 0 ;
25270 int val3 ;
25271 int ecode3 = 0 ;
25272 int val4 ;
25273 int ecode4 = 0 ;
25274 PyObject * obj0 = 0 ;
25275 PyObject * obj1 = 0 ;
25276 PyObject * obj2 = 0 ;
25277 PyObject * obj3 = 0 ;
25278 char * kwnames[] = {
25279 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25280 };
25281
25282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25284 if (!SWIG_IsOK(res1)) {
25285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25286 }
25287 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25288 ecode2 = SWIG_AsVal_int(obj1, &val2);
25289 if (!SWIG_IsOK(ecode2)) {
25290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25291 }
25292 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25293 if (obj2) {
25294 ecode3 = SWIG_AsVal_int(obj2, &val3);
25295 if (!SWIG_IsOK(ecode3)) {
25296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25297 }
25298 arg3 = static_cast< wxDateTime::Month >(val3);
25299 }
25300 if (obj3) {
25301 ecode4 = SWIG_AsVal_int(obj3, &val4);
25302 if (!SWIG_IsOK(ecode4)) {
25303 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25304 }
25305 arg4 = static_cast< int >(val4);
25306 }
25307 {
25308 PyThreadState* __tstate = wxPyBeginAllowThreads();
25309 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25310 wxPyEndAllowThreads(__tstate);
25311 if (PyErr_Occurred()) SWIG_fail;
25312 }
25313 {
25314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25315 }
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25323 PyObject *resultobj = 0;
25324 wxDateTime *arg1 = (wxDateTime *) 0 ;
25325 wxDateTime::WeekDay arg2 ;
25326 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25327 int arg4 = (int) wxDateTime::Inv_Year ;
25328 wxDateTime result;
25329 void *argp1 = 0 ;
25330 int res1 = 0 ;
25331 int val2 ;
25332 int ecode2 = 0 ;
25333 int val3 ;
25334 int ecode3 = 0 ;
25335 int val4 ;
25336 int ecode4 = 0 ;
25337 PyObject * obj0 = 0 ;
25338 PyObject * obj1 = 0 ;
25339 PyObject * obj2 = 0 ;
25340 PyObject * obj3 = 0 ;
25341 char * kwnames[] = {
25342 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25343 };
25344
25345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25347 if (!SWIG_IsOK(res1)) {
25348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25349 }
25350 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25351 ecode2 = SWIG_AsVal_int(obj1, &val2);
25352 if (!SWIG_IsOK(ecode2)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25354 }
25355 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25356 if (obj2) {
25357 ecode3 = SWIG_AsVal_int(obj2, &val3);
25358 if (!SWIG_IsOK(ecode3)) {
25359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25360 }
25361 arg3 = static_cast< wxDateTime::Month >(val3);
25362 }
25363 if (obj3) {
25364 ecode4 = SWIG_AsVal_int(obj3, &val4);
25365 if (!SWIG_IsOK(ecode4)) {
25366 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25367 }
25368 arg4 = static_cast< int >(val4);
25369 }
25370 {
25371 PyThreadState* __tstate = wxPyBeginAllowThreads();
25372 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25377 return resultobj;
25378 fail:
25379 return NULL;
25380 }
25381
25382
25383 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25384 PyObject *resultobj = 0;
25385 int arg1 ;
25386 int arg2 ;
25387 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25388 wxDateTime result;
25389 int val1 ;
25390 int ecode1 = 0 ;
25391 int val2 ;
25392 int ecode2 = 0 ;
25393 int val3 ;
25394 int ecode3 = 0 ;
25395 PyObject * obj0 = 0 ;
25396 PyObject * obj1 = 0 ;
25397 PyObject * obj2 = 0 ;
25398 char * kwnames[] = {
25399 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25400 };
25401
25402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25403 ecode1 = SWIG_AsVal_int(obj0, &val1);
25404 if (!SWIG_IsOK(ecode1)) {
25405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25406 }
25407 arg1 = static_cast< int >(val1);
25408 ecode2 = SWIG_AsVal_int(obj1, &val2);
25409 if (!SWIG_IsOK(ecode2)) {
25410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25411 }
25412 arg2 = static_cast< int >(val2);
25413 if (obj2) {
25414 ecode3 = SWIG_AsVal_int(obj2, &val3);
25415 if (!SWIG_IsOK(ecode3)) {
25416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25417 }
25418 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25419 }
25420 {
25421 PyThreadState* __tstate = wxPyBeginAllowThreads();
25422 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25423 wxPyEndAllowThreads(__tstate);
25424 if (PyErr_Occurred()) SWIG_fail;
25425 }
25426 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25427 return resultobj;
25428 fail:
25429 return NULL;
25430 }
25431
25432
25433 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25434 PyObject *resultobj = 0;
25435 wxDateTime *arg1 = (wxDateTime *) 0 ;
25436 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25437 int arg3 = (int) wxDateTime::Inv_Year ;
25438 wxDateTime *result = 0 ;
25439 void *argp1 = 0 ;
25440 int res1 = 0 ;
25441 int val2 ;
25442 int ecode2 = 0 ;
25443 int val3 ;
25444 int ecode3 = 0 ;
25445 PyObject * obj0 = 0 ;
25446 PyObject * obj1 = 0 ;
25447 PyObject * obj2 = 0 ;
25448 char * kwnames[] = {
25449 (char *) "self",(char *) "month",(char *) "year", NULL
25450 };
25451
25452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25454 if (!SWIG_IsOK(res1)) {
25455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25456 }
25457 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25458 if (obj1) {
25459 ecode2 = SWIG_AsVal_int(obj1, &val2);
25460 if (!SWIG_IsOK(ecode2)) {
25461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25462 }
25463 arg2 = static_cast< wxDateTime::Month >(val2);
25464 }
25465 if (obj2) {
25466 ecode3 = SWIG_AsVal_int(obj2, &val3);
25467 if (!SWIG_IsOK(ecode3)) {
25468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25469 }
25470 arg3 = static_cast< int >(val3);
25471 }
25472 {
25473 PyThreadState* __tstate = wxPyBeginAllowThreads();
25474 {
25475 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25476 result = (wxDateTime *) &_result_ref;
25477 }
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25489 PyObject *resultobj = 0;
25490 wxDateTime *arg1 = (wxDateTime *) 0 ;
25491 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25492 int arg3 = (int) wxDateTime::Inv_Year ;
25493 wxDateTime result;
25494 void *argp1 = 0 ;
25495 int res1 = 0 ;
25496 int val2 ;
25497 int ecode2 = 0 ;
25498 int val3 ;
25499 int ecode3 = 0 ;
25500 PyObject * obj0 = 0 ;
25501 PyObject * obj1 = 0 ;
25502 PyObject * obj2 = 0 ;
25503 char * kwnames[] = {
25504 (char *) "self",(char *) "month",(char *) "year", NULL
25505 };
25506
25507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25509 if (!SWIG_IsOK(res1)) {
25510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25511 }
25512 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25513 if (obj1) {
25514 ecode2 = SWIG_AsVal_int(obj1, &val2);
25515 if (!SWIG_IsOK(ecode2)) {
25516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25517 }
25518 arg2 = static_cast< wxDateTime::Month >(val2);
25519 }
25520 if (obj2) {
25521 ecode3 = SWIG_AsVal_int(obj2, &val3);
25522 if (!SWIG_IsOK(ecode3)) {
25523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25524 }
25525 arg3 = static_cast< int >(val3);
25526 }
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 result = (arg1)->GetLastMonthDay(arg2,arg3);
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25541 PyObject *resultobj = 0;
25542 wxDateTime *arg1 = (wxDateTime *) 0 ;
25543 int arg2 ;
25544 wxDateTime *result = 0 ;
25545 void *argp1 = 0 ;
25546 int res1 = 0 ;
25547 int val2 ;
25548 int ecode2 = 0 ;
25549 PyObject * obj0 = 0 ;
25550 PyObject * obj1 = 0 ;
25551 char * kwnames[] = {
25552 (char *) "self",(char *) "yday", NULL
25553 };
25554
25555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25557 if (!SWIG_IsOK(res1)) {
25558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25559 }
25560 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25561 ecode2 = SWIG_AsVal_int(obj1, &val2);
25562 if (!SWIG_IsOK(ecode2)) {
25563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25564 }
25565 arg2 = static_cast< int >(val2);
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 {
25569 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25570 result = (wxDateTime *) &_result_ref;
25571 }
25572 wxPyEndAllowThreads(__tstate);
25573 if (PyErr_Occurred()) SWIG_fail;
25574 }
25575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25576 return resultobj;
25577 fail:
25578 return NULL;
25579 }
25580
25581
25582 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25583 PyObject *resultobj = 0;
25584 wxDateTime *arg1 = (wxDateTime *) 0 ;
25585 int arg2 ;
25586 wxDateTime result;
25587 void *argp1 = 0 ;
25588 int res1 = 0 ;
25589 int val2 ;
25590 int ecode2 = 0 ;
25591 PyObject * obj0 = 0 ;
25592 PyObject * obj1 = 0 ;
25593 char * kwnames[] = {
25594 (char *) "self",(char *) "yday", NULL
25595 };
25596
25597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25599 if (!SWIG_IsOK(res1)) {
25600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25601 }
25602 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25603 ecode2 = SWIG_AsVal_int(obj1, &val2);
25604 if (!SWIG_IsOK(ecode2)) {
25605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25606 }
25607 arg2 = static_cast< int >(val2);
25608 {
25609 PyThreadState* __tstate = wxPyBeginAllowThreads();
25610 result = (arg1)->GetYearDay(arg2);
25611 wxPyEndAllowThreads(__tstate);
25612 if (PyErr_Occurred()) SWIG_fail;
25613 }
25614 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25615 return resultobj;
25616 fail:
25617 return NULL;
25618 }
25619
25620
25621 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25622 PyObject *resultobj = 0;
25623 wxDateTime *arg1 = (wxDateTime *) 0 ;
25624 double result;
25625 void *argp1 = 0 ;
25626 int res1 = 0 ;
25627 PyObject *swig_obj[1] ;
25628
25629 if (!args) SWIG_fail;
25630 swig_obj[0] = args;
25631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25632 if (!SWIG_IsOK(res1)) {
25633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25634 }
25635 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25636 {
25637 PyThreadState* __tstate = wxPyBeginAllowThreads();
25638 result = (double)(arg1)->GetJulianDayNumber();
25639 wxPyEndAllowThreads(__tstate);
25640 if (PyErr_Occurred()) SWIG_fail;
25641 }
25642 resultobj = SWIG_From_double(static_cast< double >(result));
25643 return resultobj;
25644 fail:
25645 return NULL;
25646 }
25647
25648
25649 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25650 PyObject *resultobj = 0;
25651 wxDateTime *arg1 = (wxDateTime *) 0 ;
25652 double result;
25653 void *argp1 = 0 ;
25654 int res1 = 0 ;
25655 PyObject *swig_obj[1] ;
25656
25657 if (!args) SWIG_fail;
25658 swig_obj[0] = args;
25659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25660 if (!SWIG_IsOK(res1)) {
25661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25662 }
25663 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25664 {
25665 PyThreadState* __tstate = wxPyBeginAllowThreads();
25666 result = (double)(arg1)->GetJDN();
25667 wxPyEndAllowThreads(__tstate);
25668 if (PyErr_Occurred()) SWIG_fail;
25669 }
25670 resultobj = SWIG_From_double(static_cast< double >(result));
25671 return resultobj;
25672 fail:
25673 return NULL;
25674 }
25675
25676
25677 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25678 PyObject *resultobj = 0;
25679 wxDateTime *arg1 = (wxDateTime *) 0 ;
25680 double result;
25681 void *argp1 = 0 ;
25682 int res1 = 0 ;
25683 PyObject *swig_obj[1] ;
25684
25685 if (!args) SWIG_fail;
25686 swig_obj[0] = args;
25687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25688 if (!SWIG_IsOK(res1)) {
25689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25690 }
25691 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25692 {
25693 PyThreadState* __tstate = wxPyBeginAllowThreads();
25694 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25695 wxPyEndAllowThreads(__tstate);
25696 if (PyErr_Occurred()) SWIG_fail;
25697 }
25698 resultobj = SWIG_From_double(static_cast< double >(result));
25699 return resultobj;
25700 fail:
25701 return NULL;
25702 }
25703
25704
25705 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25706 PyObject *resultobj = 0;
25707 wxDateTime *arg1 = (wxDateTime *) 0 ;
25708 double result;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 PyObject *swig_obj[1] ;
25712
25713 if (!args) SWIG_fail;
25714 swig_obj[0] = args;
25715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25718 }
25719 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 result = (double)(arg1)->GetMJD();
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 resultobj = SWIG_From_double(static_cast< double >(result));
25727 return resultobj;
25728 fail:
25729 return NULL;
25730 }
25731
25732
25733 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25734 PyObject *resultobj = 0;
25735 wxDateTime *arg1 = (wxDateTime *) 0 ;
25736 double result;
25737 void *argp1 = 0 ;
25738 int res1 = 0 ;
25739 PyObject *swig_obj[1] ;
25740
25741 if (!args) SWIG_fail;
25742 swig_obj[0] = args;
25743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25746 }
25747 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25748 {
25749 PyThreadState* __tstate = wxPyBeginAllowThreads();
25750 result = (double)(arg1)->GetRataDie();
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 resultobj = SWIG_From_double(static_cast< double >(result));
25755 return resultobj;
25756 fail:
25757 return NULL;
25758 }
25759
25760
25761 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25762 PyObject *resultobj = 0;
25763 wxDateTime *arg1 = (wxDateTime *) 0 ;
25764 wxDateTime::TimeZone *arg2 = 0 ;
25765 bool arg3 = (bool) false ;
25766 wxDateTime result;
25767 void *argp1 = 0 ;
25768 int res1 = 0 ;
25769 bool temp2 = false ;
25770 bool val3 ;
25771 int ecode3 = 0 ;
25772 PyObject * obj0 = 0 ;
25773 PyObject * obj1 = 0 ;
25774 PyObject * obj2 = 0 ;
25775 char * kwnames[] = {
25776 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25777 };
25778
25779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25781 if (!SWIG_IsOK(res1)) {
25782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25783 }
25784 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25785 {
25786 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25787 temp2 = true;
25788 }
25789 if (obj2) {
25790 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25791 if (!SWIG_IsOK(ecode3)) {
25792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25793 }
25794 arg3 = static_cast< bool >(val3);
25795 }
25796 {
25797 PyThreadState* __tstate = wxPyBeginAllowThreads();
25798 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25799 wxPyEndAllowThreads(__tstate);
25800 if (PyErr_Occurred()) SWIG_fail;
25801 }
25802 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25803 {
25804 if (temp2) delete arg2;
25805 }
25806 return resultobj;
25807 fail:
25808 {
25809 if (temp2) delete arg2;
25810 }
25811 return NULL;
25812 }
25813
25814
25815 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25816 PyObject *resultobj = 0;
25817 wxDateTime *arg1 = (wxDateTime *) 0 ;
25818 wxDateTime::TimeZone *arg2 = 0 ;
25819 bool arg3 = (bool) false ;
25820 wxDateTime *result = 0 ;
25821 void *argp1 = 0 ;
25822 int res1 = 0 ;
25823 bool temp2 = false ;
25824 bool val3 ;
25825 int ecode3 = 0 ;
25826 PyObject * obj0 = 0 ;
25827 PyObject * obj1 = 0 ;
25828 PyObject * obj2 = 0 ;
25829 char * kwnames[] = {
25830 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25831 };
25832
25833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25835 if (!SWIG_IsOK(res1)) {
25836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25837 }
25838 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25839 {
25840 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25841 temp2 = true;
25842 }
25843 if (obj2) {
25844 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25845 if (!SWIG_IsOK(ecode3)) {
25846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25847 }
25848 arg3 = static_cast< bool >(val3);
25849 }
25850 {
25851 PyThreadState* __tstate = wxPyBeginAllowThreads();
25852 {
25853 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25854 result = (wxDateTime *) &_result_ref;
25855 }
25856 wxPyEndAllowThreads(__tstate);
25857 if (PyErr_Occurred()) SWIG_fail;
25858 }
25859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25860 {
25861 if (temp2) delete arg2;
25862 }
25863 return resultobj;
25864 fail:
25865 {
25866 if (temp2) delete arg2;
25867 }
25868 return NULL;
25869 }
25870
25871
25872 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj = 0;
25874 wxDateTime *arg1 = (wxDateTime *) 0 ;
25875 wxDateTime::TimeZone *arg2 = 0 ;
25876 bool arg3 = (bool) false ;
25877 wxDateTime result;
25878 void *argp1 = 0 ;
25879 int res1 = 0 ;
25880 bool temp2 = false ;
25881 bool val3 ;
25882 int ecode3 = 0 ;
25883 PyObject * obj0 = 0 ;
25884 PyObject * obj1 = 0 ;
25885 PyObject * obj2 = 0 ;
25886 char * kwnames[] = {
25887 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25888 };
25889
25890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25892 if (!SWIG_IsOK(res1)) {
25893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25894 }
25895 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25896 {
25897 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25898 temp2 = true;
25899 }
25900 if (obj2) {
25901 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25902 if (!SWIG_IsOK(ecode3)) {
25903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25904 }
25905 arg3 = static_cast< bool >(val3);
25906 }
25907 {
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25910 wxPyEndAllowThreads(__tstate);
25911 if (PyErr_Occurred()) SWIG_fail;
25912 }
25913 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25914 {
25915 if (temp2) delete arg2;
25916 }
25917 return resultobj;
25918 fail:
25919 {
25920 if (temp2) delete arg2;
25921 }
25922 return NULL;
25923 }
25924
25925
25926 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj = 0;
25928 wxDateTime *arg1 = (wxDateTime *) 0 ;
25929 wxDateTime::TimeZone *arg2 = 0 ;
25930 bool arg3 = (bool) false ;
25931 wxDateTime *result = 0 ;
25932 void *argp1 = 0 ;
25933 int res1 = 0 ;
25934 bool temp2 = false ;
25935 bool val3 ;
25936 int ecode3 = 0 ;
25937 PyObject * obj0 = 0 ;
25938 PyObject * obj1 = 0 ;
25939 PyObject * obj2 = 0 ;
25940 char * kwnames[] = {
25941 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25942 };
25943
25944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25946 if (!SWIG_IsOK(res1)) {
25947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25948 }
25949 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25950 {
25951 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25952 temp2 = true;
25953 }
25954 if (obj2) {
25955 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25956 if (!SWIG_IsOK(ecode3)) {
25957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25958 }
25959 arg3 = static_cast< bool >(val3);
25960 }
25961 {
25962 PyThreadState* __tstate = wxPyBeginAllowThreads();
25963 {
25964 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25965 result = (wxDateTime *) &_result_ref;
25966 }
25967 wxPyEndAllowThreads(__tstate);
25968 if (PyErr_Occurred()) SWIG_fail;
25969 }
25970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25971 {
25972 if (temp2) delete arg2;
25973 }
25974 return resultobj;
25975 fail:
25976 {
25977 if (temp2) delete arg2;
25978 }
25979 return NULL;
25980 }
25981
25982
25983 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25984 PyObject *resultobj = 0;
25985 wxDateTime *arg1 = (wxDateTime *) 0 ;
25986 bool arg2 = (bool) false ;
25987 wxDateTime result;
25988 void *argp1 = 0 ;
25989 int res1 = 0 ;
25990 bool val2 ;
25991 int ecode2 = 0 ;
25992 PyObject * obj0 = 0 ;
25993 PyObject * obj1 = 0 ;
25994 char * kwnames[] = {
25995 (char *) "self",(char *) "noDST", NULL
25996 };
25997
25998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26002 }
26003 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26004 if (obj1) {
26005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26006 if (!SWIG_IsOK(ecode2)) {
26007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
26008 }
26009 arg2 = static_cast< bool >(val2);
26010 }
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj = 0;
26026 wxDateTime *arg1 = (wxDateTime *) 0 ;
26027 bool arg2 = (bool) false ;
26028 wxDateTime *result = 0 ;
26029 void *argp1 = 0 ;
26030 int res1 = 0 ;
26031 bool val2 ;
26032 int ecode2 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char * kwnames[] = {
26036 (char *) "self",(char *) "noDST", NULL
26037 };
26038
26039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26043 }
26044 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26045 if (obj1) {
26046 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26047 if (!SWIG_IsOK(ecode2)) {
26048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26049 }
26050 arg2 = static_cast< bool >(val2);
26051 }
26052 {
26053 PyThreadState* __tstate = wxPyBeginAllowThreads();
26054 {
26055 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26056 result = (wxDateTime *) &_result_ref;
26057 }
26058 wxPyEndAllowThreads(__tstate);
26059 if (PyErr_Occurred()) SWIG_fail;
26060 }
26061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26062 return resultobj;
26063 fail:
26064 return NULL;
26065 }
26066
26067
26068 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26069 PyObject *resultobj = 0;
26070 wxDateTime *arg1 = (wxDateTime *) 0 ;
26071 bool arg2 = (bool) false ;
26072 wxDateTime result;
26073 void *argp1 = 0 ;
26074 int res1 = 0 ;
26075 bool val2 ;
26076 int ecode2 = 0 ;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char * kwnames[] = {
26080 (char *) "self",(char *) "noDST", NULL
26081 };
26082
26083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26085 if (!SWIG_IsOK(res1)) {
26086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26087 }
26088 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26089 if (obj1) {
26090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26091 if (!SWIG_IsOK(ecode2)) {
26092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26093 }
26094 arg2 = static_cast< bool >(val2);
26095 }
26096 {
26097 PyThreadState* __tstate = wxPyBeginAllowThreads();
26098 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26099 wxPyEndAllowThreads(__tstate);
26100 if (PyErr_Occurred()) SWIG_fail;
26101 }
26102 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26103 return resultobj;
26104 fail:
26105 return NULL;
26106 }
26107
26108
26109 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26110 PyObject *resultobj = 0;
26111 wxDateTime *arg1 = (wxDateTime *) 0 ;
26112 bool arg2 = (bool) false ;
26113 wxDateTime *result = 0 ;
26114 void *argp1 = 0 ;
26115 int res1 = 0 ;
26116 bool val2 ;
26117 int ecode2 = 0 ;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char * kwnames[] = {
26121 (char *) "self",(char *) "noDST", NULL
26122 };
26123
26124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26126 if (!SWIG_IsOK(res1)) {
26127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26128 }
26129 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26130 if (obj1) {
26131 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26132 if (!SWIG_IsOK(ecode2)) {
26133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26134 }
26135 arg2 = static_cast< bool >(val2);
26136 }
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 {
26140 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26141 result = (wxDateTime *) &_result_ref;
26142 }
26143 wxPyEndAllowThreads(__tstate);
26144 if (PyErr_Occurred()) SWIG_fail;
26145 }
26146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26154 PyObject *resultobj = 0;
26155 wxDateTime *arg1 = (wxDateTime *) 0 ;
26156 bool arg2 = (bool) false ;
26157 wxDateTime result;
26158 void *argp1 = 0 ;
26159 int res1 = 0 ;
26160 bool val2 ;
26161 int ecode2 = 0 ;
26162 PyObject * obj0 = 0 ;
26163 PyObject * obj1 = 0 ;
26164 char * kwnames[] = {
26165 (char *) "self",(char *) "noDST", NULL
26166 };
26167
26168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26172 }
26173 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26174 if (obj1) {
26175 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26176 if (!SWIG_IsOK(ecode2)) {
26177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26178 }
26179 arg2 = static_cast< bool >(val2);
26180 }
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26184 wxPyEndAllowThreads(__tstate);
26185 if (PyErr_Occurred()) SWIG_fail;
26186 }
26187 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26188 return resultobj;
26189 fail:
26190 return NULL;
26191 }
26192
26193
26194 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26195 PyObject *resultobj = 0;
26196 wxDateTime *arg1 = (wxDateTime *) 0 ;
26197 bool arg2 = (bool) false ;
26198 wxDateTime *result = 0 ;
26199 void *argp1 = 0 ;
26200 int res1 = 0 ;
26201 bool val2 ;
26202 int ecode2 = 0 ;
26203 PyObject * obj0 = 0 ;
26204 PyObject * obj1 = 0 ;
26205 char * kwnames[] = {
26206 (char *) "self",(char *) "noDST", NULL
26207 };
26208
26209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26211 if (!SWIG_IsOK(res1)) {
26212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26213 }
26214 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26215 if (obj1) {
26216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26217 if (!SWIG_IsOK(ecode2)) {
26218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26219 }
26220 arg2 = static_cast< bool >(val2);
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 {
26225 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26226 result = (wxDateTime *) &_result_ref;
26227 }
26228 wxPyEndAllowThreads(__tstate);
26229 if (PyErr_Occurred()) SWIG_fail;
26230 }
26231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26239 PyObject *resultobj = 0;
26240 wxDateTime *arg1 = (wxDateTime *) 0 ;
26241 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26242 int result;
26243 void *argp1 = 0 ;
26244 int res1 = 0 ;
26245 int val2 ;
26246 int ecode2 = 0 ;
26247 PyObject * obj0 = 0 ;
26248 PyObject * obj1 = 0 ;
26249 char * kwnames[] = {
26250 (char *) "self",(char *) "country", NULL
26251 };
26252
26253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26255 if (!SWIG_IsOK(res1)) {
26256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26257 }
26258 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26259 if (obj1) {
26260 ecode2 = SWIG_AsVal_int(obj1, &val2);
26261 if (!SWIG_IsOK(ecode2)) {
26262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26263 }
26264 arg2 = static_cast< wxDateTime::Country >(val2);
26265 }
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 result = (int)(arg1)->IsDST(arg2);
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 resultobj = SWIG_From_int(static_cast< int >(result));
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26280 PyObject *resultobj = 0;
26281 wxDateTime *arg1 = (wxDateTime *) 0 ;
26282 bool result;
26283 void *argp1 = 0 ;
26284 int res1 = 0 ;
26285 PyObject *swig_obj[1] ;
26286
26287 if (!args) SWIG_fail;
26288 swig_obj[0] = args;
26289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26290 if (!SWIG_IsOK(res1)) {
26291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26292 }
26293 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = (bool)((wxDateTime const *)arg1)->IsValid();
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 {
26301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26302 }
26303 return resultobj;
26304 fail:
26305 return NULL;
26306 }
26307
26308
26309 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26310 PyObject *resultobj = 0;
26311 wxDateTime *arg1 = (wxDateTime *) 0 ;
26312 time_t result;
26313 void *argp1 = 0 ;
26314 int res1 = 0 ;
26315 PyObject *swig_obj[1] ;
26316
26317 if (!args) SWIG_fail;
26318 swig_obj[0] = args;
26319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26320 if (!SWIG_IsOK(res1)) {
26321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26322 }
26323 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26324 {
26325 PyThreadState* __tstate = wxPyBeginAllowThreads();
26326 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26331 return resultobj;
26332 fail:
26333 return NULL;
26334 }
26335
26336
26337 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26338 PyObject *resultobj = 0;
26339 wxDateTime *arg1 = (wxDateTime *) 0 ;
26340 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26341 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26342 int result;
26343 void *argp1 = 0 ;
26344 int res1 = 0 ;
26345 bool temp2 = false ;
26346 PyObject * obj0 = 0 ;
26347 PyObject * obj1 = 0 ;
26348 char * kwnames[] = {
26349 (char *) "self",(char *) "tz", NULL
26350 };
26351
26352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26354 if (!SWIG_IsOK(res1)) {
26355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26356 }
26357 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26358 if (obj1) {
26359 {
26360 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26361 temp2 = true;
26362 }
26363 }
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26367 wxPyEndAllowThreads(__tstate);
26368 if (PyErr_Occurred()) SWIG_fail;
26369 }
26370 resultobj = SWIG_From_int(static_cast< int >(result));
26371 {
26372 if (temp2) delete arg2;
26373 }
26374 return resultobj;
26375 fail:
26376 {
26377 if (temp2) delete arg2;
26378 }
26379 return NULL;
26380 }
26381
26382
26383 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26384 PyObject *resultobj = 0;
26385 wxDateTime *arg1 = (wxDateTime *) 0 ;
26386 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26387 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26388 wxDateTime::Month result;
26389 void *argp1 = 0 ;
26390 int res1 = 0 ;
26391 bool temp2 = false ;
26392 PyObject * obj0 = 0 ;
26393 PyObject * obj1 = 0 ;
26394 char * kwnames[] = {
26395 (char *) "self",(char *) "tz", NULL
26396 };
26397
26398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26400 if (!SWIG_IsOK(res1)) {
26401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26402 }
26403 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26404 if (obj1) {
26405 {
26406 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26407 temp2 = true;
26408 }
26409 }
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 resultobj = SWIG_From_int(static_cast< int >(result));
26417 {
26418 if (temp2) delete arg2;
26419 }
26420 return resultobj;
26421 fail:
26422 {
26423 if (temp2) delete arg2;
26424 }
26425 return NULL;
26426 }
26427
26428
26429 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26430 PyObject *resultobj = 0;
26431 wxDateTime *arg1 = (wxDateTime *) 0 ;
26432 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26433 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26434 int result;
26435 void *argp1 = 0 ;
26436 int res1 = 0 ;
26437 bool temp2 = false ;
26438 PyObject * obj0 = 0 ;
26439 PyObject * obj1 = 0 ;
26440 char * kwnames[] = {
26441 (char *) "self",(char *) "tz", NULL
26442 };
26443
26444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26446 if (!SWIG_IsOK(res1)) {
26447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26448 }
26449 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26450 if (obj1) {
26451 {
26452 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26453 temp2 = true;
26454 }
26455 }
26456 {
26457 PyThreadState* __tstate = wxPyBeginAllowThreads();
26458 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26459 wxPyEndAllowThreads(__tstate);
26460 if (PyErr_Occurred()) SWIG_fail;
26461 }
26462 resultobj = SWIG_From_int(static_cast< int >(result));
26463 {
26464 if (temp2) delete arg2;
26465 }
26466 return resultobj;
26467 fail:
26468 {
26469 if (temp2) delete arg2;
26470 }
26471 return NULL;
26472 }
26473
26474
26475 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26476 PyObject *resultobj = 0;
26477 wxDateTime *arg1 = (wxDateTime *) 0 ;
26478 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26479 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26480 wxDateTime::WeekDay result;
26481 void *argp1 = 0 ;
26482 int res1 = 0 ;
26483 bool temp2 = false ;
26484 PyObject * obj0 = 0 ;
26485 PyObject * obj1 = 0 ;
26486 char * kwnames[] = {
26487 (char *) "self",(char *) "tz", NULL
26488 };
26489
26490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26492 if (!SWIG_IsOK(res1)) {
26493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26494 }
26495 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26496 if (obj1) {
26497 {
26498 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26499 temp2 = true;
26500 }
26501 }
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 resultobj = SWIG_From_int(static_cast< int >(result));
26509 {
26510 if (temp2) delete arg2;
26511 }
26512 return resultobj;
26513 fail:
26514 {
26515 if (temp2) delete arg2;
26516 }
26517 return NULL;
26518 }
26519
26520
26521 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26522 PyObject *resultobj = 0;
26523 wxDateTime *arg1 = (wxDateTime *) 0 ;
26524 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26525 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26526 int result;
26527 void *argp1 = 0 ;
26528 int res1 = 0 ;
26529 bool temp2 = false ;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532 char * kwnames[] = {
26533 (char *) "self",(char *) "tz", NULL
26534 };
26535
26536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26538 if (!SWIG_IsOK(res1)) {
26539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26540 }
26541 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26542 if (obj1) {
26543 {
26544 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26545 temp2 = true;
26546 }
26547 }
26548 {
26549 PyThreadState* __tstate = wxPyBeginAllowThreads();
26550 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26551 wxPyEndAllowThreads(__tstate);
26552 if (PyErr_Occurred()) SWIG_fail;
26553 }
26554 resultobj = SWIG_From_int(static_cast< int >(result));
26555 {
26556 if (temp2) delete arg2;
26557 }
26558 return resultobj;
26559 fail:
26560 {
26561 if (temp2) delete arg2;
26562 }
26563 return NULL;
26564 }
26565
26566
26567 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj = 0;
26569 wxDateTime *arg1 = (wxDateTime *) 0 ;
26570 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26571 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26572 int result;
26573 void *argp1 = 0 ;
26574 int res1 = 0 ;
26575 bool temp2 = false ;
26576 PyObject * obj0 = 0 ;
26577 PyObject * obj1 = 0 ;
26578 char * kwnames[] = {
26579 (char *) "self",(char *) "tz", NULL
26580 };
26581
26582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26584 if (!SWIG_IsOK(res1)) {
26585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26586 }
26587 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26588 if (obj1) {
26589 {
26590 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26591 temp2 = true;
26592 }
26593 }
26594 {
26595 PyThreadState* __tstate = wxPyBeginAllowThreads();
26596 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 resultobj = SWIG_From_int(static_cast< int >(result));
26601 {
26602 if (temp2) delete arg2;
26603 }
26604 return resultobj;
26605 fail:
26606 {
26607 if (temp2) delete arg2;
26608 }
26609 return NULL;
26610 }
26611
26612
26613 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26614 PyObject *resultobj = 0;
26615 wxDateTime *arg1 = (wxDateTime *) 0 ;
26616 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26617 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26618 int result;
26619 void *argp1 = 0 ;
26620 int res1 = 0 ;
26621 bool temp2 = false ;
26622 PyObject * obj0 = 0 ;
26623 PyObject * obj1 = 0 ;
26624 char * kwnames[] = {
26625 (char *) "self",(char *) "tz", NULL
26626 };
26627
26628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26630 if (!SWIG_IsOK(res1)) {
26631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26632 }
26633 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26634 if (obj1) {
26635 {
26636 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26637 temp2 = true;
26638 }
26639 }
26640 {
26641 PyThreadState* __tstate = wxPyBeginAllowThreads();
26642 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 resultobj = SWIG_From_int(static_cast< int >(result));
26647 {
26648 if (temp2) delete arg2;
26649 }
26650 return resultobj;
26651 fail:
26652 {
26653 if (temp2) delete arg2;
26654 }
26655 return NULL;
26656 }
26657
26658
26659 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj = 0;
26661 wxDateTime *arg1 = (wxDateTime *) 0 ;
26662 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26663 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26664 int result;
26665 void *argp1 = 0 ;
26666 int res1 = 0 ;
26667 bool temp2 = false ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "self",(char *) "tz", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26676 if (!SWIG_IsOK(res1)) {
26677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26678 }
26679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26680 if (obj1) {
26681 {
26682 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26683 temp2 = true;
26684 }
26685 }
26686 {
26687 PyThreadState* __tstate = wxPyBeginAllowThreads();
26688 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26689 wxPyEndAllowThreads(__tstate);
26690 if (PyErr_Occurred()) SWIG_fail;
26691 }
26692 resultobj = SWIG_From_int(static_cast< int >(result));
26693 {
26694 if (temp2) delete arg2;
26695 }
26696 return resultobj;
26697 fail:
26698 {
26699 if (temp2) delete arg2;
26700 }
26701 return NULL;
26702 }
26703
26704
26705 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26706 PyObject *resultobj = 0;
26707 wxDateTime *arg1 = (wxDateTime *) 0 ;
26708 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26709 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26710 int result;
26711 void *argp1 = 0 ;
26712 int res1 = 0 ;
26713 bool temp2 = false ;
26714 PyObject * obj0 = 0 ;
26715 PyObject * obj1 = 0 ;
26716 char * kwnames[] = {
26717 (char *) "self",(char *) "tz", NULL
26718 };
26719
26720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26722 if (!SWIG_IsOK(res1)) {
26723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26724 }
26725 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26726 if (obj1) {
26727 {
26728 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26729 temp2 = true;
26730 }
26731 }
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 resultobj = SWIG_From_int(static_cast< int >(result));
26739 {
26740 if (temp2) delete arg2;
26741 }
26742 return resultobj;
26743 fail:
26744 {
26745 if (temp2) delete arg2;
26746 }
26747 return NULL;
26748 }
26749
26750
26751 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj = 0;
26753 wxDateTime *arg1 = (wxDateTime *) 0 ;
26754 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26755 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26756 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26757 int result;
26758 void *argp1 = 0 ;
26759 int res1 = 0 ;
26760 int val2 ;
26761 int ecode2 = 0 ;
26762 bool temp3 = false ;
26763 PyObject * obj0 = 0 ;
26764 PyObject * obj1 = 0 ;
26765 PyObject * obj2 = 0 ;
26766 char * kwnames[] = {
26767 (char *) "self",(char *) "flags",(char *) "tz", NULL
26768 };
26769
26770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26772 if (!SWIG_IsOK(res1)) {
26773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26774 }
26775 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26776 if (obj1) {
26777 ecode2 = SWIG_AsVal_int(obj1, &val2);
26778 if (!SWIG_IsOK(ecode2)) {
26779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26780 }
26781 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26782 }
26783 if (obj2) {
26784 {
26785 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26786 temp3 = true;
26787 }
26788 }
26789 {
26790 PyThreadState* __tstate = wxPyBeginAllowThreads();
26791 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26792 wxPyEndAllowThreads(__tstate);
26793 if (PyErr_Occurred()) SWIG_fail;
26794 }
26795 resultobj = SWIG_From_int(static_cast< int >(result));
26796 {
26797 if (temp3) delete arg3;
26798 }
26799 return resultobj;
26800 fail:
26801 {
26802 if (temp3) delete arg3;
26803 }
26804 return NULL;
26805 }
26806
26807
26808 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj = 0;
26810 wxDateTime *arg1 = (wxDateTime *) 0 ;
26811 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26812 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26813 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26814 int result;
26815 void *argp1 = 0 ;
26816 int res1 = 0 ;
26817 int val2 ;
26818 int ecode2 = 0 ;
26819 bool temp3 = false ;
26820 PyObject * obj0 = 0 ;
26821 PyObject * obj1 = 0 ;
26822 PyObject * obj2 = 0 ;
26823 char * kwnames[] = {
26824 (char *) "self",(char *) "flags",(char *) "tz", NULL
26825 };
26826
26827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26829 if (!SWIG_IsOK(res1)) {
26830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26831 }
26832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26833 if (obj1) {
26834 ecode2 = SWIG_AsVal_int(obj1, &val2);
26835 if (!SWIG_IsOK(ecode2)) {
26836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26837 }
26838 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26839 }
26840 if (obj2) {
26841 {
26842 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26843 temp3 = true;
26844 }
26845 }
26846 {
26847 PyThreadState* __tstate = wxPyBeginAllowThreads();
26848 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26849 wxPyEndAllowThreads(__tstate);
26850 if (PyErr_Occurred()) SWIG_fail;
26851 }
26852 resultobj = SWIG_From_int(static_cast< int >(result));
26853 {
26854 if (temp3) delete arg3;
26855 }
26856 return resultobj;
26857 fail:
26858 {
26859 if (temp3) delete arg3;
26860 }
26861 return NULL;
26862 }
26863
26864
26865 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26866 PyObject *resultobj = 0;
26867 wxDateTime *arg1 = (wxDateTime *) 0 ;
26868 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26869 bool result;
26870 void *argp1 = 0 ;
26871 int res1 = 0 ;
26872 int val2 ;
26873 int ecode2 = 0 ;
26874 PyObject * obj0 = 0 ;
26875 PyObject * obj1 = 0 ;
26876 char * kwnames[] = {
26877 (char *) "self",(char *) "country", NULL
26878 };
26879
26880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26882 if (!SWIG_IsOK(res1)) {
26883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26884 }
26885 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26886 if (obj1) {
26887 ecode2 = SWIG_AsVal_int(obj1, &val2);
26888 if (!SWIG_IsOK(ecode2)) {
26889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26890 }
26891 arg2 = static_cast< wxDateTime::Country >(val2);
26892 }
26893 {
26894 PyThreadState* __tstate = wxPyBeginAllowThreads();
26895 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26896 wxPyEndAllowThreads(__tstate);
26897 if (PyErr_Occurred()) SWIG_fail;
26898 }
26899 {
26900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26901 }
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26909 PyObject *resultobj = 0;
26910 wxDateTime *arg1 = (wxDateTime *) 0 ;
26911 wxDateTime *arg2 = 0 ;
26912 bool result;
26913 void *argp1 = 0 ;
26914 int res1 = 0 ;
26915 void *argp2 = 0 ;
26916 int res2 = 0 ;
26917 PyObject * obj0 = 0 ;
26918 PyObject * obj1 = 0 ;
26919 char * kwnames[] = {
26920 (char *) "self",(char *) "datetime", NULL
26921 };
26922
26923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26925 if (!SWIG_IsOK(res1)) {
26926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26927 }
26928 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26929 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26930 if (!SWIG_IsOK(res2)) {
26931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26932 }
26933 if (!argp2) {
26934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26935 }
26936 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26937 {
26938 PyThreadState* __tstate = wxPyBeginAllowThreads();
26939 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26940 wxPyEndAllowThreads(__tstate);
26941 if (PyErr_Occurred()) SWIG_fail;
26942 }
26943 {
26944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26945 }
26946 return resultobj;
26947 fail:
26948 return NULL;
26949 }
26950
26951
26952 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26953 PyObject *resultobj = 0;
26954 wxDateTime *arg1 = (wxDateTime *) 0 ;
26955 wxDateTime *arg2 = 0 ;
26956 bool result;
26957 void *argp1 = 0 ;
26958 int res1 = 0 ;
26959 void *argp2 = 0 ;
26960 int res2 = 0 ;
26961 PyObject * obj0 = 0 ;
26962 PyObject * obj1 = 0 ;
26963 char * kwnames[] = {
26964 (char *) "self",(char *) "datetime", NULL
26965 };
26966
26967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26969 if (!SWIG_IsOK(res1)) {
26970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26971 }
26972 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26973 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26974 if (!SWIG_IsOK(res2)) {
26975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26976 }
26977 if (!argp2) {
26978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26979 }
26980 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 {
26988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26989 }
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26997 PyObject *resultobj = 0;
26998 wxDateTime *arg1 = (wxDateTime *) 0 ;
26999 wxDateTime *arg2 = 0 ;
27000 bool result;
27001 void *argp1 = 0 ;
27002 int res1 = 0 ;
27003 void *argp2 = 0 ;
27004 int res2 = 0 ;
27005 PyObject * obj0 = 0 ;
27006 PyObject * obj1 = 0 ;
27007 char * kwnames[] = {
27008 (char *) "self",(char *) "datetime", NULL
27009 };
27010
27011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
27012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27013 if (!SWIG_IsOK(res1)) {
27014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27015 }
27016 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27017 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27018 if (!SWIG_IsOK(res2)) {
27019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27020 }
27021 if (!argp2) {
27022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27023 }
27024 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27025 {
27026 PyThreadState* __tstate = wxPyBeginAllowThreads();
27027 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
27028 wxPyEndAllowThreads(__tstate);
27029 if (PyErr_Occurred()) SWIG_fail;
27030 }
27031 {
27032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27033 }
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27041 PyObject *resultobj = 0;
27042 wxDateTime *arg1 = (wxDateTime *) 0 ;
27043 wxDateTime *arg2 = 0 ;
27044 wxDateTime *arg3 = 0 ;
27045 bool result;
27046 void *argp1 = 0 ;
27047 int res1 = 0 ;
27048 void *argp2 = 0 ;
27049 int res2 = 0 ;
27050 void *argp3 = 0 ;
27051 int res3 = 0 ;
27052 PyObject * obj0 = 0 ;
27053 PyObject * obj1 = 0 ;
27054 PyObject * obj2 = 0 ;
27055 char * kwnames[] = {
27056 (char *) "self",(char *) "t1",(char *) "t2", NULL
27057 };
27058
27059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27061 if (!SWIG_IsOK(res1)) {
27062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27063 }
27064 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27065 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27066 if (!SWIG_IsOK(res2)) {
27067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27068 }
27069 if (!argp2) {
27070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27071 }
27072 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27073 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27074 if (!SWIG_IsOK(res3)) {
27075 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27076 }
27077 if (!argp3) {
27078 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27079 }
27080 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27081 {
27082 PyThreadState* __tstate = wxPyBeginAllowThreads();
27083 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27084 wxPyEndAllowThreads(__tstate);
27085 if (PyErr_Occurred()) SWIG_fail;
27086 }
27087 {
27088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27089 }
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj = 0;
27098 wxDateTime *arg1 = (wxDateTime *) 0 ;
27099 wxDateTime *arg2 = 0 ;
27100 wxDateTime *arg3 = 0 ;
27101 bool result;
27102 void *argp1 = 0 ;
27103 int res1 = 0 ;
27104 void *argp2 = 0 ;
27105 int res2 = 0 ;
27106 void *argp3 = 0 ;
27107 int res3 = 0 ;
27108 PyObject * obj0 = 0 ;
27109 PyObject * obj1 = 0 ;
27110 PyObject * obj2 = 0 ;
27111 char * kwnames[] = {
27112 (char *) "self",(char *) "t1",(char *) "t2", NULL
27113 };
27114
27115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27117 if (!SWIG_IsOK(res1)) {
27118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27119 }
27120 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27121 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27122 if (!SWIG_IsOK(res2)) {
27123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27124 }
27125 if (!argp2) {
27126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27127 }
27128 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27129 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27130 if (!SWIG_IsOK(res3)) {
27131 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27132 }
27133 if (!argp3) {
27134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27135 }
27136 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27137 {
27138 PyThreadState* __tstate = wxPyBeginAllowThreads();
27139 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj = 0;
27154 wxDateTime *arg1 = (wxDateTime *) 0 ;
27155 wxDateTime *arg2 = 0 ;
27156 bool result;
27157 void *argp1 = 0 ;
27158 int res1 = 0 ;
27159 void *argp2 = 0 ;
27160 int res2 = 0 ;
27161 PyObject * obj0 = 0 ;
27162 PyObject * obj1 = 0 ;
27163 char * kwnames[] = {
27164 (char *) "self",(char *) "dt", NULL
27165 };
27166
27167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27169 if (!SWIG_IsOK(res1)) {
27170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27171 }
27172 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27174 if (!SWIG_IsOK(res2)) {
27175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27176 }
27177 if (!argp2) {
27178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27179 }
27180 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 {
27188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27189 }
27190 return resultobj;
27191 fail:
27192 return NULL;
27193 }
27194
27195
27196 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27197 PyObject *resultobj = 0;
27198 wxDateTime *arg1 = (wxDateTime *) 0 ;
27199 wxDateTime *arg2 = 0 ;
27200 bool result;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 void *argp2 = 0 ;
27204 int res2 = 0 ;
27205 PyObject * obj0 = 0 ;
27206 PyObject * obj1 = 0 ;
27207 char * kwnames[] = {
27208 (char *) "self",(char *) "dt", NULL
27209 };
27210
27211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27213 if (!SWIG_IsOK(res1)) {
27214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27215 }
27216 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27217 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27218 if (!SWIG_IsOK(res2)) {
27219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27220 }
27221 if (!argp2) {
27222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27223 }
27224 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 {
27232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj = 0;
27242 wxDateTime *arg1 = (wxDateTime *) 0 ;
27243 wxDateTime *arg2 = 0 ;
27244 wxTimeSpan *arg3 = 0 ;
27245 bool result;
27246 void *argp1 = 0 ;
27247 int res1 = 0 ;
27248 void *argp2 = 0 ;
27249 int res2 = 0 ;
27250 void *argp3 = 0 ;
27251 int res3 = 0 ;
27252 PyObject * obj0 = 0 ;
27253 PyObject * obj1 = 0 ;
27254 PyObject * obj2 = 0 ;
27255 char * kwnames[] = {
27256 (char *) "self",(char *) "dt",(char *) "ts", NULL
27257 };
27258
27259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27261 if (!SWIG_IsOK(res1)) {
27262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27263 }
27264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27265 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27266 if (!SWIG_IsOK(res2)) {
27267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27268 }
27269 if (!argp2) {
27270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27271 }
27272 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27273 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27274 if (!SWIG_IsOK(res3)) {
27275 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27276 }
27277 if (!argp3) {
27278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27279 }
27280 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27281 {
27282 PyThreadState* __tstate = wxPyBeginAllowThreads();
27283 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 {
27288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27289 }
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27297 PyObject *resultobj = 0;
27298 wxDateTime *arg1 = (wxDateTime *) 0 ;
27299 wxTimeSpan *arg2 = 0 ;
27300 wxDateTime *result = 0 ;
27301 void *argp1 = 0 ;
27302 int res1 = 0 ;
27303 void *argp2 = 0 ;
27304 int res2 = 0 ;
27305 PyObject * obj0 = 0 ;
27306 PyObject * obj1 = 0 ;
27307 char * kwnames[] = {
27308 (char *) "self",(char *) "diff", NULL
27309 };
27310
27311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27313 if (!SWIG_IsOK(res1)) {
27314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27315 }
27316 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27317 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27318 if (!SWIG_IsOK(res2)) {
27319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27320 }
27321 if (!argp2) {
27322 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27323 }
27324 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27325 {
27326 PyThreadState* __tstate = wxPyBeginAllowThreads();
27327 {
27328 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27329 result = (wxDateTime *) &_result_ref;
27330 }
27331 wxPyEndAllowThreads(__tstate);
27332 if (PyErr_Occurred()) SWIG_fail;
27333 }
27334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27335 return resultobj;
27336 fail:
27337 return NULL;
27338 }
27339
27340
27341 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27342 PyObject *resultobj = 0;
27343 wxDateTime *arg1 = (wxDateTime *) 0 ;
27344 wxDateSpan *arg2 = 0 ;
27345 wxDateTime *result = 0 ;
27346 void *argp1 = 0 ;
27347 int res1 = 0 ;
27348 void *argp2 = 0 ;
27349 int res2 = 0 ;
27350 PyObject * obj0 = 0 ;
27351 PyObject * obj1 = 0 ;
27352 char * kwnames[] = {
27353 (char *) "self",(char *) "diff", NULL
27354 };
27355
27356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27358 if (!SWIG_IsOK(res1)) {
27359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27360 }
27361 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27362 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27363 if (!SWIG_IsOK(res2)) {
27364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27365 }
27366 if (!argp2) {
27367 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27368 }
27369 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27370 {
27371 PyThreadState* __tstate = wxPyBeginAllowThreads();
27372 {
27373 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27374 result = (wxDateTime *) &_result_ref;
27375 }
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27380 return resultobj;
27381 fail:
27382 return NULL;
27383 }
27384
27385
27386 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27387 PyObject *resultobj = 0;
27388 wxDateTime *arg1 = (wxDateTime *) 0 ;
27389 wxTimeSpan *arg2 = 0 ;
27390 wxDateTime *result = 0 ;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 void *argp2 = 0 ;
27394 int res2 = 0 ;
27395 PyObject * obj0 = 0 ;
27396 PyObject * obj1 = 0 ;
27397 char * kwnames[] = {
27398 (char *) "self",(char *) "diff", NULL
27399 };
27400
27401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27403 if (!SWIG_IsOK(res1)) {
27404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27405 }
27406 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27407 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27408 if (!SWIG_IsOK(res2)) {
27409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27410 }
27411 if (!argp2) {
27412 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27413 }
27414 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27415 {
27416 PyThreadState* __tstate = wxPyBeginAllowThreads();
27417 {
27418 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27419 result = (wxDateTime *) &_result_ref;
27420 }
27421 wxPyEndAllowThreads(__tstate);
27422 if (PyErr_Occurred()) SWIG_fail;
27423 }
27424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27425 return resultobj;
27426 fail:
27427 return NULL;
27428 }
27429
27430
27431 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27432 PyObject *resultobj = 0;
27433 wxDateTime *arg1 = (wxDateTime *) 0 ;
27434 wxDateSpan *arg2 = 0 ;
27435 wxDateTime *result = 0 ;
27436 void *argp1 = 0 ;
27437 int res1 = 0 ;
27438 void *argp2 = 0 ;
27439 int res2 = 0 ;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 char * kwnames[] = {
27443 (char *) "self",(char *) "diff", NULL
27444 };
27445
27446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27450 }
27451 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27452 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27453 if (!SWIG_IsOK(res2)) {
27454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27455 }
27456 if (!argp2) {
27457 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27458 }
27459 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 {
27463 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27464 result = (wxDateTime *) &_result_ref;
27465 }
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27477 PyObject *resultobj = 0;
27478 wxDateTime *arg1 = (wxDateTime *) 0 ;
27479 wxDateTime *arg2 = 0 ;
27480 wxTimeSpan result;
27481 void *argp1 = 0 ;
27482 int res1 = 0 ;
27483 void *argp2 = 0 ;
27484 int res2 = 0 ;
27485 PyObject * obj0 = 0 ;
27486 PyObject * obj1 = 0 ;
27487 char * kwnames[] = {
27488 (char *) "self",(char *) "dt", NULL
27489 };
27490
27491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27493 if (!SWIG_IsOK(res1)) {
27494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27495 }
27496 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27497 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27498 if (!SWIG_IsOK(res2)) {
27499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27500 }
27501 if (!argp2) {
27502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27503 }
27504 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27519 PyObject *resultobj = 0;
27520 wxDateTime *arg1 = (wxDateTime *) 0 ;
27521 wxTimeSpan *arg2 = 0 ;
27522 wxDateTime *result = 0 ;
27523 void *argp1 = 0 ;
27524 int res1 = 0 ;
27525 void *argp2 = 0 ;
27526 int res2 = 0 ;
27527
27528 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27530 if (!SWIG_IsOK(res1)) {
27531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27532 }
27533 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27534 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27535 if (!SWIG_IsOK(res2)) {
27536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27537 }
27538 if (!argp2) {
27539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27540 }
27541 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27542 {
27543 PyThreadState* __tstate = wxPyBeginAllowThreads();
27544 {
27545 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27546 result = (wxDateTime *) &_result_ref;
27547 }
27548 wxPyEndAllowThreads(__tstate);
27549 if (PyErr_Occurred()) SWIG_fail;
27550 }
27551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27559 PyObject *resultobj = 0;
27560 wxDateTime *arg1 = (wxDateTime *) 0 ;
27561 wxDateSpan *arg2 = 0 ;
27562 wxDateTime *result = 0 ;
27563 void *argp1 = 0 ;
27564 int res1 = 0 ;
27565 void *argp2 = 0 ;
27566 int res2 = 0 ;
27567
27568 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27572 }
27573 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27574 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27575 if (!SWIG_IsOK(res2)) {
27576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27577 }
27578 if (!argp2) {
27579 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27580 }
27581 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 {
27585 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27586 result = (wxDateTime *) &_result_ref;
27587 }
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27592 return resultobj;
27593 fail:
27594 return NULL;
27595 }
27596
27597
27598 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27599 int argc;
27600 PyObject *argv[3];
27601
27602 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27603 --argc;
27604 if (argc == 2) {
27605 int _v = 0;
27606 {
27607 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27608 _v = SWIG_CheckState(res);
27609 }
27610 if (!_v) goto check_1;
27611 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27612 }
27613 check_1:
27614
27615 if (argc == 2) {
27616 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27617 }
27618
27619 fail:
27620 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27621 return NULL;
27622 }
27623
27624
27625 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27626 PyObject *resultobj = 0;
27627 wxDateTime *arg1 = (wxDateTime *) 0 ;
27628 wxTimeSpan *arg2 = 0 ;
27629 wxDateTime *result = 0 ;
27630 void *argp1 = 0 ;
27631 int res1 = 0 ;
27632 void *argp2 = 0 ;
27633 int res2 = 0 ;
27634
27635 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27637 if (!SWIG_IsOK(res1)) {
27638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27639 }
27640 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27641 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27642 if (!SWIG_IsOK(res2)) {
27643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27644 }
27645 if (!argp2) {
27646 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27647 }
27648 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 {
27652 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27653 result = (wxDateTime *) &_result_ref;
27654 }
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27666 PyObject *resultobj = 0;
27667 wxDateTime *arg1 = (wxDateTime *) 0 ;
27668 wxDateSpan *arg2 = 0 ;
27669 wxDateTime *result = 0 ;
27670 void *argp1 = 0 ;
27671 int res1 = 0 ;
27672 void *argp2 = 0 ;
27673 int res2 = 0 ;
27674
27675 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27677 if (!SWIG_IsOK(res1)) {
27678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27679 }
27680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27681 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27682 if (!SWIG_IsOK(res2)) {
27683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27684 }
27685 if (!argp2) {
27686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27687 }
27688 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27689 {
27690 PyThreadState* __tstate = wxPyBeginAllowThreads();
27691 {
27692 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27693 result = (wxDateTime *) &_result_ref;
27694 }
27695 wxPyEndAllowThreads(__tstate);
27696 if (PyErr_Occurred()) SWIG_fail;
27697 }
27698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27699 return resultobj;
27700 fail:
27701 return NULL;
27702 }
27703
27704
27705 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27706 int argc;
27707 PyObject *argv[3];
27708
27709 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27710 --argc;
27711 if (argc == 2) {
27712 int _v = 0;
27713 {
27714 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27715 _v = SWIG_CheckState(res);
27716 }
27717 if (!_v) goto check_1;
27718 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27719 }
27720 check_1:
27721
27722 if (argc == 2) {
27723 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27724 }
27725
27726 fail:
27727 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27728 return NULL;
27729 }
27730
27731
27732 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27733 PyObject *resultobj = 0;
27734 wxDateTime *arg1 = (wxDateTime *) 0 ;
27735 wxTimeSpan *arg2 = 0 ;
27736 wxDateTime result;
27737 void *argp1 = 0 ;
27738 int res1 = 0 ;
27739 void *argp2 = 0 ;
27740 int res2 = 0 ;
27741
27742 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27744 if (!SWIG_IsOK(res1)) {
27745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27746 }
27747 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27748 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27749 if (!SWIG_IsOK(res2)) {
27750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27751 }
27752 if (!argp2) {
27753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27754 }
27755 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27770 PyObject *resultobj = 0;
27771 wxDateTime *arg1 = (wxDateTime *) 0 ;
27772 wxDateSpan *arg2 = 0 ;
27773 wxDateTime result;
27774 void *argp1 = 0 ;
27775 int res1 = 0 ;
27776 void *argp2 = 0 ;
27777 int res2 = 0 ;
27778
27779 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27781 if (!SWIG_IsOK(res1)) {
27782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27783 }
27784 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27785 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27786 if (!SWIG_IsOK(res2)) {
27787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27788 }
27789 if (!argp2) {
27790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27791 }
27792 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27796 wxPyEndAllowThreads(__tstate);
27797 if (PyErr_Occurred()) SWIG_fail;
27798 }
27799 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27800 return resultobj;
27801 fail:
27802 return NULL;
27803 }
27804
27805
27806 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27807 int argc;
27808 PyObject *argv[3];
27809
27810 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27811 --argc;
27812 if (argc == 2) {
27813 int _v = 0;
27814 {
27815 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27816 _v = SWIG_CheckState(res);
27817 }
27818 if (!_v) goto check_1;
27819 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27820 }
27821 check_1:
27822
27823 if (argc == 2) {
27824 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27825 }
27826
27827 fail:
27828 Py_INCREF(Py_NotImplemented);
27829 return Py_NotImplemented;
27830 }
27831
27832
27833 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27834 PyObject *resultobj = 0;
27835 wxDateTime *arg1 = (wxDateTime *) 0 ;
27836 wxDateTime *arg2 = 0 ;
27837 wxTimeSpan result;
27838 void *argp1 = 0 ;
27839 int res1 = 0 ;
27840 void *argp2 = 0 ;
27841 int res2 = 0 ;
27842
27843 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27845 if (!SWIG_IsOK(res1)) {
27846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27847 }
27848 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27849 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27850 if (!SWIG_IsOK(res2)) {
27851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27852 }
27853 if (!argp2) {
27854 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27855 }
27856 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27857 {
27858 PyThreadState* __tstate = wxPyBeginAllowThreads();
27859 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27860 wxPyEndAllowThreads(__tstate);
27861 if (PyErr_Occurred()) SWIG_fail;
27862 }
27863 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27864 return resultobj;
27865 fail:
27866 return NULL;
27867 }
27868
27869
27870 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27871 PyObject *resultobj = 0;
27872 wxDateTime *arg1 = (wxDateTime *) 0 ;
27873 wxTimeSpan *arg2 = 0 ;
27874 wxDateTime result;
27875 void *argp1 = 0 ;
27876 int res1 = 0 ;
27877 void *argp2 = 0 ;
27878 int res2 = 0 ;
27879
27880 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27882 if (!SWIG_IsOK(res1)) {
27883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27884 }
27885 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27886 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27887 if (!SWIG_IsOK(res2)) {
27888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27889 }
27890 if (!argp2) {
27891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27892 }
27893 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27894 {
27895 PyThreadState* __tstate = wxPyBeginAllowThreads();
27896 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27908 PyObject *resultobj = 0;
27909 wxDateTime *arg1 = (wxDateTime *) 0 ;
27910 wxDateSpan *arg2 = 0 ;
27911 wxDateTime result;
27912 void *argp1 = 0 ;
27913 int res1 = 0 ;
27914 void *argp2 = 0 ;
27915 int res2 = 0 ;
27916
27917 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27919 if (!SWIG_IsOK(res1)) {
27920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27921 }
27922 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27923 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27924 if (!SWIG_IsOK(res2)) {
27925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27926 }
27927 if (!argp2) {
27928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27929 }
27930 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27945 int argc;
27946 PyObject *argv[3];
27947
27948 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27949 --argc;
27950 if (argc == 2) {
27951 int _v = 0;
27952 {
27953 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27954 _v = SWIG_CheckState(res);
27955 }
27956 if (!_v) goto check_1;
27957 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27958 }
27959 check_1:
27960
27961 if (argc == 2) {
27962 int _v = 0;
27963 {
27964 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27965 _v = SWIG_CheckState(res);
27966 }
27967 if (!_v) goto check_2;
27968 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27969 }
27970 check_2:
27971
27972 if (argc == 2) {
27973 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27974 }
27975
27976 fail:
27977 Py_INCREF(Py_NotImplemented);
27978 return Py_NotImplemented;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27983 PyObject *resultobj = 0;
27984 wxDateTime *arg1 = (wxDateTime *) 0 ;
27985 wxDateTime *arg2 = (wxDateTime *) 0 ;
27986 bool result;
27987 void *argp1 = 0 ;
27988 int res1 = 0 ;
27989 void *argp2 = 0 ;
27990 int res2 = 0 ;
27991 PyObject * obj0 = 0 ;
27992 PyObject * obj1 = 0 ;
27993 char * kwnames[] = {
27994 (char *) "self",(char *) "other", NULL
27995 };
27996
27997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27999 if (!SWIG_IsOK(res1)) {
28000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28001 }
28002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28004 if (!SWIG_IsOK(res2)) {
28005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28006 }
28007 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 {
28015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28016 }
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28024 PyObject *resultobj = 0;
28025 wxDateTime *arg1 = (wxDateTime *) 0 ;
28026 wxDateTime *arg2 = (wxDateTime *) 0 ;
28027 bool result;
28028 void *argp1 = 0 ;
28029 int res1 = 0 ;
28030 void *argp2 = 0 ;
28031 int res2 = 0 ;
28032 PyObject * obj0 = 0 ;
28033 PyObject * obj1 = 0 ;
28034 char * kwnames[] = {
28035 (char *) "self",(char *) "other", NULL
28036 };
28037
28038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28040 if (!SWIG_IsOK(res1)) {
28041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28042 }
28043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28044 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28045 if (!SWIG_IsOK(res2)) {
28046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28047 }
28048 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28049 {
28050 PyThreadState* __tstate = wxPyBeginAllowThreads();
28051 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28052 wxPyEndAllowThreads(__tstate);
28053 if (PyErr_Occurred()) SWIG_fail;
28054 }
28055 {
28056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28057 }
28058 return resultobj;
28059 fail:
28060 return NULL;
28061 }
28062
28063
28064 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28065 PyObject *resultobj = 0;
28066 wxDateTime *arg1 = (wxDateTime *) 0 ;
28067 wxDateTime *arg2 = (wxDateTime *) 0 ;
28068 bool result;
28069 void *argp1 = 0 ;
28070 int res1 = 0 ;
28071 void *argp2 = 0 ;
28072 int res2 = 0 ;
28073 PyObject * obj0 = 0 ;
28074 PyObject * obj1 = 0 ;
28075 char * kwnames[] = {
28076 (char *) "self",(char *) "other", NULL
28077 };
28078
28079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28081 if (!SWIG_IsOK(res1)) {
28082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28083 }
28084 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28086 if (!SWIG_IsOK(res2)) {
28087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28088 }
28089 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 {
28097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28098 }
28099 return resultobj;
28100 fail:
28101 return NULL;
28102 }
28103
28104
28105 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28106 PyObject *resultobj = 0;
28107 wxDateTime *arg1 = (wxDateTime *) 0 ;
28108 wxDateTime *arg2 = (wxDateTime *) 0 ;
28109 bool result;
28110 void *argp1 = 0 ;
28111 int res1 = 0 ;
28112 void *argp2 = 0 ;
28113 int res2 = 0 ;
28114 PyObject * obj0 = 0 ;
28115 PyObject * obj1 = 0 ;
28116 char * kwnames[] = {
28117 (char *) "self",(char *) "other", NULL
28118 };
28119
28120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28122 if (!SWIG_IsOK(res1)) {
28123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28124 }
28125 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28127 if (!SWIG_IsOK(res2)) {
28128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28129 }
28130 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 {
28138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28139 }
28140 return resultobj;
28141 fail:
28142 return NULL;
28143 }
28144
28145
28146 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28147 PyObject *resultobj = 0;
28148 wxDateTime *arg1 = (wxDateTime *) 0 ;
28149 wxDateTime *arg2 = (wxDateTime *) 0 ;
28150 bool result;
28151 void *argp1 = 0 ;
28152 int res1 = 0 ;
28153 void *argp2 = 0 ;
28154 int res2 = 0 ;
28155 PyObject * obj0 = 0 ;
28156 PyObject * obj1 = 0 ;
28157 char * kwnames[] = {
28158 (char *) "self",(char *) "other", NULL
28159 };
28160
28161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28163 if (!SWIG_IsOK(res1)) {
28164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28165 }
28166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28168 if (!SWIG_IsOK(res2)) {
28169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28170 }
28171 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28172 {
28173 PyThreadState* __tstate = wxPyBeginAllowThreads();
28174 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 {
28179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28180 }
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28188 PyObject *resultobj = 0;
28189 wxDateTime *arg1 = (wxDateTime *) 0 ;
28190 wxDateTime *arg2 = (wxDateTime *) 0 ;
28191 bool result;
28192 void *argp1 = 0 ;
28193 int res1 = 0 ;
28194 void *argp2 = 0 ;
28195 int res2 = 0 ;
28196 PyObject * obj0 = 0 ;
28197 PyObject * obj1 = 0 ;
28198 char * kwnames[] = {
28199 (char *) "self",(char *) "other", NULL
28200 };
28201
28202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28204 if (!SWIG_IsOK(res1)) {
28205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28206 }
28207 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28208 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28209 if (!SWIG_IsOK(res2)) {
28210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28211 }
28212 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28213 {
28214 PyThreadState* __tstate = wxPyBeginAllowThreads();
28215 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28216 wxPyEndAllowThreads(__tstate);
28217 if (PyErr_Occurred()) SWIG_fail;
28218 }
28219 {
28220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28221 }
28222 return resultobj;
28223 fail:
28224 return NULL;
28225 }
28226
28227
28228 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28229 PyObject *resultobj = 0;
28230 wxDateTime *arg1 = (wxDateTime *) 0 ;
28231 wxString *arg2 = 0 ;
28232 int result;
28233 void *argp1 = 0 ;
28234 int res1 = 0 ;
28235 bool temp2 = false ;
28236 PyObject * obj0 = 0 ;
28237 PyObject * obj1 = 0 ;
28238 char * kwnames[] = {
28239 (char *) "self",(char *) "date", NULL
28240 };
28241
28242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28244 if (!SWIG_IsOK(res1)) {
28245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28246 }
28247 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28248 {
28249 arg2 = wxString_in_helper(obj1);
28250 if (arg2 == NULL) SWIG_fail;
28251 temp2 = true;
28252 }
28253 {
28254 PyThreadState* __tstate = wxPyBeginAllowThreads();
28255 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28256 wxPyEndAllowThreads(__tstate);
28257 if (PyErr_Occurred()) SWIG_fail;
28258 }
28259 resultobj = SWIG_From_int(static_cast< int >(result));
28260 {
28261 if (temp2)
28262 delete arg2;
28263 }
28264 return resultobj;
28265 fail:
28266 {
28267 if (temp2)
28268 delete arg2;
28269 }
28270 return NULL;
28271 }
28272
28273
28274 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj = 0;
28276 wxDateTime *arg1 = (wxDateTime *) 0 ;
28277 wxString *arg2 = 0 ;
28278 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28279 wxString *arg3 = (wxString *) &arg3_defvalue ;
28280 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28281 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28282 int result;
28283 void *argp1 = 0 ;
28284 int res1 = 0 ;
28285 bool temp2 = false ;
28286 bool temp3 = false ;
28287 void *argp4 = 0 ;
28288 int res4 = 0 ;
28289 PyObject * obj0 = 0 ;
28290 PyObject * obj1 = 0 ;
28291 PyObject * obj2 = 0 ;
28292 PyObject * obj3 = 0 ;
28293 char * kwnames[] = {
28294 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28295 };
28296
28297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28299 if (!SWIG_IsOK(res1)) {
28300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28301 }
28302 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28303 {
28304 arg2 = wxString_in_helper(obj1);
28305 if (arg2 == NULL) SWIG_fail;
28306 temp2 = true;
28307 }
28308 if (obj2) {
28309 {
28310 arg3 = wxString_in_helper(obj2);
28311 if (arg3 == NULL) SWIG_fail;
28312 temp3 = true;
28313 }
28314 }
28315 if (obj3) {
28316 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28317 if (!SWIG_IsOK(res4)) {
28318 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28319 }
28320 if (!argp4) {
28321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28322 }
28323 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28324 }
28325 {
28326 PyThreadState* __tstate = wxPyBeginAllowThreads();
28327 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 resultobj = SWIG_From_int(static_cast< int >(result));
28332 {
28333 if (temp2)
28334 delete arg2;
28335 }
28336 {
28337 if (temp3)
28338 delete arg3;
28339 }
28340 return resultobj;
28341 fail:
28342 {
28343 if (temp2)
28344 delete arg2;
28345 }
28346 {
28347 if (temp3)
28348 delete arg3;
28349 }
28350 return NULL;
28351 }
28352
28353
28354 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28355 PyObject *resultobj = 0;
28356 wxDateTime *arg1 = (wxDateTime *) 0 ;
28357 wxString *arg2 = 0 ;
28358 int result;
28359 void *argp1 = 0 ;
28360 int res1 = 0 ;
28361 bool temp2 = false ;
28362 PyObject * obj0 = 0 ;
28363 PyObject * obj1 = 0 ;
28364 char * kwnames[] = {
28365 (char *) "self",(char *) "datetime", NULL
28366 };
28367
28368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28370 if (!SWIG_IsOK(res1)) {
28371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28372 }
28373 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28374 {
28375 arg2 = wxString_in_helper(obj1);
28376 if (arg2 == NULL) SWIG_fail;
28377 temp2 = true;
28378 }
28379 {
28380 PyThreadState* __tstate = wxPyBeginAllowThreads();
28381 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28382 wxPyEndAllowThreads(__tstate);
28383 if (PyErr_Occurred()) SWIG_fail;
28384 }
28385 resultobj = SWIG_From_int(static_cast< int >(result));
28386 {
28387 if (temp2)
28388 delete arg2;
28389 }
28390 return resultobj;
28391 fail:
28392 {
28393 if (temp2)
28394 delete arg2;
28395 }
28396 return NULL;
28397 }
28398
28399
28400 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28401 PyObject *resultobj = 0;
28402 wxDateTime *arg1 = (wxDateTime *) 0 ;
28403 wxString *arg2 = 0 ;
28404 int result;
28405 void *argp1 = 0 ;
28406 int res1 = 0 ;
28407 bool temp2 = false ;
28408 PyObject * obj0 = 0 ;
28409 PyObject * obj1 = 0 ;
28410 char * kwnames[] = {
28411 (char *) "self",(char *) "date", NULL
28412 };
28413
28414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28416 if (!SWIG_IsOK(res1)) {
28417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28418 }
28419 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28420 {
28421 arg2 = wxString_in_helper(obj1);
28422 if (arg2 == NULL) SWIG_fail;
28423 temp2 = true;
28424 }
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 resultobj = SWIG_From_int(static_cast< int >(result));
28432 {
28433 if (temp2)
28434 delete arg2;
28435 }
28436 return resultobj;
28437 fail:
28438 {
28439 if (temp2)
28440 delete arg2;
28441 }
28442 return NULL;
28443 }
28444
28445
28446 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj = 0;
28448 wxDateTime *arg1 = (wxDateTime *) 0 ;
28449 wxString *arg2 = 0 ;
28450 int result;
28451 void *argp1 = 0 ;
28452 int res1 = 0 ;
28453 bool temp2 = false ;
28454 PyObject * obj0 = 0 ;
28455 PyObject * obj1 = 0 ;
28456 char * kwnames[] = {
28457 (char *) "self",(char *) "time", NULL
28458 };
28459
28460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28462 if (!SWIG_IsOK(res1)) {
28463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28464 }
28465 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28466 {
28467 arg2 = wxString_in_helper(obj1);
28468 if (arg2 == NULL) SWIG_fail;
28469 temp2 = true;
28470 }
28471 {
28472 PyThreadState* __tstate = wxPyBeginAllowThreads();
28473 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 resultobj = SWIG_From_int(static_cast< int >(result));
28478 {
28479 if (temp2)
28480 delete arg2;
28481 }
28482 return resultobj;
28483 fail:
28484 {
28485 if (temp2)
28486 delete arg2;
28487 }
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28493 PyObject *resultobj = 0;
28494 wxDateTime *arg1 = (wxDateTime *) 0 ;
28495 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28496 wxString *arg2 = (wxString *) &arg2_defvalue ;
28497 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28498 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28499 wxString result;
28500 void *argp1 = 0 ;
28501 int res1 = 0 ;
28502 bool temp2 = false ;
28503 bool temp3 = false ;
28504 PyObject * obj0 = 0 ;
28505 PyObject * obj1 = 0 ;
28506 PyObject * obj2 = 0 ;
28507 char * kwnames[] = {
28508 (char *) "self",(char *) "format",(char *) "tz", NULL
28509 };
28510
28511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28513 if (!SWIG_IsOK(res1)) {
28514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28515 }
28516 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28517 if (obj1) {
28518 {
28519 arg2 = wxString_in_helper(obj1);
28520 if (arg2 == NULL) SWIG_fail;
28521 temp2 = true;
28522 }
28523 }
28524 if (obj2) {
28525 {
28526 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28527 temp3 = true;
28528 }
28529 }
28530 {
28531 PyThreadState* __tstate = wxPyBeginAllowThreads();
28532 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28533 wxPyEndAllowThreads(__tstate);
28534 if (PyErr_Occurred()) SWIG_fail;
28535 }
28536 {
28537 #if wxUSE_UNICODE
28538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28539 #else
28540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28541 #endif
28542 }
28543 {
28544 if (temp2)
28545 delete arg2;
28546 }
28547 {
28548 if (temp3) delete arg3;
28549 }
28550 return resultobj;
28551 fail:
28552 {
28553 if (temp2)
28554 delete arg2;
28555 }
28556 {
28557 if (temp3) delete arg3;
28558 }
28559 return NULL;
28560 }
28561
28562
28563 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28564 PyObject *resultobj = 0;
28565 wxDateTime *arg1 = (wxDateTime *) 0 ;
28566 wxString result;
28567 void *argp1 = 0 ;
28568 int res1 = 0 ;
28569 PyObject *swig_obj[1] ;
28570
28571 if (!args) SWIG_fail;
28572 swig_obj[0] = args;
28573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28574 if (!SWIG_IsOK(res1)) {
28575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28576 }
28577 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 result = ((wxDateTime const *)arg1)->FormatDate();
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 {
28585 #if wxUSE_UNICODE
28586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28587 #else
28588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28589 #endif
28590 }
28591 return resultobj;
28592 fail:
28593 return NULL;
28594 }
28595
28596
28597 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28598 PyObject *resultobj = 0;
28599 wxDateTime *arg1 = (wxDateTime *) 0 ;
28600 wxString result;
28601 void *argp1 = 0 ;
28602 int res1 = 0 ;
28603 PyObject *swig_obj[1] ;
28604
28605 if (!args) SWIG_fail;
28606 swig_obj[0] = args;
28607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28608 if (!SWIG_IsOK(res1)) {
28609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28610 }
28611 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 result = ((wxDateTime const *)arg1)->FormatTime();
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 {
28619 #if wxUSE_UNICODE
28620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28621 #else
28622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28623 #endif
28624 }
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *resultobj = 0;
28633 wxDateTime *arg1 = (wxDateTime *) 0 ;
28634 wxString result;
28635 void *argp1 = 0 ;
28636 int res1 = 0 ;
28637 PyObject *swig_obj[1] ;
28638
28639 if (!args) SWIG_fail;
28640 swig_obj[0] = args;
28641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28642 if (!SWIG_IsOK(res1)) {
28643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28644 }
28645 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28646 {
28647 PyThreadState* __tstate = wxPyBeginAllowThreads();
28648 result = ((wxDateTime const *)arg1)->FormatISODate();
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 {
28653 #if wxUSE_UNICODE
28654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28655 #else
28656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28657 #endif
28658 }
28659 return resultobj;
28660 fail:
28661 return NULL;
28662 }
28663
28664
28665 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28666 PyObject *resultobj = 0;
28667 wxDateTime *arg1 = (wxDateTime *) 0 ;
28668 wxString result;
28669 void *argp1 = 0 ;
28670 int res1 = 0 ;
28671 PyObject *swig_obj[1] ;
28672
28673 if (!args) SWIG_fail;
28674 swig_obj[0] = args;
28675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28676 if (!SWIG_IsOK(res1)) {
28677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28678 }
28679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28680 {
28681 PyThreadState* __tstate = wxPyBeginAllowThreads();
28682 result = ((wxDateTime const *)arg1)->FormatISOTime();
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 {
28687 #if wxUSE_UNICODE
28688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28689 #else
28690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28691 #endif
28692 }
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *obj;
28701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28702 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28703 return SWIG_Py_Void();
28704 }
28705
28706 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28707 return SWIG_Python_InitShadowInstance(args);
28708 }
28709
28710 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj = 0;
28712 long arg1 ;
28713 wxTimeSpan result;
28714 long val1 ;
28715 int ecode1 = 0 ;
28716 PyObject * obj0 = 0 ;
28717 char * kwnames[] = {
28718 (char *) "ms", NULL
28719 };
28720
28721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28722 ecode1 = SWIG_AsVal_long(obj0, &val1);
28723 if (!SWIG_IsOK(ecode1)) {
28724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28725 }
28726 arg1 = static_cast< long >(val1);
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = wxTimeSpan::Milliseconds(arg1);
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741 PyObject *resultobj = 0;
28742 wxTimeSpan result;
28743
28744 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = wxTimeSpan::Millisecond();
28748 wxPyEndAllowThreads(__tstate);
28749 if (PyErr_Occurred()) SWIG_fail;
28750 }
28751 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj = 0;
28760 long arg1 ;
28761 wxTimeSpan result;
28762 long val1 ;
28763 int ecode1 = 0 ;
28764 PyObject * obj0 = 0 ;
28765 char * kwnames[] = {
28766 (char *) "sec", NULL
28767 };
28768
28769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28770 ecode1 = SWIG_AsVal_long(obj0, &val1);
28771 if (!SWIG_IsOK(ecode1)) {
28772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28773 }
28774 arg1 = static_cast< long >(val1);
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = wxTimeSpan::Seconds(arg1);
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28782 return resultobj;
28783 fail:
28784 return NULL;
28785 }
28786
28787
28788 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28789 PyObject *resultobj = 0;
28790 wxTimeSpan result;
28791
28792 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = wxTimeSpan::Second();
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28807 PyObject *resultobj = 0;
28808 long arg1 ;
28809 wxTimeSpan result;
28810 long val1 ;
28811 int ecode1 = 0 ;
28812 PyObject * obj0 = 0 ;
28813 char * kwnames[] = {
28814 (char *) "min", NULL
28815 };
28816
28817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28818 ecode1 = SWIG_AsVal_long(obj0, &val1);
28819 if (!SWIG_IsOK(ecode1)) {
28820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28821 }
28822 arg1 = static_cast< long >(val1);
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = wxTimeSpan::Minutes(arg1);
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28837 PyObject *resultobj = 0;
28838 wxTimeSpan result;
28839
28840 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28841 {
28842 PyThreadState* __tstate = wxPyBeginAllowThreads();
28843 result = wxTimeSpan::Minute();
28844 wxPyEndAllowThreads(__tstate);
28845 if (PyErr_Occurred()) SWIG_fail;
28846 }
28847 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28855 PyObject *resultobj = 0;
28856 long arg1 ;
28857 wxTimeSpan result;
28858 long val1 ;
28859 int ecode1 = 0 ;
28860 PyObject * obj0 = 0 ;
28861 char * kwnames[] = {
28862 (char *) "hours", NULL
28863 };
28864
28865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28866 ecode1 = SWIG_AsVal_long(obj0, &val1);
28867 if (!SWIG_IsOK(ecode1)) {
28868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28869 }
28870 arg1 = static_cast< long >(val1);
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = wxTimeSpan::Hours(arg1);
28874 wxPyEndAllowThreads(__tstate);
28875 if (PyErr_Occurred()) SWIG_fail;
28876 }
28877 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28878 return resultobj;
28879 fail:
28880 return NULL;
28881 }
28882
28883
28884 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28885 PyObject *resultobj = 0;
28886 wxTimeSpan result;
28887
28888 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28889 {
28890 PyThreadState* __tstate = wxPyBeginAllowThreads();
28891 result = wxTimeSpan::Hour();
28892 wxPyEndAllowThreads(__tstate);
28893 if (PyErr_Occurred()) SWIG_fail;
28894 }
28895 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28896 return resultobj;
28897 fail:
28898 return NULL;
28899 }
28900
28901
28902 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28903 PyObject *resultobj = 0;
28904 long arg1 ;
28905 wxTimeSpan result;
28906 long val1 ;
28907 int ecode1 = 0 ;
28908 PyObject * obj0 = 0 ;
28909 char * kwnames[] = {
28910 (char *) "days", NULL
28911 };
28912
28913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28914 ecode1 = SWIG_AsVal_long(obj0, &val1);
28915 if (!SWIG_IsOK(ecode1)) {
28916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28917 }
28918 arg1 = static_cast< long >(val1);
28919 {
28920 PyThreadState* __tstate = wxPyBeginAllowThreads();
28921 result = wxTimeSpan::Days(arg1);
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28933 PyObject *resultobj = 0;
28934 wxTimeSpan result;
28935
28936 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28937 {
28938 PyThreadState* __tstate = wxPyBeginAllowThreads();
28939 result = wxTimeSpan::Day();
28940 wxPyEndAllowThreads(__tstate);
28941 if (PyErr_Occurred()) SWIG_fail;
28942 }
28943 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28951 PyObject *resultobj = 0;
28952 long arg1 ;
28953 wxTimeSpan result;
28954 long val1 ;
28955 int ecode1 = 0 ;
28956 PyObject * obj0 = 0 ;
28957 char * kwnames[] = {
28958 (char *) "days", NULL
28959 };
28960
28961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28962 ecode1 = SWIG_AsVal_long(obj0, &val1);
28963 if (!SWIG_IsOK(ecode1)) {
28964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28965 }
28966 arg1 = static_cast< long >(val1);
28967 {
28968 PyThreadState* __tstate = wxPyBeginAllowThreads();
28969 result = wxTimeSpan::Weeks(arg1);
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28974 return resultobj;
28975 fail:
28976 return NULL;
28977 }
28978
28979
28980 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28981 PyObject *resultobj = 0;
28982 wxTimeSpan result;
28983
28984 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28985 {
28986 PyThreadState* __tstate = wxPyBeginAllowThreads();
28987 result = wxTimeSpan::Week();
28988 wxPyEndAllowThreads(__tstate);
28989 if (PyErr_Occurred()) SWIG_fail;
28990 }
28991 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28992 return resultobj;
28993 fail:
28994 return NULL;
28995 }
28996
28997
28998 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28999 PyObject *resultobj = 0;
29000 long arg1 = (long) 0 ;
29001 long arg2 = (long) 0 ;
29002 long arg3 = (long) 0 ;
29003 long arg4 = (long) 0 ;
29004 wxTimeSpan *result = 0 ;
29005 long val1 ;
29006 int ecode1 = 0 ;
29007 long val2 ;
29008 int ecode2 = 0 ;
29009 long val3 ;
29010 int ecode3 = 0 ;
29011 long val4 ;
29012 int ecode4 = 0 ;
29013 PyObject * obj0 = 0 ;
29014 PyObject * obj1 = 0 ;
29015 PyObject * obj2 = 0 ;
29016 PyObject * obj3 = 0 ;
29017 char * kwnames[] = {
29018 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
29019 };
29020
29021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29022 if (obj0) {
29023 ecode1 = SWIG_AsVal_long(obj0, &val1);
29024 if (!SWIG_IsOK(ecode1)) {
29025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
29026 }
29027 arg1 = static_cast< long >(val1);
29028 }
29029 if (obj1) {
29030 ecode2 = SWIG_AsVal_long(obj1, &val2);
29031 if (!SWIG_IsOK(ecode2)) {
29032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
29033 }
29034 arg2 = static_cast< long >(val2);
29035 }
29036 if (obj2) {
29037 ecode3 = SWIG_AsVal_long(obj2, &val3);
29038 if (!SWIG_IsOK(ecode3)) {
29039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
29040 }
29041 arg3 = static_cast< long >(val3);
29042 }
29043 if (obj3) {
29044 ecode4 = SWIG_AsVal_long(obj3, &val4);
29045 if (!SWIG_IsOK(ecode4)) {
29046 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
29047 }
29048 arg4 = static_cast< long >(val4);
29049 }
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29057 return resultobj;
29058 fail:
29059 return NULL;
29060 }
29061
29062
29063 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29064 PyObject *resultobj = 0;
29065 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29066 void *argp1 = 0 ;
29067 int res1 = 0 ;
29068 PyObject *swig_obj[1] ;
29069
29070 if (!args) SWIG_fail;
29071 swig_obj[0] = args;
29072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29073 if (!SWIG_IsOK(res1)) {
29074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29075 }
29076 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29077 {
29078 PyThreadState* __tstate = wxPyBeginAllowThreads();
29079 delete arg1;
29080
29081 wxPyEndAllowThreads(__tstate);
29082 if (PyErr_Occurred()) SWIG_fail;
29083 }
29084 resultobj = SWIG_Py_Void();
29085 return resultobj;
29086 fail:
29087 return NULL;
29088 }
29089
29090
29091 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29092 PyObject *resultobj = 0;
29093 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29094 wxTimeSpan *arg2 = 0 ;
29095 wxTimeSpan *result = 0 ;
29096 void *argp1 = 0 ;
29097 int res1 = 0 ;
29098 void *argp2 = 0 ;
29099 int res2 = 0 ;
29100 PyObject * obj0 = 0 ;
29101 PyObject * obj1 = 0 ;
29102 char * kwnames[] = {
29103 (char *) "self",(char *) "diff", NULL
29104 };
29105
29106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29108 if (!SWIG_IsOK(res1)) {
29109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29110 }
29111 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29112 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29113 if (!SWIG_IsOK(res2)) {
29114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29115 }
29116 if (!argp2) {
29117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29118 }
29119 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 {
29123 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29124 result = (wxTimeSpan *) &_result_ref;
29125 }
29126 wxPyEndAllowThreads(__tstate);
29127 if (PyErr_Occurred()) SWIG_fail;
29128 }
29129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29130 return resultobj;
29131 fail:
29132 return NULL;
29133 }
29134
29135
29136 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29137 PyObject *resultobj = 0;
29138 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29139 wxTimeSpan *arg2 = 0 ;
29140 wxTimeSpan *result = 0 ;
29141 void *argp1 = 0 ;
29142 int res1 = 0 ;
29143 void *argp2 = 0 ;
29144 int res2 = 0 ;
29145 PyObject * obj0 = 0 ;
29146 PyObject * obj1 = 0 ;
29147 char * kwnames[] = {
29148 (char *) "self",(char *) "diff", NULL
29149 };
29150
29151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29153 if (!SWIG_IsOK(res1)) {
29154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29155 }
29156 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29158 if (!SWIG_IsOK(res2)) {
29159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29160 }
29161 if (!argp2) {
29162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29163 }
29164 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 {
29168 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29169 result = (wxTimeSpan *) &_result_ref;
29170 }
29171 wxPyEndAllowThreads(__tstate);
29172 if (PyErr_Occurred()) SWIG_fail;
29173 }
29174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29182 PyObject *resultobj = 0;
29183 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29184 int arg2 ;
29185 wxTimeSpan *result = 0 ;
29186 void *argp1 = 0 ;
29187 int res1 = 0 ;
29188 int val2 ;
29189 int ecode2 = 0 ;
29190 PyObject * obj0 = 0 ;
29191 PyObject * obj1 = 0 ;
29192 char * kwnames[] = {
29193 (char *) "self",(char *) "n", NULL
29194 };
29195
29196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29198 if (!SWIG_IsOK(res1)) {
29199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29200 }
29201 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29202 ecode2 = SWIG_AsVal_int(obj1, &val2);
29203 if (!SWIG_IsOK(ecode2)) {
29204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29205 }
29206 arg2 = static_cast< int >(val2);
29207 {
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 {
29210 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29211 result = (wxTimeSpan *) &_result_ref;
29212 }
29213 wxPyEndAllowThreads(__tstate);
29214 if (PyErr_Occurred()) SWIG_fail;
29215 }
29216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29224 PyObject *resultobj = 0;
29225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29226 wxTimeSpan *result = 0 ;
29227 void *argp1 = 0 ;
29228 int res1 = 0 ;
29229 PyObject *swig_obj[1] ;
29230
29231 if (!args) SWIG_fail;
29232 swig_obj[0] = args;
29233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29234 if (!SWIG_IsOK(res1)) {
29235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29236 }
29237 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29238 {
29239 PyThreadState* __tstate = wxPyBeginAllowThreads();
29240 {
29241 wxTimeSpan &_result_ref = (arg1)->Neg();
29242 result = (wxTimeSpan *) &_result_ref;
29243 }
29244 wxPyEndAllowThreads(__tstate);
29245 if (PyErr_Occurred()) SWIG_fail;
29246 }
29247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29248 return resultobj;
29249 fail:
29250 return NULL;
29251 }
29252
29253
29254 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29255 PyObject *resultobj = 0;
29256 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29257 wxTimeSpan result;
29258 void *argp1 = 0 ;
29259 int res1 = 0 ;
29260 PyObject *swig_obj[1] ;
29261
29262 if (!args) SWIG_fail;
29263 swig_obj[0] = args;
29264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29265 if (!SWIG_IsOK(res1)) {
29266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29267 }
29268 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 result = ((wxTimeSpan const *)arg1)->Abs();
29272 wxPyEndAllowThreads(__tstate);
29273 if (PyErr_Occurred()) SWIG_fail;
29274 }
29275 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29276 return resultobj;
29277 fail:
29278 return NULL;
29279 }
29280
29281
29282 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29283 PyObject *resultobj = 0;
29284 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29285 wxTimeSpan *arg2 = 0 ;
29286 wxTimeSpan *result = 0 ;
29287 void *argp1 = 0 ;
29288 int res1 = 0 ;
29289 void *argp2 = 0 ;
29290 int res2 = 0 ;
29291 PyObject * obj0 = 0 ;
29292 PyObject * obj1 = 0 ;
29293 char * kwnames[] = {
29294 (char *) "self",(char *) "diff", NULL
29295 };
29296
29297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29299 if (!SWIG_IsOK(res1)) {
29300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29301 }
29302 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29303 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29304 if (!SWIG_IsOK(res2)) {
29305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29306 }
29307 if (!argp2) {
29308 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29309 }
29310 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 {
29314 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29315 result = (wxTimeSpan *) &_result_ref;
29316 }
29317 wxPyEndAllowThreads(__tstate);
29318 if (PyErr_Occurred()) SWIG_fail;
29319 }
29320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29321 return resultobj;
29322 fail:
29323 return NULL;
29324 }
29325
29326
29327 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29328 PyObject *resultobj = 0;
29329 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29330 wxTimeSpan *arg2 = 0 ;
29331 wxTimeSpan *result = 0 ;
29332 void *argp1 = 0 ;
29333 int res1 = 0 ;
29334 void *argp2 = 0 ;
29335 int res2 = 0 ;
29336 PyObject * obj0 = 0 ;
29337 PyObject * obj1 = 0 ;
29338 char * kwnames[] = {
29339 (char *) "self",(char *) "diff", NULL
29340 };
29341
29342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29344 if (!SWIG_IsOK(res1)) {
29345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29346 }
29347 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29349 if (!SWIG_IsOK(res2)) {
29350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29351 }
29352 if (!argp2) {
29353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29354 }
29355 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 {
29359 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29360 result = (wxTimeSpan *) &_result_ref;
29361 }
29362 wxPyEndAllowThreads(__tstate);
29363 if (PyErr_Occurred()) SWIG_fail;
29364 }
29365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29366 return resultobj;
29367 fail:
29368 return NULL;
29369 }
29370
29371
29372 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29373 PyObject *resultobj = 0;
29374 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29375 int arg2 ;
29376 wxTimeSpan *result = 0 ;
29377 void *argp1 = 0 ;
29378 int res1 = 0 ;
29379 int val2 ;
29380 int ecode2 = 0 ;
29381 PyObject * obj0 = 0 ;
29382 PyObject * obj1 = 0 ;
29383 char * kwnames[] = {
29384 (char *) "self",(char *) "n", NULL
29385 };
29386
29387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29389 if (!SWIG_IsOK(res1)) {
29390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29391 }
29392 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29393 ecode2 = SWIG_AsVal_int(obj1, &val2);
29394 if (!SWIG_IsOK(ecode2)) {
29395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29396 }
29397 arg2 = static_cast< int >(val2);
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 {
29401 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29402 result = (wxTimeSpan *) &_result_ref;
29403 }
29404 wxPyEndAllowThreads(__tstate);
29405 if (PyErr_Occurred()) SWIG_fail;
29406 }
29407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29408 return resultobj;
29409 fail:
29410 return NULL;
29411 }
29412
29413
29414 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29415 PyObject *resultobj = 0;
29416 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29417 wxTimeSpan *result = 0 ;
29418 void *argp1 = 0 ;
29419 int res1 = 0 ;
29420 PyObject *swig_obj[1] ;
29421
29422 if (!args) SWIG_fail;
29423 swig_obj[0] = args;
29424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29425 if (!SWIG_IsOK(res1)) {
29426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29427 }
29428 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 {
29432 wxTimeSpan &_result_ref = (arg1)->operator -();
29433 result = (wxTimeSpan *) &_result_ref;
29434 }
29435 wxPyEndAllowThreads(__tstate);
29436 if (PyErr_Occurred()) SWIG_fail;
29437 }
29438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj = 0;
29447 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29448 wxTimeSpan *arg2 = 0 ;
29449 wxTimeSpan result;
29450 void *argp1 = 0 ;
29451 int res1 = 0 ;
29452 void *argp2 = 0 ;
29453 int res2 = 0 ;
29454 PyObject * obj0 = 0 ;
29455 PyObject * obj1 = 0 ;
29456 char * kwnames[] = {
29457 (char *) "self",(char *) "other", NULL
29458 };
29459
29460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29462 if (!SWIG_IsOK(res1)) {
29463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29464 }
29465 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29467 if (!SWIG_IsOK(res2)) {
29468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29469 }
29470 if (!argp2) {
29471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29472 }
29473 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29474 {
29475 PyThreadState* __tstate = wxPyBeginAllowThreads();
29476 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29477 wxPyEndAllowThreads(__tstate);
29478 if (PyErr_Occurred()) SWIG_fail;
29479 }
29480 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29481 return resultobj;
29482 fail:
29483 return NULL;
29484 }
29485
29486
29487 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29488 PyObject *resultobj = 0;
29489 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29490 wxTimeSpan *arg2 = 0 ;
29491 wxTimeSpan result;
29492 void *argp1 = 0 ;
29493 int res1 = 0 ;
29494 void *argp2 = 0 ;
29495 int res2 = 0 ;
29496 PyObject * obj0 = 0 ;
29497 PyObject * obj1 = 0 ;
29498 char * kwnames[] = {
29499 (char *) "self",(char *) "other", NULL
29500 };
29501
29502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29504 if (!SWIG_IsOK(res1)) {
29505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29506 }
29507 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29509 if (!SWIG_IsOK(res2)) {
29510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29511 }
29512 if (!argp2) {
29513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29514 }
29515 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29516 {
29517 PyThreadState* __tstate = wxPyBeginAllowThreads();
29518 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29519 wxPyEndAllowThreads(__tstate);
29520 if (PyErr_Occurred()) SWIG_fail;
29521 }
29522 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj = 0;
29531 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29532 int arg2 ;
29533 wxTimeSpan result;
29534 void *argp1 = 0 ;
29535 int res1 = 0 ;
29536 int val2 ;
29537 int ecode2 = 0 ;
29538 PyObject * obj0 = 0 ;
29539 PyObject * obj1 = 0 ;
29540 char * kwnames[] = {
29541 (char *) "self",(char *) "n", NULL
29542 };
29543
29544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29546 if (!SWIG_IsOK(res1)) {
29547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29548 }
29549 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29550 ecode2 = SWIG_AsVal_int(obj1, &val2);
29551 if (!SWIG_IsOK(ecode2)) {
29552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29553 }
29554 arg2 = static_cast< int >(val2);
29555 {
29556 PyThreadState* __tstate = wxPyBeginAllowThreads();
29557 result = wxTimeSpan___mul__(arg1,arg2);
29558 wxPyEndAllowThreads(__tstate);
29559 if (PyErr_Occurred()) SWIG_fail;
29560 }
29561 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29569 PyObject *resultobj = 0;
29570 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29571 int arg2 ;
29572 wxTimeSpan result;
29573 void *argp1 = 0 ;
29574 int res1 = 0 ;
29575 int val2 ;
29576 int ecode2 = 0 ;
29577 PyObject * obj0 = 0 ;
29578 PyObject * obj1 = 0 ;
29579 char * kwnames[] = {
29580 (char *) "self",(char *) "n", NULL
29581 };
29582
29583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29585 if (!SWIG_IsOK(res1)) {
29586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29587 }
29588 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29589 ecode2 = SWIG_AsVal_int(obj1, &val2);
29590 if (!SWIG_IsOK(ecode2)) {
29591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29592 }
29593 arg2 = static_cast< int >(val2);
29594 {
29595 PyThreadState* __tstate = wxPyBeginAllowThreads();
29596 result = wxTimeSpan___rmul__(arg1,arg2);
29597 wxPyEndAllowThreads(__tstate);
29598 if (PyErr_Occurred()) SWIG_fail;
29599 }
29600 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29601 return resultobj;
29602 fail:
29603 return NULL;
29604 }
29605
29606
29607 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29608 PyObject *resultobj = 0;
29609 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29610 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29611 bool result;
29612 void *argp1 = 0 ;
29613 int res1 = 0 ;
29614 void *argp2 = 0 ;
29615 int res2 = 0 ;
29616 PyObject * obj0 = 0 ;
29617 PyObject * obj1 = 0 ;
29618 char * kwnames[] = {
29619 (char *) "self",(char *) "other", NULL
29620 };
29621
29622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29624 if (!SWIG_IsOK(res1)) {
29625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29626 }
29627 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29629 if (!SWIG_IsOK(res2)) {
29630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29631 }
29632 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29633 {
29634 PyThreadState* __tstate = wxPyBeginAllowThreads();
29635 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29636 wxPyEndAllowThreads(__tstate);
29637 if (PyErr_Occurred()) SWIG_fail;
29638 }
29639 {
29640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29641 }
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj = 0;
29650 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29651 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29652 bool result;
29653 void *argp1 = 0 ;
29654 int res1 = 0 ;
29655 void *argp2 = 0 ;
29656 int res2 = 0 ;
29657 PyObject * obj0 = 0 ;
29658 PyObject * obj1 = 0 ;
29659 char * kwnames[] = {
29660 (char *) "self",(char *) "other", NULL
29661 };
29662
29663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29665 if (!SWIG_IsOK(res1)) {
29666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29667 }
29668 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29669 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29670 if (!SWIG_IsOK(res2)) {
29671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29672 }
29673 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29674 {
29675 PyThreadState* __tstate = wxPyBeginAllowThreads();
29676 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 {
29681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29682 }
29683 return resultobj;
29684 fail:
29685 return NULL;
29686 }
29687
29688
29689 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29690 PyObject *resultobj = 0;
29691 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29692 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29693 bool result;
29694 void *argp1 = 0 ;
29695 int res1 = 0 ;
29696 void *argp2 = 0 ;
29697 int res2 = 0 ;
29698 PyObject * obj0 = 0 ;
29699 PyObject * obj1 = 0 ;
29700 char * kwnames[] = {
29701 (char *) "self",(char *) "other", NULL
29702 };
29703
29704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29706 if (!SWIG_IsOK(res1)) {
29707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29708 }
29709 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29711 if (!SWIG_IsOK(res2)) {
29712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29713 }
29714 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29718 wxPyEndAllowThreads(__tstate);
29719 if (PyErr_Occurred()) SWIG_fail;
29720 }
29721 {
29722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29723 }
29724 return resultobj;
29725 fail:
29726 return NULL;
29727 }
29728
29729
29730 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29731 PyObject *resultobj = 0;
29732 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29733 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29734 bool result;
29735 void *argp1 = 0 ;
29736 int res1 = 0 ;
29737 void *argp2 = 0 ;
29738 int res2 = 0 ;
29739 PyObject * obj0 = 0 ;
29740 PyObject * obj1 = 0 ;
29741 char * kwnames[] = {
29742 (char *) "self",(char *) "other", NULL
29743 };
29744
29745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29747 if (!SWIG_IsOK(res1)) {
29748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29749 }
29750 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29752 if (!SWIG_IsOK(res2)) {
29753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29754 }
29755 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29756 {
29757 PyThreadState* __tstate = wxPyBeginAllowThreads();
29758 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 {
29763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29764 }
29765 return resultobj;
29766 fail:
29767 return NULL;
29768 }
29769
29770
29771 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29772 PyObject *resultobj = 0;
29773 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29774 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29775 bool result;
29776 void *argp1 = 0 ;
29777 int res1 = 0 ;
29778 void *argp2 = 0 ;
29779 int res2 = 0 ;
29780 PyObject * obj0 = 0 ;
29781 PyObject * obj1 = 0 ;
29782 char * kwnames[] = {
29783 (char *) "self",(char *) "other", NULL
29784 };
29785
29786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29788 if (!SWIG_IsOK(res1)) {
29789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29790 }
29791 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29793 if (!SWIG_IsOK(res2)) {
29794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29795 }
29796 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 {
29804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29805 }
29806 return resultobj;
29807 fail:
29808 return NULL;
29809 }
29810
29811
29812 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29813 PyObject *resultobj = 0;
29814 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29815 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29816 bool result;
29817 void *argp1 = 0 ;
29818 int res1 = 0 ;
29819 void *argp2 = 0 ;
29820 int res2 = 0 ;
29821 PyObject * obj0 = 0 ;
29822 PyObject * obj1 = 0 ;
29823 char * kwnames[] = {
29824 (char *) "self",(char *) "other", NULL
29825 };
29826
29827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29829 if (!SWIG_IsOK(res1)) {
29830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29831 }
29832 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29834 if (!SWIG_IsOK(res2)) {
29835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29836 }
29837 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29854 PyObject *resultobj = 0;
29855 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29856 bool result;
29857 void *argp1 = 0 ;
29858 int res1 = 0 ;
29859 PyObject *swig_obj[1] ;
29860
29861 if (!args) SWIG_fail;
29862 swig_obj[0] = args;
29863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29864 if (!SWIG_IsOK(res1)) {
29865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29866 }
29867 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 {
29875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29876 }
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29884 PyObject *resultobj = 0;
29885 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29886 bool result;
29887 void *argp1 = 0 ;
29888 int res1 = 0 ;
29889 PyObject *swig_obj[1] ;
29890
29891 if (!args) SWIG_fail;
29892 swig_obj[0] = args;
29893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29894 if (!SWIG_IsOK(res1)) {
29895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29896 }
29897 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29901 wxPyEndAllowThreads(__tstate);
29902 if (PyErr_Occurred()) SWIG_fail;
29903 }
29904 {
29905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29906 }
29907 return resultobj;
29908 fail:
29909 return NULL;
29910 }
29911
29912
29913 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29914 PyObject *resultobj = 0;
29915 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29916 bool result;
29917 void *argp1 = 0 ;
29918 int res1 = 0 ;
29919 PyObject *swig_obj[1] ;
29920
29921 if (!args) SWIG_fail;
29922 swig_obj[0] = args;
29923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29924 if (!SWIG_IsOK(res1)) {
29925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29926 }
29927 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29928 {
29929 PyThreadState* __tstate = wxPyBeginAllowThreads();
29930 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 {
29935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29936 }
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj = 0;
29945 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29946 wxTimeSpan *arg2 = 0 ;
29947 bool result;
29948 void *argp1 = 0 ;
29949 int res1 = 0 ;
29950 void *argp2 = 0 ;
29951 int res2 = 0 ;
29952 PyObject * obj0 = 0 ;
29953 PyObject * obj1 = 0 ;
29954 char * kwnames[] = {
29955 (char *) "self",(char *) "ts", NULL
29956 };
29957
29958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29960 if (!SWIG_IsOK(res1)) {
29961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29962 }
29963 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29965 if (!SWIG_IsOK(res2)) {
29966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29967 }
29968 if (!argp2) {
29969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29970 }
29971 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29972 {
29973 PyThreadState* __tstate = wxPyBeginAllowThreads();
29974 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 {
29979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj = 0;
29989 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29990 wxTimeSpan *arg2 = 0 ;
29991 bool result;
29992 void *argp1 = 0 ;
29993 int res1 = 0 ;
29994 void *argp2 = 0 ;
29995 int res2 = 0 ;
29996 PyObject * obj0 = 0 ;
29997 PyObject * obj1 = 0 ;
29998 char * kwnames[] = {
29999 (char *) "self",(char *) "ts", NULL
30000 };
30001
30002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
30003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30004 if (!SWIG_IsOK(res1)) {
30005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30006 }
30007 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30008 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30009 if (!SWIG_IsOK(res2)) {
30010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30011 }
30012 if (!argp2) {
30013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30014 }
30015 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 {
30023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30024 }
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj = 0;
30033 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30034 wxTimeSpan *arg2 = 0 ;
30035 bool result;
30036 void *argp1 = 0 ;
30037 int res1 = 0 ;
30038 void *argp2 = 0 ;
30039 int res2 = 0 ;
30040 PyObject * obj0 = 0 ;
30041 PyObject * obj1 = 0 ;
30042 char * kwnames[] = {
30043 (char *) "self",(char *) "t", NULL
30044 };
30045
30046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
30047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30048 if (!SWIG_IsOK(res1)) {
30049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30050 }
30051 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30053 if (!SWIG_IsOK(res2)) {
30054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30055 }
30056 if (!argp2) {
30057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30058 }
30059 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30060 {
30061 PyThreadState* __tstate = wxPyBeginAllowThreads();
30062 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 {
30067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30068 }
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30076 PyObject *resultobj = 0;
30077 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30078 int result;
30079 void *argp1 = 0 ;
30080 int res1 = 0 ;
30081 PyObject *swig_obj[1] ;
30082
30083 if (!args) SWIG_fail;
30084 swig_obj[0] = args;
30085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30086 if (!SWIG_IsOK(res1)) {
30087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30088 }
30089 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30093 wxPyEndAllowThreads(__tstate);
30094 if (PyErr_Occurred()) SWIG_fail;
30095 }
30096 resultobj = SWIG_From_int(static_cast< int >(result));
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30104 PyObject *resultobj = 0;
30105 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30106 int result;
30107 void *argp1 = 0 ;
30108 int res1 = 0 ;
30109 PyObject *swig_obj[1] ;
30110
30111 if (!args) SWIG_fail;
30112 swig_obj[0] = args;
30113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30114 if (!SWIG_IsOK(res1)) {
30115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30116 }
30117 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30118 {
30119 PyThreadState* __tstate = wxPyBeginAllowThreads();
30120 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30121 wxPyEndAllowThreads(__tstate);
30122 if (PyErr_Occurred()) SWIG_fail;
30123 }
30124 resultobj = SWIG_From_int(static_cast< int >(result));
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30132 PyObject *resultobj = 0;
30133 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30134 int result;
30135 void *argp1 = 0 ;
30136 int res1 = 0 ;
30137 PyObject *swig_obj[1] ;
30138
30139 if (!args) SWIG_fail;
30140 swig_obj[0] = args;
30141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30142 if (!SWIG_IsOK(res1)) {
30143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30144 }
30145 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30146 {
30147 PyThreadState* __tstate = wxPyBeginAllowThreads();
30148 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30149 wxPyEndAllowThreads(__tstate);
30150 if (PyErr_Occurred()) SWIG_fail;
30151 }
30152 resultobj = SWIG_From_int(static_cast< int >(result));
30153 return resultobj;
30154 fail:
30155 return NULL;
30156 }
30157
30158
30159 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30160 PyObject *resultobj = 0;
30161 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30162 int result;
30163 void *argp1 = 0 ;
30164 int res1 = 0 ;
30165 PyObject *swig_obj[1] ;
30166
30167 if (!args) SWIG_fail;
30168 swig_obj[0] = args;
30169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30170 if (!SWIG_IsOK(res1)) {
30171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30172 }
30173 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30174 {
30175 PyThreadState* __tstate = wxPyBeginAllowThreads();
30176 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30177 wxPyEndAllowThreads(__tstate);
30178 if (PyErr_Occurred()) SWIG_fail;
30179 }
30180 resultobj = SWIG_From_int(static_cast< int >(result));
30181 return resultobj;
30182 fail:
30183 return NULL;
30184 }
30185
30186
30187 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30188 PyObject *resultobj = 0;
30189 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30190 wxLongLong result;
30191 void *argp1 = 0 ;
30192 int res1 = 0 ;
30193 PyObject *swig_obj[1] ;
30194
30195 if (!args) SWIG_fail;
30196 swig_obj[0] = args;
30197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30198 if (!SWIG_IsOK(res1)) {
30199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30200 }
30201 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30202 {
30203 PyThreadState* __tstate = wxPyBeginAllowThreads();
30204 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30205 wxPyEndAllowThreads(__tstate);
30206 if (PyErr_Occurred()) SWIG_fail;
30207 }
30208 {
30209 PyObject *hi, *lo, *shifter, *shifted;
30210 hi = PyLong_FromLong( (&result)->GetHi() );
30211 lo = PyLong_FromLong( (&result)->GetLo() );
30212 shifter = PyLong_FromLong(32);
30213 shifted = PyNumber_Lshift(hi, shifter);
30214 resultobj = PyNumber_Or(shifted, lo);
30215 Py_DECREF(hi);
30216 Py_DECREF(lo);
30217 Py_DECREF(shifter);
30218 Py_DECREF(shifted);
30219 }
30220 return resultobj;
30221 fail:
30222 return NULL;
30223 }
30224
30225
30226 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30227 PyObject *resultobj = 0;
30228 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30229 wxLongLong result;
30230 void *argp1 = 0 ;
30231 int res1 = 0 ;
30232 PyObject *swig_obj[1] ;
30233
30234 if (!args) SWIG_fail;
30235 swig_obj[0] = args;
30236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30237 if (!SWIG_IsOK(res1)) {
30238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30239 }
30240 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 {
30248 PyObject *hi, *lo, *shifter, *shifted;
30249 hi = PyLong_FromLong( (&result)->GetHi() );
30250 lo = PyLong_FromLong( (&result)->GetLo() );
30251 shifter = PyLong_FromLong(32);
30252 shifted = PyNumber_Lshift(hi, shifter);
30253 resultobj = PyNumber_Or(shifted, lo);
30254 Py_DECREF(hi);
30255 Py_DECREF(lo);
30256 Py_DECREF(shifter);
30257 Py_DECREF(shifted);
30258 }
30259 return resultobj;
30260 fail:
30261 return NULL;
30262 }
30263
30264
30265 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30266 PyObject *resultobj = 0;
30267 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30268 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30269 wxString *arg2 = (wxString *) &arg2_defvalue ;
30270 wxString result;
30271 void *argp1 = 0 ;
30272 int res1 = 0 ;
30273 bool temp2 = false ;
30274 PyObject * obj0 = 0 ;
30275 PyObject * obj1 = 0 ;
30276 char * kwnames[] = {
30277 (char *) "self",(char *) "format", NULL
30278 };
30279
30280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30282 if (!SWIG_IsOK(res1)) {
30283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30284 }
30285 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30286 if (obj1) {
30287 {
30288 arg2 = wxString_in_helper(obj1);
30289 if (arg2 == NULL) SWIG_fail;
30290 temp2 = true;
30291 }
30292 }
30293 {
30294 PyThreadState* __tstate = wxPyBeginAllowThreads();
30295 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30296 wxPyEndAllowThreads(__tstate);
30297 if (PyErr_Occurred()) SWIG_fail;
30298 }
30299 {
30300 #if wxUSE_UNICODE
30301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30302 #else
30303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30304 #endif
30305 }
30306 {
30307 if (temp2)
30308 delete arg2;
30309 }
30310 return resultobj;
30311 fail:
30312 {
30313 if (temp2)
30314 delete arg2;
30315 }
30316 return NULL;
30317 }
30318
30319
30320 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30321 PyObject *obj;
30322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30323 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30324 return SWIG_Py_Void();
30325 }
30326
30327 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30328 return SWIG_Python_InitShadowInstance(args);
30329 }
30330
30331 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30332 PyObject *resultobj = 0;
30333 int arg1 = (int) 0 ;
30334 int arg2 = (int) 0 ;
30335 int arg3 = (int) 0 ;
30336 int arg4 = (int) 0 ;
30337 wxDateSpan *result = 0 ;
30338 int val1 ;
30339 int ecode1 = 0 ;
30340 int val2 ;
30341 int ecode2 = 0 ;
30342 int val3 ;
30343 int ecode3 = 0 ;
30344 int val4 ;
30345 int ecode4 = 0 ;
30346 PyObject * obj0 = 0 ;
30347 PyObject * obj1 = 0 ;
30348 PyObject * obj2 = 0 ;
30349 PyObject * obj3 = 0 ;
30350 char * kwnames[] = {
30351 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30352 };
30353
30354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30355 if (obj0) {
30356 ecode1 = SWIG_AsVal_int(obj0, &val1);
30357 if (!SWIG_IsOK(ecode1)) {
30358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30359 }
30360 arg1 = static_cast< int >(val1);
30361 }
30362 if (obj1) {
30363 ecode2 = SWIG_AsVal_int(obj1, &val2);
30364 if (!SWIG_IsOK(ecode2)) {
30365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30366 }
30367 arg2 = static_cast< int >(val2);
30368 }
30369 if (obj2) {
30370 ecode3 = SWIG_AsVal_int(obj2, &val3);
30371 if (!SWIG_IsOK(ecode3)) {
30372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30373 }
30374 arg3 = static_cast< int >(val3);
30375 }
30376 if (obj3) {
30377 ecode4 = SWIG_AsVal_int(obj3, &val4);
30378 if (!SWIG_IsOK(ecode4)) {
30379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30380 }
30381 arg4 = static_cast< int >(val4);
30382 }
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30397 PyObject *resultobj = 0;
30398 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30399 void *argp1 = 0 ;
30400 int res1 = 0 ;
30401 PyObject *swig_obj[1] ;
30402
30403 if (!args) SWIG_fail;
30404 swig_obj[0] = args;
30405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30406 if (!SWIG_IsOK(res1)) {
30407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30408 }
30409 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 delete arg1;
30413
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_Py_Void();
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj = 0;
30426 int arg1 ;
30427 wxDateSpan result;
30428 int val1 ;
30429 int ecode1 = 0 ;
30430 PyObject * obj0 = 0 ;
30431 char * kwnames[] = {
30432 (char *) "days", NULL
30433 };
30434
30435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30436 ecode1 = SWIG_AsVal_int(obj0, &val1);
30437 if (!SWIG_IsOK(ecode1)) {
30438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30439 }
30440 arg1 = static_cast< int >(val1);
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 result = wxDateSpan::Days(arg1);
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30455 PyObject *resultobj = 0;
30456 wxDateSpan result;
30457
30458 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 result = wxDateSpan::Day();
30462 wxPyEndAllowThreads(__tstate);
30463 if (PyErr_Occurred()) SWIG_fail;
30464 }
30465 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30473 PyObject *resultobj = 0;
30474 int arg1 ;
30475 wxDateSpan result;
30476 int val1 ;
30477 int ecode1 = 0 ;
30478 PyObject * obj0 = 0 ;
30479 char * kwnames[] = {
30480 (char *) "weeks", NULL
30481 };
30482
30483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30484 ecode1 = SWIG_AsVal_int(obj0, &val1);
30485 if (!SWIG_IsOK(ecode1)) {
30486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30487 }
30488 arg1 = static_cast< int >(val1);
30489 {
30490 PyThreadState* __tstate = wxPyBeginAllowThreads();
30491 result = wxDateSpan::Weeks(arg1);
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30503 PyObject *resultobj = 0;
30504 wxDateSpan result;
30505
30506 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30507 {
30508 PyThreadState* __tstate = wxPyBeginAllowThreads();
30509 result = wxDateSpan::Week();
30510 wxPyEndAllowThreads(__tstate);
30511 if (PyErr_Occurred()) SWIG_fail;
30512 }
30513 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj = 0;
30522 int arg1 ;
30523 wxDateSpan result;
30524 int val1 ;
30525 int ecode1 = 0 ;
30526 PyObject * obj0 = 0 ;
30527 char * kwnames[] = {
30528 (char *) "mon", NULL
30529 };
30530
30531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30532 ecode1 = SWIG_AsVal_int(obj0, &val1);
30533 if (!SWIG_IsOK(ecode1)) {
30534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30535 }
30536 arg1 = static_cast< int >(val1);
30537 {
30538 PyThreadState* __tstate = wxPyBeginAllowThreads();
30539 result = wxDateSpan::Months(arg1);
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30551 PyObject *resultobj = 0;
30552 wxDateSpan result;
30553
30554 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30555 {
30556 PyThreadState* __tstate = wxPyBeginAllowThreads();
30557 result = wxDateSpan::Month();
30558 wxPyEndAllowThreads(__tstate);
30559 if (PyErr_Occurred()) SWIG_fail;
30560 }
30561 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30562 return resultobj;
30563 fail:
30564 return NULL;
30565 }
30566
30567
30568 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30569 PyObject *resultobj = 0;
30570 int arg1 ;
30571 wxDateSpan result;
30572 int val1 ;
30573 int ecode1 = 0 ;
30574 PyObject * obj0 = 0 ;
30575 char * kwnames[] = {
30576 (char *) "years", NULL
30577 };
30578
30579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30580 ecode1 = SWIG_AsVal_int(obj0, &val1);
30581 if (!SWIG_IsOK(ecode1)) {
30582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30583 }
30584 arg1 = static_cast< int >(val1);
30585 {
30586 PyThreadState* __tstate = wxPyBeginAllowThreads();
30587 result = wxDateSpan::Years(arg1);
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30599 PyObject *resultobj = 0;
30600 wxDateSpan result;
30601
30602 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30603 {
30604 PyThreadState* __tstate = wxPyBeginAllowThreads();
30605 result = wxDateSpan::Year();
30606 wxPyEndAllowThreads(__tstate);
30607 if (PyErr_Occurred()) SWIG_fail;
30608 }
30609 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30610 return resultobj;
30611 fail:
30612 return NULL;
30613 }
30614
30615
30616 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30617 PyObject *resultobj = 0;
30618 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30619 int arg2 ;
30620 wxDateSpan *result = 0 ;
30621 void *argp1 = 0 ;
30622 int res1 = 0 ;
30623 int val2 ;
30624 int ecode2 = 0 ;
30625 PyObject * obj0 = 0 ;
30626 PyObject * obj1 = 0 ;
30627 char * kwnames[] = {
30628 (char *) "self",(char *) "n", NULL
30629 };
30630
30631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30633 if (!SWIG_IsOK(res1)) {
30634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30635 }
30636 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30637 ecode2 = SWIG_AsVal_int(obj1, &val2);
30638 if (!SWIG_IsOK(ecode2)) {
30639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30640 }
30641 arg2 = static_cast< int >(val2);
30642 {
30643 PyThreadState* __tstate = wxPyBeginAllowThreads();
30644 {
30645 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30646 result = (wxDateSpan *) &_result_ref;
30647 }
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30659 PyObject *resultobj = 0;
30660 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30661 int arg2 ;
30662 wxDateSpan *result = 0 ;
30663 void *argp1 = 0 ;
30664 int res1 = 0 ;
30665 int val2 ;
30666 int ecode2 = 0 ;
30667 PyObject * obj0 = 0 ;
30668 PyObject * obj1 = 0 ;
30669 char * kwnames[] = {
30670 (char *) "self",(char *) "n", NULL
30671 };
30672
30673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30675 if (!SWIG_IsOK(res1)) {
30676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30677 }
30678 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30679 ecode2 = SWIG_AsVal_int(obj1, &val2);
30680 if (!SWIG_IsOK(ecode2)) {
30681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30682 }
30683 arg2 = static_cast< int >(val2);
30684 {
30685 PyThreadState* __tstate = wxPyBeginAllowThreads();
30686 {
30687 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30688 result = (wxDateSpan *) &_result_ref;
30689 }
30690 wxPyEndAllowThreads(__tstate);
30691 if (PyErr_Occurred()) SWIG_fail;
30692 }
30693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30694 return resultobj;
30695 fail:
30696 return NULL;
30697 }
30698
30699
30700 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30701 PyObject *resultobj = 0;
30702 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30703 int arg2 ;
30704 wxDateSpan *result = 0 ;
30705 void *argp1 = 0 ;
30706 int res1 = 0 ;
30707 int val2 ;
30708 int ecode2 = 0 ;
30709 PyObject * obj0 = 0 ;
30710 PyObject * obj1 = 0 ;
30711 char * kwnames[] = {
30712 (char *) "self",(char *) "n", NULL
30713 };
30714
30715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30719 }
30720 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30721 ecode2 = SWIG_AsVal_int(obj1, &val2);
30722 if (!SWIG_IsOK(ecode2)) {
30723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30724 }
30725 arg2 = static_cast< int >(val2);
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 {
30729 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30730 result = (wxDateSpan *) &_result_ref;
30731 }
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30743 PyObject *resultobj = 0;
30744 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30745 int arg2 ;
30746 wxDateSpan *result = 0 ;
30747 void *argp1 = 0 ;
30748 int res1 = 0 ;
30749 int val2 ;
30750 int ecode2 = 0 ;
30751 PyObject * obj0 = 0 ;
30752 PyObject * obj1 = 0 ;
30753 char * kwnames[] = {
30754 (char *) "self",(char *) "n", NULL
30755 };
30756
30757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30759 if (!SWIG_IsOK(res1)) {
30760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30761 }
30762 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30763 ecode2 = SWIG_AsVal_int(obj1, &val2);
30764 if (!SWIG_IsOK(ecode2)) {
30765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30766 }
30767 arg2 = static_cast< int >(val2);
30768 {
30769 PyThreadState* __tstate = wxPyBeginAllowThreads();
30770 {
30771 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30772 result = (wxDateSpan *) &_result_ref;
30773 }
30774 wxPyEndAllowThreads(__tstate);
30775 if (PyErr_Occurred()) SWIG_fail;
30776 }
30777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30778 return resultobj;
30779 fail:
30780 return NULL;
30781 }
30782
30783
30784 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30785 PyObject *resultobj = 0;
30786 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30787 int result;
30788 void *argp1 = 0 ;
30789 int res1 = 0 ;
30790 PyObject *swig_obj[1] ;
30791
30792 if (!args) SWIG_fail;
30793 swig_obj[0] = args;
30794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30795 if (!SWIG_IsOK(res1)) {
30796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30797 }
30798 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30799 {
30800 PyThreadState* __tstate = wxPyBeginAllowThreads();
30801 result = (int)((wxDateSpan const *)arg1)->GetYears();
30802 wxPyEndAllowThreads(__tstate);
30803 if (PyErr_Occurred()) SWIG_fail;
30804 }
30805 resultobj = SWIG_From_int(static_cast< int >(result));
30806 return resultobj;
30807 fail:
30808 return NULL;
30809 }
30810
30811
30812 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30813 PyObject *resultobj = 0;
30814 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30815 int result;
30816 void *argp1 = 0 ;
30817 int res1 = 0 ;
30818 PyObject *swig_obj[1] ;
30819
30820 if (!args) SWIG_fail;
30821 swig_obj[0] = args;
30822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30823 if (!SWIG_IsOK(res1)) {
30824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30825 }
30826 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30830 wxPyEndAllowThreads(__tstate);
30831 if (PyErr_Occurred()) SWIG_fail;
30832 }
30833 resultobj = SWIG_From_int(static_cast< int >(result));
30834 return resultobj;
30835 fail:
30836 return NULL;
30837 }
30838
30839
30840 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30841 PyObject *resultobj = 0;
30842 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30843 int result;
30844 void *argp1 = 0 ;
30845 int res1 = 0 ;
30846 PyObject *swig_obj[1] ;
30847
30848 if (!args) SWIG_fail;
30849 swig_obj[0] = args;
30850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30851 if (!SWIG_IsOK(res1)) {
30852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30853 }
30854 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30855 {
30856 PyThreadState* __tstate = wxPyBeginAllowThreads();
30857 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 resultobj = SWIG_From_int(static_cast< int >(result));
30862 return resultobj;
30863 fail:
30864 return NULL;
30865 }
30866
30867
30868 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30869 PyObject *resultobj = 0;
30870 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30871 int result;
30872 void *argp1 = 0 ;
30873 int res1 = 0 ;
30874 PyObject *swig_obj[1] ;
30875
30876 if (!args) SWIG_fail;
30877 swig_obj[0] = args;
30878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30879 if (!SWIG_IsOK(res1)) {
30880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30881 }
30882 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30883 {
30884 PyThreadState* __tstate = wxPyBeginAllowThreads();
30885 result = (int)((wxDateSpan const *)arg1)->GetDays();
30886 wxPyEndAllowThreads(__tstate);
30887 if (PyErr_Occurred()) SWIG_fail;
30888 }
30889 resultobj = SWIG_From_int(static_cast< int >(result));
30890 return resultobj;
30891 fail:
30892 return NULL;
30893 }
30894
30895
30896 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30897 PyObject *resultobj = 0;
30898 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30899 int result;
30900 void *argp1 = 0 ;
30901 int res1 = 0 ;
30902 PyObject *swig_obj[1] ;
30903
30904 if (!args) SWIG_fail;
30905 swig_obj[0] = args;
30906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30907 if (!SWIG_IsOK(res1)) {
30908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30909 }
30910 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30914 wxPyEndAllowThreads(__tstate);
30915 if (PyErr_Occurred()) SWIG_fail;
30916 }
30917 resultobj = SWIG_From_int(static_cast< int >(result));
30918 return resultobj;
30919 fail:
30920 return NULL;
30921 }
30922
30923
30924 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30925 PyObject *resultobj = 0;
30926 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30927 wxDateSpan *arg2 = 0 ;
30928 wxDateSpan *result = 0 ;
30929 void *argp1 = 0 ;
30930 int res1 = 0 ;
30931 void *argp2 = 0 ;
30932 int res2 = 0 ;
30933 PyObject * obj0 = 0 ;
30934 PyObject * obj1 = 0 ;
30935 char * kwnames[] = {
30936 (char *) "self",(char *) "other", NULL
30937 };
30938
30939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30941 if (!SWIG_IsOK(res1)) {
30942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30943 }
30944 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30946 if (!SWIG_IsOK(res2)) {
30947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30948 }
30949 if (!argp2) {
30950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30951 }
30952 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30953 {
30954 PyThreadState* __tstate = wxPyBeginAllowThreads();
30955 {
30956 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30957 result = (wxDateSpan *) &_result_ref;
30958 }
30959 wxPyEndAllowThreads(__tstate);
30960 if (PyErr_Occurred()) SWIG_fail;
30961 }
30962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30963 return resultobj;
30964 fail:
30965 return NULL;
30966 }
30967
30968
30969 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30970 PyObject *resultobj = 0;
30971 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30972 wxDateSpan *arg2 = 0 ;
30973 wxDateSpan *result = 0 ;
30974 void *argp1 = 0 ;
30975 int res1 = 0 ;
30976 void *argp2 = 0 ;
30977 int res2 = 0 ;
30978 PyObject * obj0 = 0 ;
30979 PyObject * obj1 = 0 ;
30980 char * kwnames[] = {
30981 (char *) "self",(char *) "other", NULL
30982 };
30983
30984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30986 if (!SWIG_IsOK(res1)) {
30987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30988 }
30989 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30990 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30991 if (!SWIG_IsOK(res2)) {
30992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30993 }
30994 if (!argp2) {
30995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30996 }
30997 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 {
31001 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
31002 result = (wxDateSpan *) &_result_ref;
31003 }
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31015 PyObject *resultobj = 0;
31016 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31017 wxDateSpan *result = 0 ;
31018 void *argp1 = 0 ;
31019 int res1 = 0 ;
31020 PyObject *swig_obj[1] ;
31021
31022 if (!args) SWIG_fail;
31023 swig_obj[0] = args;
31024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31025 if (!SWIG_IsOK(res1)) {
31026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31027 }
31028 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 {
31032 wxDateSpan &_result_ref = (arg1)->Neg();
31033 result = (wxDateSpan *) &_result_ref;
31034 }
31035 wxPyEndAllowThreads(__tstate);
31036 if (PyErr_Occurred()) SWIG_fail;
31037 }
31038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31039 return resultobj;
31040 fail:
31041 return NULL;
31042 }
31043
31044
31045 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31046 PyObject *resultobj = 0;
31047 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31048 int arg2 ;
31049 wxDateSpan *result = 0 ;
31050 void *argp1 = 0 ;
31051 int res1 = 0 ;
31052 int val2 ;
31053 int ecode2 = 0 ;
31054 PyObject * obj0 = 0 ;
31055 PyObject * obj1 = 0 ;
31056 char * kwnames[] = {
31057 (char *) "self",(char *) "factor", NULL
31058 };
31059
31060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31062 if (!SWIG_IsOK(res1)) {
31063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31064 }
31065 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31066 ecode2 = SWIG_AsVal_int(obj1, &val2);
31067 if (!SWIG_IsOK(ecode2)) {
31068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31069 }
31070 arg2 = static_cast< int >(val2);
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 {
31074 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31075 result = (wxDateSpan *) &_result_ref;
31076 }
31077 wxPyEndAllowThreads(__tstate);
31078 if (PyErr_Occurred()) SWIG_fail;
31079 }
31080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31081 return resultobj;
31082 fail:
31083 return NULL;
31084 }
31085
31086
31087 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31088 PyObject *resultobj = 0;
31089 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31090 wxDateSpan *arg2 = 0 ;
31091 wxDateSpan *result = 0 ;
31092 void *argp1 = 0 ;
31093 int res1 = 0 ;
31094 void *argp2 = 0 ;
31095 int res2 = 0 ;
31096 PyObject * obj0 = 0 ;
31097 PyObject * obj1 = 0 ;
31098 char * kwnames[] = {
31099 (char *) "self",(char *) "other", NULL
31100 };
31101
31102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31104 if (!SWIG_IsOK(res1)) {
31105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31106 }
31107 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31109 if (!SWIG_IsOK(res2)) {
31110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31111 }
31112 if (!argp2) {
31113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31114 }
31115 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31116 {
31117 PyThreadState* __tstate = wxPyBeginAllowThreads();
31118 {
31119 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31120 result = (wxDateSpan *) &_result_ref;
31121 }
31122 wxPyEndAllowThreads(__tstate);
31123 if (PyErr_Occurred()) SWIG_fail;
31124 }
31125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31126 return resultobj;
31127 fail:
31128 return NULL;
31129 }
31130
31131
31132 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31133 PyObject *resultobj = 0;
31134 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31135 wxDateSpan *arg2 = 0 ;
31136 wxDateSpan *result = 0 ;
31137 void *argp1 = 0 ;
31138 int res1 = 0 ;
31139 void *argp2 = 0 ;
31140 int res2 = 0 ;
31141 PyObject * obj0 = 0 ;
31142 PyObject * obj1 = 0 ;
31143 char * kwnames[] = {
31144 (char *) "self",(char *) "other", NULL
31145 };
31146
31147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31149 if (!SWIG_IsOK(res1)) {
31150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31151 }
31152 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31154 if (!SWIG_IsOK(res2)) {
31155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31156 }
31157 if (!argp2) {
31158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31159 }
31160 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31161 {
31162 PyThreadState* __tstate = wxPyBeginAllowThreads();
31163 {
31164 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31165 result = (wxDateSpan *) &_result_ref;
31166 }
31167 wxPyEndAllowThreads(__tstate);
31168 if (PyErr_Occurred()) SWIG_fail;
31169 }
31170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31171 return resultobj;
31172 fail:
31173 return NULL;
31174 }
31175
31176
31177 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31178 PyObject *resultobj = 0;
31179 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31180 wxDateSpan *result = 0 ;
31181 void *argp1 = 0 ;
31182 int res1 = 0 ;
31183 PyObject *swig_obj[1] ;
31184
31185 if (!args) SWIG_fail;
31186 swig_obj[0] = args;
31187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31188 if (!SWIG_IsOK(res1)) {
31189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31190 }
31191 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 {
31195 wxDateSpan &_result_ref = (arg1)->operator -();
31196 result = (wxDateSpan *) &_result_ref;
31197 }
31198 wxPyEndAllowThreads(__tstate);
31199 if (PyErr_Occurred()) SWIG_fail;
31200 }
31201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31209 PyObject *resultobj = 0;
31210 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31211 int arg2 ;
31212 wxDateSpan *result = 0 ;
31213 void *argp1 = 0 ;
31214 int res1 = 0 ;
31215 int val2 ;
31216 int ecode2 = 0 ;
31217 PyObject * obj0 = 0 ;
31218 PyObject * obj1 = 0 ;
31219 char * kwnames[] = {
31220 (char *) "self",(char *) "factor", NULL
31221 };
31222
31223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31225 if (!SWIG_IsOK(res1)) {
31226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31227 }
31228 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31229 ecode2 = SWIG_AsVal_int(obj1, &val2);
31230 if (!SWIG_IsOK(ecode2)) {
31231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31232 }
31233 arg2 = static_cast< int >(val2);
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 {
31237 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31238 result = (wxDateSpan *) &_result_ref;
31239 }
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj = 0;
31252 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31253 wxDateSpan *arg2 = 0 ;
31254 wxDateSpan result;
31255 void *argp1 = 0 ;
31256 int res1 = 0 ;
31257 void *argp2 = 0 ;
31258 int res2 = 0 ;
31259 PyObject * obj0 = 0 ;
31260 PyObject * obj1 = 0 ;
31261 char * kwnames[] = {
31262 (char *) "self",(char *) "other", NULL
31263 };
31264
31265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31267 if (!SWIG_IsOK(res1)) {
31268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31269 }
31270 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31271 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31272 if (!SWIG_IsOK(res2)) {
31273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31274 }
31275 if (!argp2) {
31276 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31277 }
31278 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31293 PyObject *resultobj = 0;
31294 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31295 wxDateSpan *arg2 = 0 ;
31296 wxDateSpan result;
31297 void *argp1 = 0 ;
31298 int res1 = 0 ;
31299 void *argp2 = 0 ;
31300 int res2 = 0 ;
31301 PyObject * obj0 = 0 ;
31302 PyObject * obj1 = 0 ;
31303 char * kwnames[] = {
31304 (char *) "self",(char *) "other", NULL
31305 };
31306
31307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31309 if (!SWIG_IsOK(res1)) {
31310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31311 }
31312 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31313 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31314 if (!SWIG_IsOK(res2)) {
31315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31316 }
31317 if (!argp2) {
31318 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31319 }
31320 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31321 {
31322 PyThreadState* __tstate = wxPyBeginAllowThreads();
31323 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31324 wxPyEndAllowThreads(__tstate);
31325 if (PyErr_Occurred()) SWIG_fail;
31326 }
31327 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31328 return resultobj;
31329 fail:
31330 return NULL;
31331 }
31332
31333
31334 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31335 PyObject *resultobj = 0;
31336 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31337 int arg2 ;
31338 wxDateSpan result;
31339 void *argp1 = 0 ;
31340 int res1 = 0 ;
31341 int val2 ;
31342 int ecode2 = 0 ;
31343 PyObject * obj0 = 0 ;
31344 PyObject * obj1 = 0 ;
31345 char * kwnames[] = {
31346 (char *) "self",(char *) "n", NULL
31347 };
31348
31349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31351 if (!SWIG_IsOK(res1)) {
31352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31353 }
31354 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31355 ecode2 = SWIG_AsVal_int(obj1, &val2);
31356 if (!SWIG_IsOK(ecode2)) {
31357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31358 }
31359 arg2 = static_cast< int >(val2);
31360 {
31361 PyThreadState* __tstate = wxPyBeginAllowThreads();
31362 result = wxDateSpan___mul__(arg1,arg2);
31363 wxPyEndAllowThreads(__tstate);
31364 if (PyErr_Occurred()) SWIG_fail;
31365 }
31366 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31367 return resultobj;
31368 fail:
31369 return NULL;
31370 }
31371
31372
31373 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31374 PyObject *resultobj = 0;
31375 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31376 int arg2 ;
31377 wxDateSpan result;
31378 void *argp1 = 0 ;
31379 int res1 = 0 ;
31380 int val2 ;
31381 int ecode2 = 0 ;
31382 PyObject * obj0 = 0 ;
31383 PyObject * obj1 = 0 ;
31384 char * kwnames[] = {
31385 (char *) "self",(char *) "n", NULL
31386 };
31387
31388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31390 if (!SWIG_IsOK(res1)) {
31391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31392 }
31393 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31394 ecode2 = SWIG_AsVal_int(obj1, &val2);
31395 if (!SWIG_IsOK(ecode2)) {
31396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31397 }
31398 arg2 = static_cast< int >(val2);
31399 {
31400 PyThreadState* __tstate = wxPyBeginAllowThreads();
31401 result = wxDateSpan___rmul__(arg1,arg2);
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj = 0;
31414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31415 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31416 bool result;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 void *argp2 = 0 ;
31420 int res2 = 0 ;
31421 PyObject * obj0 = 0 ;
31422 PyObject * obj1 = 0 ;
31423 char * kwnames[] = {
31424 (char *) "self",(char *) "other", NULL
31425 };
31426
31427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31429 if (!SWIG_IsOK(res1)) {
31430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31431 }
31432 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31433 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31434 if (!SWIG_IsOK(res2)) {
31435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31436 }
31437 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 {
31445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31446 }
31447 return resultobj;
31448 fail:
31449 return NULL;
31450 }
31451
31452
31453 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31454 PyObject *resultobj = 0;
31455 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31456 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31457 bool result;
31458 void *argp1 = 0 ;
31459 int res1 = 0 ;
31460 void *argp2 = 0 ;
31461 int res2 = 0 ;
31462 PyObject * obj0 = 0 ;
31463 PyObject * obj1 = 0 ;
31464 char * kwnames[] = {
31465 (char *) "self",(char *) "other", NULL
31466 };
31467
31468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31470 if (!SWIG_IsOK(res1)) {
31471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31472 }
31473 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31474 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31475 if (!SWIG_IsOK(res2)) {
31476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31477 }
31478 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31479 {
31480 PyThreadState* __tstate = wxPyBeginAllowThreads();
31481 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 {
31486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31487 }
31488 return resultobj;
31489 fail:
31490 return NULL;
31491 }
31492
31493
31494 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31495 PyObject *obj;
31496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31497 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31498 return SWIG_Py_Void();
31499 }
31500
31501 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31502 return SWIG_Python_InitShadowInstance(args);
31503 }
31504
31505 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31506 PyObject *resultobj = 0;
31507 long result;
31508
31509 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 result = (long)wxGetLocalTime();
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 resultobj = SWIG_From_long(static_cast< long >(result));
31517 return resultobj;
31518 fail:
31519 return NULL;
31520 }
31521
31522
31523 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31524 PyObject *resultobj = 0;
31525 long result;
31526
31527 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 result = (long)wxGetUTCTime();
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 resultobj = SWIG_From_long(static_cast< long >(result));
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31542 PyObject *resultobj = 0;
31543 long result;
31544
31545 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 result = (long)wxGetCurrentTime();
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_From_long(static_cast< long >(result));
31553 return resultobj;
31554 fail:
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 PyObject *resultobj = 0;
31561 wxLongLong result;
31562
31563 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31564 {
31565 PyThreadState* __tstate = wxPyBeginAllowThreads();
31566 result = wxGetLocalTimeMillis();
31567 wxPyEndAllowThreads(__tstate);
31568 if (PyErr_Occurred()) SWIG_fail;
31569 }
31570 {
31571 PyObject *hi, *lo, *shifter, *shifted;
31572 hi = PyLong_FromLong( (&result)->GetHi() );
31573 lo = PyLong_FromLong( (&result)->GetLo() );
31574 shifter = PyLong_FromLong(32);
31575 shifted = PyNumber_Lshift(hi, shifter);
31576 resultobj = PyNumber_Or(shifted, lo);
31577 Py_DECREF(hi);
31578 Py_DECREF(lo);
31579 Py_DECREF(shifter);
31580 Py_DECREF(shifted);
31581 }
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31589 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31590 return 1;
31591 }
31592
31593
31594 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31595 PyObject *pyobj = 0;
31596
31597 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31598 return pyobj;
31599 }
31600
31601
31602 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31603 PyObject *resultobj = 0;
31604 wxDataFormatId arg1 ;
31605 wxDataFormat *result = 0 ;
31606 int val1 ;
31607 int ecode1 = 0 ;
31608 PyObject * obj0 = 0 ;
31609 char * kwnames[] = {
31610 (char *) "type", NULL
31611 };
31612
31613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31614 ecode1 = SWIG_AsVal_int(obj0, &val1);
31615 if (!SWIG_IsOK(ecode1)) {
31616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31617 }
31618 arg1 = static_cast< wxDataFormatId >(val1);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 result = (wxDataFormat *)new wxDataFormat(arg1);
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31626 return resultobj;
31627 fail:
31628 return NULL;
31629 }
31630
31631
31632 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31633 PyObject *resultobj = 0;
31634 wxString *arg1 = 0 ;
31635 wxDataFormat *result = 0 ;
31636 bool temp1 = false ;
31637 PyObject * obj0 = 0 ;
31638 char * kwnames[] = {
31639 (char *) "format", NULL
31640 };
31641
31642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31643 {
31644 arg1 = wxString_in_helper(obj0);
31645 if (arg1 == NULL) SWIG_fail;
31646 temp1 = true;
31647 }
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31655 {
31656 if (temp1)
31657 delete arg1;
31658 }
31659 return resultobj;
31660 fail:
31661 {
31662 if (temp1)
31663 delete arg1;
31664 }
31665 return NULL;
31666 }
31667
31668
31669 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31670 PyObject *resultobj = 0;
31671 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31672 void *argp1 = 0 ;
31673 int res1 = 0 ;
31674 PyObject *swig_obj[1] ;
31675
31676 if (!args) SWIG_fail;
31677 swig_obj[0] = args;
31678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31679 if (!SWIG_IsOK(res1)) {
31680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31681 }
31682 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 delete arg1;
31686
31687 wxPyEndAllowThreads(__tstate);
31688 if (PyErr_Occurred()) SWIG_fail;
31689 }
31690 resultobj = SWIG_Py_Void();
31691 return resultobj;
31692 fail:
31693 return NULL;
31694 }
31695
31696
31697 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31698 PyObject *resultobj = 0;
31699 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31700 wxDataFormatId arg2 ;
31701 bool result;
31702 void *argp1 = 0 ;
31703 int res1 = 0 ;
31704 int val2 ;
31705 int ecode2 = 0 ;
31706
31707 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31709 if (!SWIG_IsOK(res1)) {
31710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31711 }
31712 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31713 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31714 if (!SWIG_IsOK(ecode2)) {
31715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31716 }
31717 arg2 = static_cast< wxDataFormatId >(val2);
31718 {
31719 PyThreadState* __tstate = wxPyBeginAllowThreads();
31720 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31721 wxPyEndAllowThreads(__tstate);
31722 if (PyErr_Occurred()) SWIG_fail;
31723 }
31724 {
31725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31726 }
31727 return resultobj;
31728 fail:
31729 return NULL;
31730 }
31731
31732
31733 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31734 PyObject *resultobj = 0;
31735 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31736 wxDataFormatId arg2 ;
31737 bool result;
31738 void *argp1 = 0 ;
31739 int res1 = 0 ;
31740 int val2 ;
31741 int ecode2 = 0 ;
31742
31743 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31745 if (!SWIG_IsOK(res1)) {
31746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31747 }
31748 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31749 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31750 if (!SWIG_IsOK(ecode2)) {
31751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31752 }
31753 arg2 = static_cast< wxDataFormatId >(val2);
31754 {
31755 PyThreadState* __tstate = wxPyBeginAllowThreads();
31756 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31757 wxPyEndAllowThreads(__tstate);
31758 if (PyErr_Occurred()) SWIG_fail;
31759 }
31760 {
31761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31762 }
31763 return resultobj;
31764 fail:
31765 return NULL;
31766 }
31767
31768
31769 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31770 PyObject *resultobj = 0;
31771 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31772 wxDataFormat *arg2 = 0 ;
31773 bool result;
31774 void *argp1 = 0 ;
31775 int res1 = 0 ;
31776 void *argp2 = 0 ;
31777 int res2 = 0 ;
31778
31779 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31781 if (!SWIG_IsOK(res1)) {
31782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31783 }
31784 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31785 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31786 if (!SWIG_IsOK(res2)) {
31787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31788 }
31789 if (!argp2) {
31790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31791 }
31792 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 {
31800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31801 }
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31809 int argc;
31810 PyObject *argv[3];
31811
31812 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31813 --argc;
31814 if (argc == 2) {
31815 int _v = 0;
31816 {
31817 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31818 _v = SWIG_CheckState(res);
31819 }
31820 if (!_v) goto check_1;
31821 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31822 }
31823 check_1:
31824
31825 if (argc == 2) {
31826 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31827 }
31828
31829 fail:
31830 Py_INCREF(Py_NotImplemented);
31831 return Py_NotImplemented;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31836 PyObject *resultobj = 0;
31837 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31838 wxDataFormat *arg2 = 0 ;
31839 bool result;
31840 void *argp1 = 0 ;
31841 int res1 = 0 ;
31842 void *argp2 = 0 ;
31843 int res2 = 0 ;
31844
31845 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31847 if (!SWIG_IsOK(res1)) {
31848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31849 }
31850 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31851 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31852 if (!SWIG_IsOK(res2)) {
31853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31854 }
31855 if (!argp2) {
31856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31857 }
31858 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31862 wxPyEndAllowThreads(__tstate);
31863 if (PyErr_Occurred()) SWIG_fail;
31864 }
31865 {
31866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31867 }
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31875 int argc;
31876 PyObject *argv[3];
31877
31878 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31879 --argc;
31880 if (argc == 2) {
31881 int _v = 0;
31882 {
31883 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31884 _v = SWIG_CheckState(res);
31885 }
31886 if (!_v) goto check_1;
31887 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31888 }
31889 check_1:
31890
31891 if (argc == 2) {
31892 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31893 }
31894
31895 fail:
31896 Py_INCREF(Py_NotImplemented);
31897 return Py_NotImplemented;
31898 }
31899
31900
31901 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31902 PyObject *resultobj = 0;
31903 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31904 wxDataFormatId arg2 ;
31905 void *argp1 = 0 ;
31906 int res1 = 0 ;
31907 int val2 ;
31908 int ecode2 = 0 ;
31909 PyObject * obj0 = 0 ;
31910 PyObject * obj1 = 0 ;
31911 char * kwnames[] = {
31912 (char *) "self",(char *) "format", NULL
31913 };
31914
31915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31919 }
31920 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31921 ecode2 = SWIG_AsVal_int(obj1, &val2);
31922 if (!SWIG_IsOK(ecode2)) {
31923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31924 }
31925 arg2 = static_cast< wxDataFormatId >(val2);
31926 {
31927 PyThreadState* __tstate = wxPyBeginAllowThreads();
31928 (arg1)->SetType(arg2);
31929 wxPyEndAllowThreads(__tstate);
31930 if (PyErr_Occurred()) SWIG_fail;
31931 }
31932 resultobj = SWIG_Py_Void();
31933 return resultobj;
31934 fail:
31935 return NULL;
31936 }
31937
31938
31939 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31940 PyObject *resultobj = 0;
31941 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31942 wxDataFormatId result;
31943 void *argp1 = 0 ;
31944 int res1 = 0 ;
31945 PyObject *swig_obj[1] ;
31946
31947 if (!args) SWIG_fail;
31948 swig_obj[0] = args;
31949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31950 if (!SWIG_IsOK(res1)) {
31951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31952 }
31953 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31954 {
31955 PyThreadState* __tstate = wxPyBeginAllowThreads();
31956 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31957 wxPyEndAllowThreads(__tstate);
31958 if (PyErr_Occurred()) SWIG_fail;
31959 }
31960 resultobj = SWIG_From_int(static_cast< int >(result));
31961 return resultobj;
31962 fail:
31963 return NULL;
31964 }
31965
31966
31967 SWIGINTERN PyObject *_wrap_DataFormat__GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31968 PyObject *resultobj = 0;
31969 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31970 wxString result;
31971 void *argp1 = 0 ;
31972 int res1 = 0 ;
31973 PyObject *swig_obj[1] ;
31974
31975 if (!args) SWIG_fail;
31976 swig_obj[0] = args;
31977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31978 if (!SWIG_IsOK(res1)) {
31979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat__GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31980 }
31981 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31982 {
31983 PyThreadState* __tstate = wxPyBeginAllowThreads();
31984 result = ((wxDataFormat const *)arg1)->GetId();
31985 wxPyEndAllowThreads(__tstate);
31986 if (PyErr_Occurred()) SWIG_fail;
31987 }
31988 {
31989 #if wxUSE_UNICODE
31990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31991 #else
31992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31993 #endif
31994 }
31995 return resultobj;
31996 fail:
31997 return NULL;
31998 }
31999
32000
32001 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32002 PyObject *resultobj = 0;
32003 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
32004 wxString *arg2 = 0 ;
32005 void *argp1 = 0 ;
32006 int res1 = 0 ;
32007 bool temp2 = false ;
32008 PyObject * obj0 = 0 ;
32009 PyObject * obj1 = 0 ;
32010 char * kwnames[] = {
32011 (char *) "self",(char *) "format", NULL
32012 };
32013
32014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
32015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
32016 if (!SWIG_IsOK(res1)) {
32017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
32018 }
32019 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32020 {
32021 arg2 = wxString_in_helper(obj1);
32022 if (arg2 == NULL) SWIG_fail;
32023 temp2 = true;
32024 }
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 (arg1)->SetId((wxString const &)*arg2);
32028 wxPyEndAllowThreads(__tstate);
32029 if (PyErr_Occurred()) SWIG_fail;
32030 }
32031 resultobj = SWIG_Py_Void();
32032 {
32033 if (temp2)
32034 delete arg2;
32035 }
32036 return resultobj;
32037 fail:
32038 {
32039 if (temp2)
32040 delete arg2;
32041 }
32042 return NULL;
32043 }
32044
32045
32046 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32047 PyObject *obj;
32048 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32049 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32050 return SWIG_Py_Void();
32051 }
32052
32053 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32054 return SWIG_Python_InitShadowInstance(args);
32055 }
32056
32057 SWIGINTERN int FormatInvalid_set(PyObject *) {
32058 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32059 return 1;
32060 }
32061
32062
32063 SWIGINTERN PyObject *FormatInvalid_get(void) {
32064 PyObject *pyobj = 0;
32065
32066 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32067 return pyobj;
32068 }
32069
32070
32071 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32072 PyObject *resultobj = 0;
32073 wxDataObject *arg1 = (wxDataObject *) 0 ;
32074 void *argp1 = 0 ;
32075 int res1 = 0 ;
32076 PyObject *swig_obj[1] ;
32077
32078 if (!args) SWIG_fail;
32079 swig_obj[0] = args;
32080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32081 if (!SWIG_IsOK(res1)) {
32082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32083 }
32084 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32085 {
32086 PyThreadState* __tstate = wxPyBeginAllowThreads();
32087 delete arg1;
32088
32089 wxPyEndAllowThreads(__tstate);
32090 if (PyErr_Occurred()) SWIG_fail;
32091 }
32092 resultobj = SWIG_Py_Void();
32093 return resultobj;
32094 fail:
32095 return NULL;
32096 }
32097
32098
32099 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32100 PyObject *resultobj = 0;
32101 wxDataObject *arg1 = (wxDataObject *) 0 ;
32102 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32103 SwigValueWrapper<wxDataFormat > result;
32104 void *argp1 = 0 ;
32105 int res1 = 0 ;
32106 int val2 ;
32107 int ecode2 = 0 ;
32108 PyObject * obj0 = 0 ;
32109 PyObject * obj1 = 0 ;
32110 char * kwnames[] = {
32111 (char *) "self",(char *) "dir", NULL
32112 };
32113
32114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32116 if (!SWIG_IsOK(res1)) {
32117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32118 }
32119 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32120 if (obj1) {
32121 ecode2 = SWIG_AsVal_int(obj1, &val2);
32122 if (!SWIG_IsOK(ecode2)) {
32123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32124 }
32125 arg2 = static_cast< wxDataObject::Direction >(val2);
32126 }
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32141 PyObject *resultobj = 0;
32142 wxDataObject *arg1 = (wxDataObject *) 0 ;
32143 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32144 size_t result;
32145 void *argp1 = 0 ;
32146 int res1 = 0 ;
32147 int val2 ;
32148 int ecode2 = 0 ;
32149 PyObject * obj0 = 0 ;
32150 PyObject * obj1 = 0 ;
32151 char * kwnames[] = {
32152 (char *) "self",(char *) "dir", NULL
32153 };
32154
32155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32157 if (!SWIG_IsOK(res1)) {
32158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32159 }
32160 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32161 if (obj1) {
32162 ecode2 = SWIG_AsVal_int(obj1, &val2);
32163 if (!SWIG_IsOK(ecode2)) {
32164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32165 }
32166 arg2 = static_cast< wxDataObject::Direction >(val2);
32167 }
32168 {
32169 PyThreadState* __tstate = wxPyBeginAllowThreads();
32170 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32171 wxPyEndAllowThreads(__tstate);
32172 if (PyErr_Occurred()) SWIG_fail;
32173 }
32174 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32175 return resultobj;
32176 fail:
32177 return NULL;
32178 }
32179
32180
32181 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32182 PyObject *resultobj = 0;
32183 wxDataObject *arg1 = (wxDataObject *) 0 ;
32184 wxDataFormat *arg2 = 0 ;
32185 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32186 bool result;
32187 void *argp1 = 0 ;
32188 int res1 = 0 ;
32189 void *argp2 = 0 ;
32190 int res2 = 0 ;
32191 int val3 ;
32192 int ecode3 = 0 ;
32193 PyObject * obj0 = 0 ;
32194 PyObject * obj1 = 0 ;
32195 PyObject * obj2 = 0 ;
32196 char * kwnames[] = {
32197 (char *) "self",(char *) "format",(char *) "dir", NULL
32198 };
32199
32200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32202 if (!SWIG_IsOK(res1)) {
32203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32204 }
32205 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32206 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32207 if (!SWIG_IsOK(res2)) {
32208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32209 }
32210 if (!argp2) {
32211 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32212 }
32213 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32214 if (obj2) {
32215 ecode3 = SWIG_AsVal_int(obj2, &val3);
32216 if (!SWIG_IsOK(ecode3)) {
32217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32218 }
32219 arg3 = static_cast< wxDataObject::Direction >(val3);
32220 }
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 {
32228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32229 }
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32237 PyObject *resultobj = 0;
32238 wxDataObject *arg1 = (wxDataObject *) 0 ;
32239 wxDataFormat *arg2 = 0 ;
32240 size_t result;
32241 void *argp1 = 0 ;
32242 int res1 = 0 ;
32243 void *argp2 = 0 ;
32244 int res2 = 0 ;
32245 PyObject * obj0 = 0 ;
32246 PyObject * obj1 = 0 ;
32247 char * kwnames[] = {
32248 (char *) "self",(char *) "format", NULL
32249 };
32250
32251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32253 if (!SWIG_IsOK(res1)) {
32254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32255 }
32256 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32257 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32258 if (!SWIG_IsOK(res2)) {
32259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32260 }
32261 if (!argp2) {
32262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32263 }
32264 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32268 wxPyEndAllowThreads(__tstate);
32269 if (PyErr_Occurred()) SWIG_fail;
32270 }
32271 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32272 return resultobj;
32273 fail:
32274 return NULL;
32275 }
32276
32277
32278 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32279 PyObject *resultobj = 0;
32280 wxDataObject *arg1 = (wxDataObject *) 0 ;
32281 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32282 PyObject *result = 0 ;
32283 void *argp1 = 0 ;
32284 int res1 = 0 ;
32285 int val2 ;
32286 int ecode2 = 0 ;
32287 PyObject * obj0 = 0 ;
32288 PyObject * obj1 = 0 ;
32289 char * kwnames[] = {
32290 (char *) "self",(char *) "dir", NULL
32291 };
32292
32293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32295 if (!SWIG_IsOK(res1)) {
32296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32297 }
32298 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32299 if (obj1) {
32300 ecode2 = SWIG_AsVal_int(obj1, &val2);
32301 if (!SWIG_IsOK(ecode2)) {
32302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32303 }
32304 arg2 = static_cast< wxDataObject::Direction >(val2);
32305 }
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32309 wxPyEndAllowThreads(__tstate);
32310 if (PyErr_Occurred()) SWIG_fail;
32311 }
32312 resultobj = result;
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32320 PyObject *resultobj = 0;
32321 wxDataObject *arg1 = (wxDataObject *) 0 ;
32322 wxDataFormat *arg2 = 0 ;
32323 PyObject *result = 0 ;
32324 void *argp1 = 0 ;
32325 int res1 = 0 ;
32326 void *argp2 = 0 ;
32327 int res2 = 0 ;
32328 PyObject * obj0 = 0 ;
32329 PyObject * obj1 = 0 ;
32330 char * kwnames[] = {
32331 (char *) "self",(char *) "format", NULL
32332 };
32333
32334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32336 if (!SWIG_IsOK(res1)) {
32337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32338 }
32339 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32341 if (!SWIG_IsOK(res2)) {
32342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32343 }
32344 if (!argp2) {
32345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32346 }
32347 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32348 {
32349 PyThreadState* __tstate = wxPyBeginAllowThreads();
32350 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32351 wxPyEndAllowThreads(__tstate);
32352 if (PyErr_Occurred()) SWIG_fail;
32353 }
32354 resultobj = result;
32355 return resultobj;
32356 fail:
32357 return NULL;
32358 }
32359
32360
32361 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32362 PyObject *resultobj = 0;
32363 wxDataObject *arg1 = (wxDataObject *) 0 ;
32364 wxDataFormat *arg2 = 0 ;
32365 PyObject *arg3 = (PyObject *) 0 ;
32366 bool result;
32367 void *argp1 = 0 ;
32368 int res1 = 0 ;
32369 void *argp2 = 0 ;
32370 int res2 = 0 ;
32371 PyObject * obj0 = 0 ;
32372 PyObject * obj1 = 0 ;
32373 PyObject * obj2 = 0 ;
32374 char * kwnames[] = {
32375 (char *) "self",(char *) "format",(char *) "data", NULL
32376 };
32377
32378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32380 if (!SWIG_IsOK(res1)) {
32381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32382 }
32383 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32384 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32385 if (!SWIG_IsOK(res2)) {
32386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32387 }
32388 if (!argp2) {
32389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32390 }
32391 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32392 arg3 = obj2;
32393 {
32394 PyThreadState* __tstate = wxPyBeginAllowThreads();
32395 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32396 wxPyEndAllowThreads(__tstate);
32397 if (PyErr_Occurred()) SWIG_fail;
32398 }
32399 {
32400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32401 }
32402 return resultobj;
32403 fail:
32404 return NULL;
32405 }
32406
32407
32408 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32409 PyObject *obj;
32410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32411 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32412 return SWIG_Py_Void();
32413 }
32414
32415 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32416 PyObject *resultobj = 0;
32417 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32418 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32419 wxDataObjectSimple *result = 0 ;
32420 void *argp1 = 0 ;
32421 int res1 = 0 ;
32422 PyObject * obj0 = 0 ;
32423 char * kwnames[] = {
32424 (char *) "format", NULL
32425 };
32426
32427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32428 if (obj0) {
32429 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32430 if (!SWIG_IsOK(res1)) {
32431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32432 }
32433 if (!argp1) {
32434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32435 }
32436 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32437 }
32438 {
32439 PyThreadState* __tstate = wxPyBeginAllowThreads();
32440 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32441 wxPyEndAllowThreads(__tstate);
32442 if (PyErr_Occurred()) SWIG_fail;
32443 }
32444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32445 return resultobj;
32446 fail:
32447 return NULL;
32448 }
32449
32450
32451 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32452 PyObject *resultobj = 0;
32453 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32454 wxDataFormat *result = 0 ;
32455 void *argp1 = 0 ;
32456 int res1 = 0 ;
32457 PyObject *swig_obj[1] ;
32458
32459 if (!args) SWIG_fail;
32460 swig_obj[0] = args;
32461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32462 if (!SWIG_IsOK(res1)) {
32463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32464 }
32465 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 {
32469 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32470 result = (wxDataFormat *) &_result_ref;
32471 }
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32476 return resultobj;
32477 fail:
32478 return NULL;
32479 }
32480
32481
32482 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32483 PyObject *resultobj = 0;
32484 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32485 wxDataFormat *arg2 = 0 ;
32486 void *argp1 = 0 ;
32487 int res1 = 0 ;
32488 void *argp2 = 0 ;
32489 int res2 = 0 ;
32490 PyObject * obj0 = 0 ;
32491 PyObject * obj1 = 0 ;
32492 char * kwnames[] = {
32493 (char *) "self",(char *) "format", NULL
32494 };
32495
32496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32498 if (!SWIG_IsOK(res1)) {
32499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32500 }
32501 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32502 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32503 if (!SWIG_IsOK(res2)) {
32504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32505 }
32506 if (!argp2) {
32507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32508 }
32509 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32513 wxPyEndAllowThreads(__tstate);
32514 if (PyErr_Occurred()) SWIG_fail;
32515 }
32516 resultobj = SWIG_Py_Void();
32517 return resultobj;
32518 fail:
32519 return NULL;
32520 }
32521
32522
32523 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32524 PyObject *resultobj = 0;
32525 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32526 size_t result;
32527 void *argp1 = 0 ;
32528 int res1 = 0 ;
32529 PyObject *swig_obj[1] ;
32530
32531 if (!args) SWIG_fail;
32532 swig_obj[0] = args;
32533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32534 if (!SWIG_IsOK(res1)) {
32535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32536 }
32537 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32538 {
32539 PyThreadState* __tstate = wxPyBeginAllowThreads();
32540 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32552 PyObject *resultobj = 0;
32553 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32554 PyObject *result = 0 ;
32555 void *argp1 = 0 ;
32556 int res1 = 0 ;
32557 PyObject *swig_obj[1] ;
32558
32559 if (!args) SWIG_fail;
32560 swig_obj[0] = args;
32561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32562 if (!SWIG_IsOK(res1)) {
32563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32564 }
32565 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32566 {
32567 PyThreadState* __tstate = wxPyBeginAllowThreads();
32568 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32569 wxPyEndAllowThreads(__tstate);
32570 if (PyErr_Occurred()) SWIG_fail;
32571 }
32572 resultobj = result;
32573 return resultobj;
32574 fail:
32575 return NULL;
32576 }
32577
32578
32579 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32580 PyObject *resultobj = 0;
32581 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32582 PyObject *arg2 = (PyObject *) 0 ;
32583 bool result;
32584 void *argp1 = 0 ;
32585 int res1 = 0 ;
32586 PyObject * obj0 = 0 ;
32587 PyObject * obj1 = 0 ;
32588 char * kwnames[] = {
32589 (char *) "self",(char *) "data", NULL
32590 };
32591
32592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32594 if (!SWIG_IsOK(res1)) {
32595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32596 }
32597 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32598 arg2 = obj1;
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32602 wxPyEndAllowThreads(__tstate);
32603 if (PyErr_Occurred()) SWIG_fail;
32604 }
32605 {
32606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32607 }
32608 return resultobj;
32609 fail:
32610 return NULL;
32611 }
32612
32613
32614 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32615 PyObject *obj;
32616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32617 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32618 return SWIG_Py_Void();
32619 }
32620
32621 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32622 return SWIG_Python_InitShadowInstance(args);
32623 }
32624
32625 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32626 PyObject *resultobj = 0;
32627 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32628 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32629 wxPyDataObjectSimple *result = 0 ;
32630 void *argp1 = 0 ;
32631 int res1 = 0 ;
32632 PyObject * obj0 = 0 ;
32633 char * kwnames[] = {
32634 (char *) "format", NULL
32635 };
32636
32637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32638 if (obj0) {
32639 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32640 if (!SWIG_IsOK(res1)) {
32641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32642 }
32643 if (!argp1) {
32644 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32645 }
32646 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32647 }
32648 {
32649 PyThreadState* __tstate = wxPyBeginAllowThreads();
32650 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32651 wxPyEndAllowThreads(__tstate);
32652 if (PyErr_Occurred()) SWIG_fail;
32653 }
32654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32655 return resultobj;
32656 fail:
32657 return NULL;
32658 }
32659
32660
32661 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj = 0;
32663 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32664 PyObject *arg2 = (PyObject *) 0 ;
32665 PyObject *arg3 = (PyObject *) 0 ;
32666 void *argp1 = 0 ;
32667 int res1 = 0 ;
32668 PyObject * obj0 = 0 ;
32669 PyObject * obj1 = 0 ;
32670 PyObject * obj2 = 0 ;
32671 char * kwnames[] = {
32672 (char *) "self",(char *) "self",(char *) "_class", NULL
32673 };
32674
32675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32679 }
32680 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32681 arg2 = obj1;
32682 arg3 = obj2;
32683 {
32684 PyThreadState* __tstate = wxPyBeginAllowThreads();
32685 (arg1)->_setCallbackInfo(arg2,arg3);
32686 wxPyEndAllowThreads(__tstate);
32687 if (PyErr_Occurred()) SWIG_fail;
32688 }
32689 resultobj = SWIG_Py_Void();
32690 return resultobj;
32691 fail:
32692 return NULL;
32693 }
32694
32695
32696 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32697 PyObject *obj;
32698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32699 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32700 return SWIG_Py_Void();
32701 }
32702
32703 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32704 return SWIG_Python_InitShadowInstance(args);
32705 }
32706
32707 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32708 PyObject *resultobj = 0;
32709 wxDataObjectComposite *result = 0 ;
32710
32711 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32712 {
32713 PyThreadState* __tstate = wxPyBeginAllowThreads();
32714 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32726 PyObject *resultobj = 0;
32727 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32728 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32729 bool arg3 = (bool) false ;
32730 void *argp1 = 0 ;
32731 int res1 = 0 ;
32732 int res2 = 0 ;
32733 bool val3 ;
32734 int ecode3 = 0 ;
32735 PyObject * obj0 = 0 ;
32736 PyObject * obj1 = 0 ;
32737 PyObject * obj2 = 0 ;
32738 char * kwnames[] = {
32739 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32740 };
32741
32742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32744 if (!SWIG_IsOK(res1)) {
32745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32746 }
32747 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32748 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32749 if (!SWIG_IsOK(res2)) {
32750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32751 }
32752 if (obj2) {
32753 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32754 if (!SWIG_IsOK(ecode3)) {
32755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32756 }
32757 arg3 = static_cast< bool >(val3);
32758 }
32759 {
32760 PyThreadState* __tstate = wxPyBeginAllowThreads();
32761 (arg1)->Add(arg2,arg3);
32762 wxPyEndAllowThreads(__tstate);
32763 if (PyErr_Occurred()) SWIG_fail;
32764 }
32765 resultobj = SWIG_Py_Void();
32766 return resultobj;
32767 fail:
32768 return NULL;
32769 }
32770
32771
32772 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32773 PyObject *resultobj = 0;
32774 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32775 SwigValueWrapper<wxDataFormat > result;
32776 void *argp1 = 0 ;
32777 int res1 = 0 ;
32778 PyObject *swig_obj[1] ;
32779
32780 if (!args) SWIG_fail;
32781 swig_obj[0] = args;
32782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32783 if (!SWIG_IsOK(res1)) {
32784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32785 }
32786 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32787 {
32788 PyThreadState* __tstate = wxPyBeginAllowThreads();
32789 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32790 wxPyEndAllowThreads(__tstate);
32791 if (PyErr_Occurred()) SWIG_fail;
32792 }
32793 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32794 return resultobj;
32795 fail:
32796 return NULL;
32797 }
32798
32799
32800 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32801 PyObject *obj;
32802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32803 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32804 return SWIG_Py_Void();
32805 }
32806
32807 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32808 return SWIG_Python_InitShadowInstance(args);
32809 }
32810
32811 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32812 PyObject *resultobj = 0;
32813 wxString const &arg1_defvalue = wxPyEmptyString ;
32814 wxString *arg1 = (wxString *) &arg1_defvalue ;
32815 wxTextDataObject *result = 0 ;
32816 bool temp1 = false ;
32817 PyObject * obj0 = 0 ;
32818 char * kwnames[] = {
32819 (char *) "text", NULL
32820 };
32821
32822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32823 if (obj0) {
32824 {
32825 arg1 = wxString_in_helper(obj0);
32826 if (arg1 == NULL) SWIG_fail;
32827 temp1 = true;
32828 }
32829 }
32830 {
32831 PyThreadState* __tstate = wxPyBeginAllowThreads();
32832 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32833 wxPyEndAllowThreads(__tstate);
32834 if (PyErr_Occurred()) SWIG_fail;
32835 }
32836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32837 {
32838 if (temp1)
32839 delete arg1;
32840 }
32841 return resultobj;
32842 fail:
32843 {
32844 if (temp1)
32845 delete arg1;
32846 }
32847 return NULL;
32848 }
32849
32850
32851 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32852 PyObject *resultobj = 0;
32853 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32854 size_t result;
32855 void *argp1 = 0 ;
32856 int res1 = 0 ;
32857 PyObject *swig_obj[1] ;
32858
32859 if (!args) SWIG_fail;
32860 swig_obj[0] = args;
32861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32862 if (!SWIG_IsOK(res1)) {
32863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32864 }
32865 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32866 {
32867 PyThreadState* __tstate = wxPyBeginAllowThreads();
32868 result = (size_t)(arg1)->GetTextLength();
32869 wxPyEndAllowThreads(__tstate);
32870 if (PyErr_Occurred()) SWIG_fail;
32871 }
32872 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32873 return resultobj;
32874 fail:
32875 return NULL;
32876 }
32877
32878
32879 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32880 PyObject *resultobj = 0;
32881 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32882 wxString result;
32883 void *argp1 = 0 ;
32884 int res1 = 0 ;
32885 PyObject *swig_obj[1] ;
32886
32887 if (!args) SWIG_fail;
32888 swig_obj[0] = args;
32889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32890 if (!SWIG_IsOK(res1)) {
32891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32892 }
32893 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32894 {
32895 PyThreadState* __tstate = wxPyBeginAllowThreads();
32896 result = (arg1)->GetText();
32897 wxPyEndAllowThreads(__tstate);
32898 if (PyErr_Occurred()) SWIG_fail;
32899 }
32900 {
32901 #if wxUSE_UNICODE
32902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32903 #else
32904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32905 #endif
32906 }
32907 return resultobj;
32908 fail:
32909 return NULL;
32910 }
32911
32912
32913 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32914 PyObject *resultobj = 0;
32915 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32916 wxString *arg2 = 0 ;
32917 void *argp1 = 0 ;
32918 int res1 = 0 ;
32919 bool temp2 = false ;
32920 PyObject * obj0 = 0 ;
32921 PyObject * obj1 = 0 ;
32922 char * kwnames[] = {
32923 (char *) "self",(char *) "text", NULL
32924 };
32925
32926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32928 if (!SWIG_IsOK(res1)) {
32929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32930 }
32931 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32932 {
32933 arg2 = wxString_in_helper(obj1);
32934 if (arg2 == NULL) SWIG_fail;
32935 temp2 = true;
32936 }
32937 {
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 (arg1)->SetText((wxString const &)*arg2);
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 resultobj = SWIG_Py_Void();
32944 {
32945 if (temp2)
32946 delete arg2;
32947 }
32948 return resultobj;
32949 fail:
32950 {
32951 if (temp2)
32952 delete arg2;
32953 }
32954 return NULL;
32955 }
32956
32957
32958 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32959 PyObject *obj;
32960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32961 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32962 return SWIG_Py_Void();
32963 }
32964
32965 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32966 return SWIG_Python_InitShadowInstance(args);
32967 }
32968
32969 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32970 PyObject *resultobj = 0;
32971 wxString const &arg1_defvalue = wxPyEmptyString ;
32972 wxString *arg1 = (wxString *) &arg1_defvalue ;
32973 wxPyTextDataObject *result = 0 ;
32974 bool temp1 = false ;
32975 PyObject * obj0 = 0 ;
32976 char * kwnames[] = {
32977 (char *) "text", NULL
32978 };
32979
32980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32981 if (obj0) {
32982 {
32983 arg1 = wxString_in_helper(obj0);
32984 if (arg1 == NULL) SWIG_fail;
32985 temp1 = true;
32986 }
32987 }
32988 {
32989 PyThreadState* __tstate = wxPyBeginAllowThreads();
32990 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32991 wxPyEndAllowThreads(__tstate);
32992 if (PyErr_Occurred()) SWIG_fail;
32993 }
32994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32995 {
32996 if (temp1)
32997 delete arg1;
32998 }
32999 return resultobj;
33000 fail:
33001 {
33002 if (temp1)
33003 delete arg1;
33004 }
33005 return NULL;
33006 }
33007
33008
33009 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33010 PyObject *resultobj = 0;
33011 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
33012 PyObject *arg2 = (PyObject *) 0 ;
33013 PyObject *arg3 = (PyObject *) 0 ;
33014 void *argp1 = 0 ;
33015 int res1 = 0 ;
33016 PyObject * obj0 = 0 ;
33017 PyObject * obj1 = 0 ;
33018 PyObject * obj2 = 0 ;
33019 char * kwnames[] = {
33020 (char *) "self",(char *) "self",(char *) "_class", NULL
33021 };
33022
33023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
33025 if (!SWIG_IsOK(res1)) {
33026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
33027 }
33028 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
33029 arg2 = obj1;
33030 arg3 = obj2;
33031 {
33032 PyThreadState* __tstate = wxPyBeginAllowThreads();
33033 (arg1)->_setCallbackInfo(arg2,arg3);
33034 wxPyEndAllowThreads(__tstate);
33035 if (PyErr_Occurred()) SWIG_fail;
33036 }
33037 resultobj = SWIG_Py_Void();
33038 return resultobj;
33039 fail:
33040 return NULL;
33041 }
33042
33043
33044 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33045 PyObject *obj;
33046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33047 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
33048 return SWIG_Py_Void();
33049 }
33050
33051 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33052 return SWIG_Python_InitShadowInstance(args);
33053 }
33054
33055 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33056 PyObject *resultobj = 0;
33057 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33058 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33059 wxBitmapDataObject *result = 0 ;
33060 void *argp1 = 0 ;
33061 int res1 = 0 ;
33062 PyObject * obj0 = 0 ;
33063 char * kwnames[] = {
33064 (char *) "bitmap", NULL
33065 };
33066
33067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33068 if (obj0) {
33069 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33070 if (!SWIG_IsOK(res1)) {
33071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33072 }
33073 if (!argp1) {
33074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33075 }
33076 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33077 }
33078 {
33079 PyThreadState* __tstate = wxPyBeginAllowThreads();
33080 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33081 wxPyEndAllowThreads(__tstate);
33082 if (PyErr_Occurred()) SWIG_fail;
33083 }
33084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33085 return resultobj;
33086 fail:
33087 return NULL;
33088 }
33089
33090
33091 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33092 PyObject *resultobj = 0;
33093 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33094 wxBitmap result;
33095 void *argp1 = 0 ;
33096 int res1 = 0 ;
33097 PyObject *swig_obj[1] ;
33098
33099 if (!args) SWIG_fail;
33100 swig_obj[0] = args;
33101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33102 if (!SWIG_IsOK(res1)) {
33103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33104 }
33105 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33109 wxPyEndAllowThreads(__tstate);
33110 if (PyErr_Occurred()) SWIG_fail;
33111 }
33112 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33113 return resultobj;
33114 fail:
33115 return NULL;
33116 }
33117
33118
33119 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33120 PyObject *resultobj = 0;
33121 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33122 wxBitmap *arg2 = 0 ;
33123 void *argp1 = 0 ;
33124 int res1 = 0 ;
33125 void *argp2 = 0 ;
33126 int res2 = 0 ;
33127 PyObject * obj0 = 0 ;
33128 PyObject * obj1 = 0 ;
33129 char * kwnames[] = {
33130 (char *) "self",(char *) "bitmap", NULL
33131 };
33132
33133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33135 if (!SWIG_IsOK(res1)) {
33136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33137 }
33138 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33139 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33140 if (!SWIG_IsOK(res2)) {
33141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33142 }
33143 if (!argp2) {
33144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33145 }
33146 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33147 {
33148 PyThreadState* __tstate = wxPyBeginAllowThreads();
33149 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33150 wxPyEndAllowThreads(__tstate);
33151 if (PyErr_Occurred()) SWIG_fail;
33152 }
33153 resultobj = SWIG_Py_Void();
33154 return resultobj;
33155 fail:
33156 return NULL;
33157 }
33158
33159
33160 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33161 PyObject *obj;
33162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33163 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33164 return SWIG_Py_Void();
33165 }
33166
33167 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33168 return SWIG_Python_InitShadowInstance(args);
33169 }
33170
33171 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33172 PyObject *resultobj = 0;
33173 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33174 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33175 wxPyBitmapDataObject *result = 0 ;
33176 void *argp1 = 0 ;
33177 int res1 = 0 ;
33178 PyObject * obj0 = 0 ;
33179 char * kwnames[] = {
33180 (char *) "bitmap", NULL
33181 };
33182
33183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33184 if (obj0) {
33185 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33186 if (!SWIG_IsOK(res1)) {
33187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33188 }
33189 if (!argp1) {
33190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33191 }
33192 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33193 }
33194 {
33195 PyThreadState* __tstate = wxPyBeginAllowThreads();
33196 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33197 wxPyEndAllowThreads(__tstate);
33198 if (PyErr_Occurred()) SWIG_fail;
33199 }
33200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33201 return resultobj;
33202 fail:
33203 return NULL;
33204 }
33205
33206
33207 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33208 PyObject *resultobj = 0;
33209 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33210 PyObject *arg2 = (PyObject *) 0 ;
33211 PyObject *arg3 = (PyObject *) 0 ;
33212 void *argp1 = 0 ;
33213 int res1 = 0 ;
33214 PyObject * obj0 = 0 ;
33215 PyObject * obj1 = 0 ;
33216 PyObject * obj2 = 0 ;
33217 char * kwnames[] = {
33218 (char *) "self",(char *) "self",(char *) "_class", NULL
33219 };
33220
33221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33223 if (!SWIG_IsOK(res1)) {
33224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33225 }
33226 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33227 arg2 = obj1;
33228 arg3 = obj2;
33229 {
33230 PyThreadState* __tstate = wxPyBeginAllowThreads();
33231 (arg1)->_setCallbackInfo(arg2,arg3);
33232 wxPyEndAllowThreads(__tstate);
33233 if (PyErr_Occurred()) SWIG_fail;
33234 }
33235 resultobj = SWIG_Py_Void();
33236 return resultobj;
33237 fail:
33238 return NULL;
33239 }
33240
33241
33242 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33243 PyObject *obj;
33244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33245 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33246 return SWIG_Py_Void();
33247 }
33248
33249 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33250 return SWIG_Python_InitShadowInstance(args);
33251 }
33252
33253 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33254 PyObject *resultobj = 0;
33255 wxFileDataObject *result = 0 ;
33256
33257 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33258 {
33259 PyThreadState* __tstate = wxPyBeginAllowThreads();
33260 result = (wxFileDataObject *)new wxFileDataObject();
33261 wxPyEndAllowThreads(__tstate);
33262 if (PyErr_Occurred()) SWIG_fail;
33263 }
33264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33265 return resultobj;
33266 fail:
33267 return NULL;
33268 }
33269
33270
33271 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33272 PyObject *resultobj = 0;
33273 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33274 wxArrayString *result = 0 ;
33275 void *argp1 = 0 ;
33276 int res1 = 0 ;
33277 PyObject *swig_obj[1] ;
33278
33279 if (!args) SWIG_fail;
33280 swig_obj[0] = args;
33281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33282 if (!SWIG_IsOK(res1)) {
33283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33284 }
33285 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33286 {
33287 PyThreadState* __tstate = wxPyBeginAllowThreads();
33288 {
33289 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33290 result = (wxArrayString *) &_result_ref;
33291 }
33292 wxPyEndAllowThreads(__tstate);
33293 if (PyErr_Occurred()) SWIG_fail;
33294 }
33295 {
33296 resultobj = wxArrayString2PyList_helper(*result);
33297 }
33298 return resultobj;
33299 fail:
33300 return NULL;
33301 }
33302
33303
33304 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33305 PyObject *resultobj = 0;
33306 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33307 wxString *arg2 = 0 ;
33308 void *argp1 = 0 ;
33309 int res1 = 0 ;
33310 bool temp2 = false ;
33311 PyObject * obj0 = 0 ;
33312 PyObject * obj1 = 0 ;
33313 char * kwnames[] = {
33314 (char *) "self",(char *) "filename", NULL
33315 };
33316
33317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33319 if (!SWIG_IsOK(res1)) {
33320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33321 }
33322 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33323 {
33324 arg2 = wxString_in_helper(obj1);
33325 if (arg2 == NULL) SWIG_fail;
33326 temp2 = true;
33327 }
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 (arg1)->AddFile((wxString const &)*arg2);
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 resultobj = SWIG_Py_Void();
33335 {
33336 if (temp2)
33337 delete arg2;
33338 }
33339 return resultobj;
33340 fail:
33341 {
33342 if (temp2)
33343 delete arg2;
33344 }
33345 return NULL;
33346 }
33347
33348
33349 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33350 PyObject *obj;
33351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33352 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33353 return SWIG_Py_Void();
33354 }
33355
33356 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33357 return SWIG_Python_InitShadowInstance(args);
33358 }
33359
33360 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33361 PyObject *resultobj = 0;
33362 wxDataFormat *arg1 = 0 ;
33363 wxCustomDataObject *result = 0 ;
33364 void *argp1 = 0 ;
33365 int res1 = 0 ;
33366
33367 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33369 if (!SWIG_IsOK(res1)) {
33370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33371 }
33372 if (!argp1) {
33373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33374 }
33375 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33376 {
33377 PyThreadState* __tstate = wxPyBeginAllowThreads();
33378 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33379 wxPyEndAllowThreads(__tstate);
33380 if (PyErr_Occurred()) SWIG_fail;
33381 }
33382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33383 return resultobj;
33384 fail:
33385 return NULL;
33386 }
33387
33388
33389 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33390 PyObject *resultobj = 0;
33391 wxString *arg1 = 0 ;
33392 wxCustomDataObject *result = 0 ;
33393 bool temp1 = false ;
33394
33395 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33396 {
33397 arg1 = wxString_in_helper(swig_obj[0]);
33398 if (arg1 == NULL) SWIG_fail;
33399 temp1 = true;
33400 }
33401 {
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33404 wxPyEndAllowThreads(__tstate);
33405 if (PyErr_Occurred()) SWIG_fail;
33406 }
33407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33408 {
33409 if (temp1)
33410 delete arg1;
33411 }
33412 return resultobj;
33413 fail:
33414 {
33415 if (temp1)
33416 delete arg1;
33417 }
33418 return NULL;
33419 }
33420
33421
33422 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33423 PyObject *resultobj = 0;
33424 wxCustomDataObject *result = 0 ;
33425
33426 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 result = (wxCustomDataObject *)new wxCustomDataObject();
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33434 return resultobj;
33435 fail:
33436 return NULL;
33437 }
33438
33439
33440 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33441 int argc;
33442 PyObject *argv[2];
33443
33444 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33445 --argc;
33446 if (argc == 0) {
33447 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33448 }
33449 if (argc == 1) {
33450 int _v = 0;
33451 {
33452 {
33453 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33454 }
33455 }
33456 if (!_v) goto check_2;
33457 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33458 }
33459 check_2:
33460
33461 if (argc == 1) {
33462 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33463 }
33464
33465 fail:
33466 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33467 return NULL;
33468 }
33469
33470
33471 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33472 PyObject *resultobj = 0;
33473 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33474 PyObject *arg2 = (PyObject *) 0 ;
33475 bool result;
33476 void *argp1 = 0 ;
33477 int res1 = 0 ;
33478 PyObject * obj0 = 0 ;
33479 PyObject * obj1 = 0 ;
33480 char * kwnames[] = {
33481 (char *) "self",(char *) "data", NULL
33482 };
33483
33484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33486 if (!SWIG_IsOK(res1)) {
33487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33488 }
33489 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33490 arg2 = obj1;
33491 {
33492 PyThreadState* __tstate = wxPyBeginAllowThreads();
33493 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33494 wxPyEndAllowThreads(__tstate);
33495 if (PyErr_Occurred()) SWIG_fail;
33496 }
33497 {
33498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33499 }
33500 return resultobj;
33501 fail:
33502 return NULL;
33503 }
33504
33505
33506 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33507 PyObject *resultobj = 0;
33508 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33509 size_t result;
33510 void *argp1 = 0 ;
33511 int res1 = 0 ;
33512 PyObject *swig_obj[1] ;
33513
33514 if (!args) SWIG_fail;
33515 swig_obj[0] = args;
33516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33517 if (!SWIG_IsOK(res1)) {
33518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33519 }
33520 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33521 {
33522 PyThreadState* __tstate = wxPyBeginAllowThreads();
33523 result = (size_t)(arg1)->GetSize();
33524 wxPyEndAllowThreads(__tstate);
33525 if (PyErr_Occurred()) SWIG_fail;
33526 }
33527 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33528 return resultobj;
33529 fail:
33530 return NULL;
33531 }
33532
33533
33534 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33535 PyObject *resultobj = 0;
33536 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33537 PyObject *result = 0 ;
33538 void *argp1 = 0 ;
33539 int res1 = 0 ;
33540 PyObject *swig_obj[1] ;
33541
33542 if (!args) SWIG_fail;
33543 swig_obj[0] = args;
33544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33545 if (!SWIG_IsOK(res1)) {
33546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33547 }
33548 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33549 {
33550 PyThreadState* __tstate = wxPyBeginAllowThreads();
33551 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33552 wxPyEndAllowThreads(__tstate);
33553 if (PyErr_Occurred()) SWIG_fail;
33554 }
33555 resultobj = result;
33556 return resultobj;
33557 fail:
33558 return NULL;
33559 }
33560
33561
33562 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33563 PyObject *obj;
33564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33565 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33566 return SWIG_Py_Void();
33567 }
33568
33569 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33570 return SWIG_Python_InitShadowInstance(args);
33571 }
33572
33573 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33574 PyObject *resultobj = 0;
33575 wxString const &arg1_defvalue = wxPyEmptyString ;
33576 wxString *arg1 = (wxString *) &arg1_defvalue ;
33577 wxURLDataObject *result = 0 ;
33578 bool temp1 = false ;
33579 PyObject * obj0 = 0 ;
33580 char * kwnames[] = {
33581 (char *) "url", NULL
33582 };
33583
33584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33585 if (obj0) {
33586 {
33587 arg1 = wxString_in_helper(obj0);
33588 if (arg1 == NULL) SWIG_fail;
33589 temp1 = true;
33590 }
33591 }
33592 {
33593 PyThreadState* __tstate = wxPyBeginAllowThreads();
33594 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33595 wxPyEndAllowThreads(__tstate);
33596 if (PyErr_Occurred()) SWIG_fail;
33597 }
33598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33599 {
33600 if (temp1)
33601 delete arg1;
33602 }
33603 return resultobj;
33604 fail:
33605 {
33606 if (temp1)
33607 delete arg1;
33608 }
33609 return NULL;
33610 }
33611
33612
33613 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33614 PyObject *resultobj = 0;
33615 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33616 wxString result;
33617 void *argp1 = 0 ;
33618 int res1 = 0 ;
33619 PyObject *swig_obj[1] ;
33620
33621 if (!args) SWIG_fail;
33622 swig_obj[0] = args;
33623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33624 if (!SWIG_IsOK(res1)) {
33625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33626 }
33627 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33628 {
33629 PyThreadState* __tstate = wxPyBeginAllowThreads();
33630 result = (arg1)->GetURL();
33631 wxPyEndAllowThreads(__tstate);
33632 if (PyErr_Occurred()) SWIG_fail;
33633 }
33634 {
33635 #if wxUSE_UNICODE
33636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33637 #else
33638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33639 #endif
33640 }
33641 return resultobj;
33642 fail:
33643 return NULL;
33644 }
33645
33646
33647 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33648 PyObject *resultobj = 0;
33649 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33650 wxString *arg2 = 0 ;
33651 void *argp1 = 0 ;
33652 int res1 = 0 ;
33653 bool temp2 = false ;
33654 PyObject * obj0 = 0 ;
33655 PyObject * obj1 = 0 ;
33656 char * kwnames[] = {
33657 (char *) "self",(char *) "url", NULL
33658 };
33659
33660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33662 if (!SWIG_IsOK(res1)) {
33663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33664 }
33665 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33666 {
33667 arg2 = wxString_in_helper(obj1);
33668 if (arg2 == NULL) SWIG_fail;
33669 temp2 = true;
33670 }
33671 {
33672 PyThreadState* __tstate = wxPyBeginAllowThreads();
33673 (arg1)->SetURL((wxString const &)*arg2);
33674 wxPyEndAllowThreads(__tstate);
33675 if (PyErr_Occurred()) SWIG_fail;
33676 }
33677 resultobj = SWIG_Py_Void();
33678 {
33679 if (temp2)
33680 delete arg2;
33681 }
33682 return resultobj;
33683 fail:
33684 {
33685 if (temp2)
33686 delete arg2;
33687 }
33688 return NULL;
33689 }
33690
33691
33692 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33693 PyObject *obj;
33694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33695 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33696 return SWIG_Py_Void();
33697 }
33698
33699 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33700 return SWIG_Python_InitShadowInstance(args);
33701 }
33702
33703 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33704 PyObject *resultobj = 0;
33705 wxMetafileDataObject *result = 0 ;
33706
33707 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33715 return resultobj;
33716 fail:
33717 return NULL;
33718 }
33719
33720
33721 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33722 PyObject *resultobj = 0;
33723 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33724 wxMetafile *arg2 = 0 ;
33725 void *argp1 = 0 ;
33726 int res1 = 0 ;
33727 void *argp2 = 0 ;
33728 int res2 = 0 ;
33729 PyObject * obj0 = 0 ;
33730 PyObject * obj1 = 0 ;
33731 char * kwnames[] = {
33732 (char *) "self",(char *) "metafile", NULL
33733 };
33734
33735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33737 if (!SWIG_IsOK(res1)) {
33738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33739 }
33740 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33742 if (!SWIG_IsOK(res2)) {
33743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33744 }
33745 if (!argp2) {
33746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33747 }
33748 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33752 wxPyEndAllowThreads(__tstate);
33753 if (PyErr_Occurred()) SWIG_fail;
33754 }
33755 resultobj = SWIG_Py_Void();
33756 return resultobj;
33757 fail:
33758 return NULL;
33759 }
33760
33761
33762 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33763 PyObject *resultobj = 0;
33764 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33765 wxMetafile result;
33766 void *argp1 = 0 ;
33767 int res1 = 0 ;
33768 PyObject *swig_obj[1] ;
33769
33770 if (!args) SWIG_fail;
33771 swig_obj[0] = args;
33772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33773 if (!SWIG_IsOK(res1)) {
33774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33775 }
33776 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33777 {
33778 PyThreadState* __tstate = wxPyBeginAllowThreads();
33779 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33780 wxPyEndAllowThreads(__tstate);
33781 if (PyErr_Occurred()) SWIG_fail;
33782 }
33783 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33784 return resultobj;
33785 fail:
33786 return NULL;
33787 }
33788
33789
33790 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33791 PyObject *obj;
33792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33793 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33794 return SWIG_Py_Void();
33795 }
33796
33797 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33798 return SWIG_Python_InitShadowInstance(args);
33799 }
33800
33801 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33802 PyObject *resultobj = 0;
33803 wxDragResult arg1 ;
33804 bool result;
33805 int val1 ;
33806 int ecode1 = 0 ;
33807 PyObject * obj0 = 0 ;
33808 char * kwnames[] = {
33809 (char *) "res", NULL
33810 };
33811
33812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33813 ecode1 = SWIG_AsVal_int(obj0, &val1);
33814 if (!SWIG_IsOK(ecode1)) {
33815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33816 }
33817 arg1 = static_cast< wxDragResult >(val1);
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 result = (bool)wxIsDragResultOk(arg1);
33821 wxPyEndAllowThreads(__tstate);
33822 if (PyErr_Occurred()) SWIG_fail;
33823 }
33824 {
33825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33826 }
33827 return resultobj;
33828 fail:
33829 return NULL;
33830 }
33831
33832
33833 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33834 PyObject *resultobj = 0;
33835 wxWindow *arg1 = (wxWindow *) 0 ;
33836 wxCursor const &arg2_defvalue = wxNullCursor ;
33837 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33838 wxCursor const &arg3_defvalue = wxNullCursor ;
33839 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33840 wxCursor const &arg4_defvalue = wxNullCursor ;
33841 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33842 wxPyDropSource *result = 0 ;
33843 void *argp1 = 0 ;
33844 int res1 = 0 ;
33845 void *argp2 = 0 ;
33846 int res2 = 0 ;
33847 void *argp3 = 0 ;
33848 int res3 = 0 ;
33849 void *argp4 = 0 ;
33850 int res4 = 0 ;
33851 PyObject * obj0 = 0 ;
33852 PyObject * obj1 = 0 ;
33853 PyObject * obj2 = 0 ;
33854 PyObject * obj3 = 0 ;
33855 char * kwnames[] = {
33856 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33857 };
33858
33859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33861 if (!SWIG_IsOK(res1)) {
33862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33863 }
33864 arg1 = reinterpret_cast< wxWindow * >(argp1);
33865 if (obj1) {
33866 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33867 if (!SWIG_IsOK(res2)) {
33868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33869 }
33870 if (!argp2) {
33871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33872 }
33873 arg2 = reinterpret_cast< wxCursor * >(argp2);
33874 }
33875 if (obj2) {
33876 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33877 if (!SWIG_IsOK(res3)) {
33878 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33879 }
33880 if (!argp3) {
33881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33882 }
33883 arg3 = reinterpret_cast< wxCursor * >(argp3);
33884 }
33885 if (obj3) {
33886 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33887 if (!SWIG_IsOK(res4)) {
33888 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33889 }
33890 if (!argp4) {
33891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33892 }
33893 arg4 = reinterpret_cast< wxCursor * >(argp4);
33894 }
33895 {
33896 PyThreadState* __tstate = wxPyBeginAllowThreads();
33897 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33898 wxPyEndAllowThreads(__tstate);
33899 if (PyErr_Occurred()) SWIG_fail;
33900 }
33901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33902 return resultobj;
33903 fail:
33904 return NULL;
33905 }
33906
33907
33908 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33909 PyObject *resultobj = 0;
33910 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33911 PyObject *arg2 = (PyObject *) 0 ;
33912 PyObject *arg3 = (PyObject *) 0 ;
33913 int arg4 = (int) 0 ;
33914 void *argp1 = 0 ;
33915 int res1 = 0 ;
33916 int val4 ;
33917 int ecode4 = 0 ;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 PyObject * obj2 = 0 ;
33921 PyObject * obj3 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33928 if (!SWIG_IsOK(res1)) {
33929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33930 }
33931 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33932 arg2 = obj1;
33933 arg3 = obj2;
33934 if (obj3) {
33935 ecode4 = SWIG_AsVal_int(obj3, &val4);
33936 if (!SWIG_IsOK(ecode4)) {
33937 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33938 }
33939 arg4 = static_cast< int >(val4);
33940 }
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33944 wxPyEndAllowThreads(__tstate);
33945 if (PyErr_Occurred()) SWIG_fail;
33946 }
33947 resultobj = SWIG_Py_Void();
33948 return resultobj;
33949 fail:
33950 return NULL;
33951 }
33952
33953
33954 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33955 PyObject *resultobj = 0;
33956 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33957 void *argp1 = 0 ;
33958 int res1 = 0 ;
33959 PyObject *swig_obj[1] ;
33960
33961 if (!args) SWIG_fail;
33962 swig_obj[0] = args;
33963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33966 }
33967 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33968 {
33969 PyThreadState* __tstate = wxPyBeginAllowThreads();
33970 delete arg1;
33971
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 resultobj = SWIG_Py_Void();
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33983 PyObject *resultobj = 0;
33984 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33985 wxDataObject *arg2 = 0 ;
33986 void *argp1 = 0 ;
33987 int res1 = 0 ;
33988 void *argp2 = 0 ;
33989 int res2 = 0 ;
33990 PyObject * obj0 = 0 ;
33991 PyObject * obj1 = 0 ;
33992 char * kwnames[] = {
33993 (char *) "self",(char *) "data", NULL
33994 };
33995
33996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33998 if (!SWIG_IsOK(res1)) {
33999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34000 }
34001 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34002 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34003 if (!SWIG_IsOK(res2)) {
34004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34005 }
34006 if (!argp2) {
34007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34008 }
34009 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34010 {
34011 PyThreadState* __tstate = wxPyBeginAllowThreads();
34012 (arg1)->SetData(*arg2);
34013 wxPyEndAllowThreads(__tstate);
34014 if (PyErr_Occurred()) SWIG_fail;
34015 }
34016 resultobj = SWIG_Py_Void();
34017 return resultobj;
34018 fail:
34019 return NULL;
34020 }
34021
34022
34023 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34024 PyObject *resultobj = 0;
34025 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34026 wxDataObject *result = 0 ;
34027 void *argp1 = 0 ;
34028 int res1 = 0 ;
34029 PyObject *swig_obj[1] ;
34030
34031 if (!args) SWIG_fail;
34032 swig_obj[0] = args;
34033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34034 if (!SWIG_IsOK(res1)) {
34035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34036 }
34037 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34038 {
34039 PyThreadState* __tstate = wxPyBeginAllowThreads();
34040 result = (wxDataObject *)(arg1)->GetDataObject();
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34045 return resultobj;
34046 fail:
34047 return NULL;
34048 }
34049
34050
34051 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34052 PyObject *resultobj = 0;
34053 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34054 wxDragResult arg2 ;
34055 wxCursor *arg3 = 0 ;
34056 void *argp1 = 0 ;
34057 int res1 = 0 ;
34058 int val2 ;
34059 int ecode2 = 0 ;
34060 void *argp3 = 0 ;
34061 int res3 = 0 ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 PyObject * obj2 = 0 ;
34065 char * kwnames[] = {
34066 (char *) "self",(char *) "res",(char *) "cursor", NULL
34067 };
34068
34069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34071 if (!SWIG_IsOK(res1)) {
34072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34073 }
34074 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34075 ecode2 = SWIG_AsVal_int(obj1, &val2);
34076 if (!SWIG_IsOK(ecode2)) {
34077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34078 }
34079 arg2 = static_cast< wxDragResult >(val2);
34080 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34081 if (!SWIG_IsOK(res3)) {
34082 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34083 }
34084 if (!argp3) {
34085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34086 }
34087 arg3 = reinterpret_cast< wxCursor * >(argp3);
34088 {
34089 PyThreadState* __tstate = wxPyBeginAllowThreads();
34090 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34091 wxPyEndAllowThreads(__tstate);
34092 if (PyErr_Occurred()) SWIG_fail;
34093 }
34094 resultobj = SWIG_Py_Void();
34095 return resultobj;
34096 fail:
34097 return NULL;
34098 }
34099
34100
34101 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34102 PyObject *resultobj = 0;
34103 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34104 int arg2 = (int) wxDrag_CopyOnly ;
34105 wxDragResult result;
34106 void *argp1 = 0 ;
34107 int res1 = 0 ;
34108 int val2 ;
34109 int ecode2 = 0 ;
34110 PyObject * obj0 = 0 ;
34111 PyObject * obj1 = 0 ;
34112 char * kwnames[] = {
34113 (char *) "self",(char *) "flags", NULL
34114 };
34115
34116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34120 }
34121 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34122 if (obj1) {
34123 ecode2 = SWIG_AsVal_int(obj1, &val2);
34124 if (!SWIG_IsOK(ecode2)) {
34125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34126 }
34127 arg2 = static_cast< int >(val2);
34128 }
34129 {
34130 PyThreadState* __tstate = wxPyBeginAllowThreads();
34131 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34132 wxPyEndAllowThreads(__tstate);
34133 if (PyErr_Occurred()) SWIG_fail;
34134 }
34135 resultobj = SWIG_From_int(static_cast< int >(result));
34136 return resultobj;
34137 fail:
34138 return NULL;
34139 }
34140
34141
34142 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34143 PyObject *resultobj = 0;
34144 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34145 wxDragResult arg2 ;
34146 bool result;
34147 void *argp1 = 0 ;
34148 int res1 = 0 ;
34149 int val2 ;
34150 int ecode2 = 0 ;
34151 PyObject * obj0 = 0 ;
34152 PyObject * obj1 = 0 ;
34153 char * kwnames[] = {
34154 (char *) "self",(char *) "effect", NULL
34155 };
34156
34157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34159 if (!SWIG_IsOK(res1)) {
34160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34161 }
34162 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34163 ecode2 = SWIG_AsVal_int(obj1, &val2);
34164 if (!SWIG_IsOK(ecode2)) {
34165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34166 }
34167 arg2 = static_cast< wxDragResult >(val2);
34168 {
34169 PyThreadState* __tstate = wxPyBeginAllowThreads();
34170 result = (bool)(arg1)->GiveFeedback(arg2);
34171 wxPyEndAllowThreads(__tstate);
34172 if (PyErr_Occurred()) SWIG_fail;
34173 }
34174 {
34175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34176 }
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34184 PyObject *obj;
34185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34186 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34187 return SWIG_Py_Void();
34188 }
34189
34190 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34191 return SWIG_Python_InitShadowInstance(args);
34192 }
34193
34194 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34195 PyObject *resultobj = 0;
34196 wxDataObject *arg1 = (wxDataObject *) NULL ;
34197 wxPyDropTarget *result = 0 ;
34198 int res1 = 0 ;
34199 PyObject * obj0 = 0 ;
34200 char * kwnames[] = {
34201 (char *) "dataObject", NULL
34202 };
34203
34204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34205 if (obj0) {
34206 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34209 }
34210 }
34211 {
34212 PyThreadState* __tstate = wxPyBeginAllowThreads();
34213 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34225 PyObject *resultobj = 0;
34226 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34227 PyObject *arg2 = (PyObject *) 0 ;
34228 PyObject *arg3 = (PyObject *) 0 ;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 PyObject * obj0 = 0 ;
34232 PyObject * obj1 = 0 ;
34233 PyObject * obj2 = 0 ;
34234 char * kwnames[] = {
34235 (char *) "self",(char *) "self",(char *) "_class", NULL
34236 };
34237
34238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34240 if (!SWIG_IsOK(res1)) {
34241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34242 }
34243 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34244 arg2 = obj1;
34245 arg3 = obj2;
34246 {
34247 PyThreadState* __tstate = wxPyBeginAllowThreads();
34248 (arg1)->_setCallbackInfo(arg2,arg3);
34249 wxPyEndAllowThreads(__tstate);
34250 if (PyErr_Occurred()) SWIG_fail;
34251 }
34252 resultobj = SWIG_Py_Void();
34253 return resultobj;
34254 fail:
34255 return NULL;
34256 }
34257
34258
34259 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34260 PyObject *resultobj = 0;
34261 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34262 void *argp1 = 0 ;
34263 int res1 = 0 ;
34264 PyObject *swig_obj[1] ;
34265
34266 if (!args) SWIG_fail;
34267 swig_obj[0] = args;
34268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34269 if (!SWIG_IsOK(res1)) {
34270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34271 }
34272 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 delete arg1;
34276
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 resultobj = SWIG_Py_Void();
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34288 PyObject *resultobj = 0;
34289 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34290 wxDataObject *result = 0 ;
34291 void *argp1 = 0 ;
34292 int res1 = 0 ;
34293 PyObject *swig_obj[1] ;
34294
34295 if (!args) SWIG_fail;
34296 swig_obj[0] = args;
34297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34298 if (!SWIG_IsOK(res1)) {
34299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34300 }
34301 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34302 {
34303 PyThreadState* __tstate = wxPyBeginAllowThreads();
34304 result = (wxDataObject *)(arg1)->GetDataObject();
34305 wxPyEndAllowThreads(__tstate);
34306 if (PyErr_Occurred()) SWIG_fail;
34307 }
34308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34309 return resultobj;
34310 fail:
34311 return NULL;
34312 }
34313
34314
34315 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34316 PyObject *resultobj = 0;
34317 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34318 wxDataObject *arg2 = (wxDataObject *) 0 ;
34319 void *argp1 = 0 ;
34320 int res1 = 0 ;
34321 int res2 = 0 ;
34322 PyObject * obj0 = 0 ;
34323 PyObject * obj1 = 0 ;
34324 char * kwnames[] = {
34325 (char *) "self",(char *) "dataObject", NULL
34326 };
34327
34328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34330 if (!SWIG_IsOK(res1)) {
34331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34332 }
34333 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34334 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34335 if (!SWIG_IsOK(res2)) {
34336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34337 }
34338 {
34339 PyThreadState* __tstate = wxPyBeginAllowThreads();
34340 (arg1)->SetDataObject(arg2);
34341 wxPyEndAllowThreads(__tstate);
34342 if (PyErr_Occurred()) SWIG_fail;
34343 }
34344 resultobj = SWIG_Py_Void();
34345 return resultobj;
34346 fail:
34347 return NULL;
34348 }
34349
34350
34351 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34352 PyObject *resultobj = 0;
34353 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34354 int arg2 ;
34355 int arg3 ;
34356 wxDragResult arg4 ;
34357 wxDragResult result;
34358 void *argp1 = 0 ;
34359 int res1 = 0 ;
34360 int val2 ;
34361 int ecode2 = 0 ;
34362 int val3 ;
34363 int ecode3 = 0 ;
34364 int val4 ;
34365 int ecode4 = 0 ;
34366 PyObject * obj0 = 0 ;
34367 PyObject * obj1 = 0 ;
34368 PyObject * obj2 = 0 ;
34369 PyObject * obj3 = 0 ;
34370 char * kwnames[] = {
34371 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34372 };
34373
34374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34376 if (!SWIG_IsOK(res1)) {
34377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34378 }
34379 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34380 ecode2 = SWIG_AsVal_int(obj1, &val2);
34381 if (!SWIG_IsOK(ecode2)) {
34382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34383 }
34384 arg2 = static_cast< int >(val2);
34385 ecode3 = SWIG_AsVal_int(obj2, &val3);
34386 if (!SWIG_IsOK(ecode3)) {
34387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34388 }
34389 arg3 = static_cast< int >(val3);
34390 ecode4 = SWIG_AsVal_int(obj3, &val4);
34391 if (!SWIG_IsOK(ecode4)) {
34392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34393 }
34394 arg4 = static_cast< wxDragResult >(val4);
34395 {
34396 PyThreadState* __tstate = wxPyBeginAllowThreads();
34397 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34398 wxPyEndAllowThreads(__tstate);
34399 if (PyErr_Occurred()) SWIG_fail;
34400 }
34401 resultobj = SWIG_From_int(static_cast< int >(result));
34402 return resultobj;
34403 fail:
34404 return NULL;
34405 }
34406
34407
34408 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34409 PyObject *resultobj = 0;
34410 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34411 int arg2 ;
34412 int arg3 ;
34413 wxDragResult arg4 ;
34414 wxDragResult result;
34415 void *argp1 = 0 ;
34416 int res1 = 0 ;
34417 int val2 ;
34418 int ecode2 = 0 ;
34419 int val3 ;
34420 int ecode3 = 0 ;
34421 int val4 ;
34422 int ecode4 = 0 ;
34423 PyObject * obj0 = 0 ;
34424 PyObject * obj1 = 0 ;
34425 PyObject * obj2 = 0 ;
34426 PyObject * obj3 = 0 ;
34427 char * kwnames[] = {
34428 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34429 };
34430
34431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34433 if (!SWIG_IsOK(res1)) {
34434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34435 }
34436 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34437 ecode2 = SWIG_AsVal_int(obj1, &val2);
34438 if (!SWIG_IsOK(ecode2)) {
34439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34440 }
34441 arg2 = static_cast< int >(val2);
34442 ecode3 = SWIG_AsVal_int(obj2, &val3);
34443 if (!SWIG_IsOK(ecode3)) {
34444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34445 }
34446 arg3 = static_cast< int >(val3);
34447 ecode4 = SWIG_AsVal_int(obj3, &val4);
34448 if (!SWIG_IsOK(ecode4)) {
34449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34450 }
34451 arg4 = static_cast< wxDragResult >(val4);
34452 {
34453 PyThreadState* __tstate = wxPyBeginAllowThreads();
34454 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34455 wxPyEndAllowThreads(__tstate);
34456 if (PyErr_Occurred()) SWIG_fail;
34457 }
34458 resultobj = SWIG_From_int(static_cast< int >(result));
34459 return resultobj;
34460 fail:
34461 return NULL;
34462 }
34463
34464
34465 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34466 PyObject *resultobj = 0;
34467 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34468 void *argp1 = 0 ;
34469 int res1 = 0 ;
34470 PyObject *swig_obj[1] ;
34471
34472 if (!args) SWIG_fail;
34473 swig_obj[0] = args;
34474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34475 if (!SWIG_IsOK(res1)) {
34476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34477 }
34478 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34479 {
34480 PyThreadState* __tstate = wxPyBeginAllowThreads();
34481 (arg1)->OnLeave();
34482 wxPyEndAllowThreads(__tstate);
34483 if (PyErr_Occurred()) SWIG_fail;
34484 }
34485 resultobj = SWIG_Py_Void();
34486 return resultobj;
34487 fail:
34488 return NULL;
34489 }
34490
34491
34492 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34493 PyObject *resultobj = 0;
34494 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34495 int arg2 ;
34496 int arg3 ;
34497 bool result;
34498 void *argp1 = 0 ;
34499 int res1 = 0 ;
34500 int val2 ;
34501 int ecode2 = 0 ;
34502 int val3 ;
34503 int ecode3 = 0 ;
34504 PyObject * obj0 = 0 ;
34505 PyObject * obj1 = 0 ;
34506 PyObject * obj2 = 0 ;
34507 char * kwnames[] = {
34508 (char *) "self",(char *) "x",(char *) "y", NULL
34509 };
34510
34511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34513 if (!SWIG_IsOK(res1)) {
34514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34515 }
34516 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34517 ecode2 = SWIG_AsVal_int(obj1, &val2);
34518 if (!SWIG_IsOK(ecode2)) {
34519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34520 }
34521 arg2 = static_cast< int >(val2);
34522 ecode3 = SWIG_AsVal_int(obj2, &val3);
34523 if (!SWIG_IsOK(ecode3)) {
34524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34525 }
34526 arg3 = static_cast< int >(val3);
34527 {
34528 PyThreadState* __tstate = wxPyBeginAllowThreads();
34529 result = (bool)(arg1)->OnDrop(arg2,arg3);
34530 wxPyEndAllowThreads(__tstate);
34531 if (PyErr_Occurred()) SWIG_fail;
34532 }
34533 {
34534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34535 }
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34543 PyObject *resultobj = 0;
34544 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34545 bool result;
34546 void *argp1 = 0 ;
34547 int res1 = 0 ;
34548 PyObject *swig_obj[1] ;
34549
34550 if (!args) SWIG_fail;
34551 swig_obj[0] = args;
34552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34553 if (!SWIG_IsOK(res1)) {
34554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34555 }
34556 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 result = (bool)(arg1)->GetData();
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 {
34564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34565 }
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34573 PyObject *resultobj = 0;
34574 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34575 wxDragResult arg2 ;
34576 void *argp1 = 0 ;
34577 int res1 = 0 ;
34578 int val2 ;
34579 int ecode2 = 0 ;
34580 PyObject * obj0 = 0 ;
34581 PyObject * obj1 = 0 ;
34582 char * kwnames[] = {
34583 (char *) "self",(char *) "action", NULL
34584 };
34585
34586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34588 if (!SWIG_IsOK(res1)) {
34589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34590 }
34591 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34592 ecode2 = SWIG_AsVal_int(obj1, &val2);
34593 if (!SWIG_IsOK(ecode2)) {
34594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34595 }
34596 arg2 = static_cast< wxDragResult >(val2);
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 (arg1)->SetDefaultAction(arg2);
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_Py_Void();
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34611 PyObject *resultobj = 0;
34612 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34613 wxDragResult result;
34614 void *argp1 = 0 ;
34615 int res1 = 0 ;
34616 PyObject *swig_obj[1] ;
34617
34618 if (!args) SWIG_fail;
34619 swig_obj[0] = args;
34620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34621 if (!SWIG_IsOK(res1)) {
34622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34623 }
34624 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = (wxDragResult)(arg1)->GetDefaultAction();
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 resultobj = SWIG_From_int(static_cast< int >(result));
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34639 PyObject *obj;
34640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34641 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34642 return SWIG_Py_Void();
34643 }
34644
34645 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34646 return SWIG_Python_InitShadowInstance(args);
34647 }
34648
34649 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34650 PyObject *resultobj = 0;
34651 wxPyTextDropTarget *result = 0 ;
34652
34653 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34654 {
34655 PyThreadState* __tstate = wxPyBeginAllowThreads();
34656 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34657 wxPyEndAllowThreads(__tstate);
34658 if (PyErr_Occurred()) SWIG_fail;
34659 }
34660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34661 return resultobj;
34662 fail:
34663 return NULL;
34664 }
34665
34666
34667 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34668 PyObject *resultobj = 0;
34669 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34670 PyObject *arg2 = (PyObject *) 0 ;
34671 PyObject *arg3 = (PyObject *) 0 ;
34672 void *argp1 = 0 ;
34673 int res1 = 0 ;
34674 PyObject * obj0 = 0 ;
34675 PyObject * obj1 = 0 ;
34676 PyObject * obj2 = 0 ;
34677 char * kwnames[] = {
34678 (char *) "self",(char *) "self",(char *) "_class", NULL
34679 };
34680
34681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34683 if (!SWIG_IsOK(res1)) {
34684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34685 }
34686 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34687 arg2 = obj1;
34688 arg3 = obj2;
34689 {
34690 PyThreadState* __tstate = wxPyBeginAllowThreads();
34691 (arg1)->_setCallbackInfo(arg2,arg3);
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 resultobj = SWIG_Py_Void();
34696 return resultobj;
34697 fail:
34698 return NULL;
34699 }
34700
34701
34702 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34703 PyObject *resultobj = 0;
34704 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34705 int arg2 ;
34706 int arg3 ;
34707 wxString *arg4 = 0 ;
34708 bool result;
34709 void *argp1 = 0 ;
34710 int res1 = 0 ;
34711 int val2 ;
34712 int ecode2 = 0 ;
34713 int val3 ;
34714 int ecode3 = 0 ;
34715 bool temp4 = false ;
34716 PyObject * obj0 = 0 ;
34717 PyObject * obj1 = 0 ;
34718 PyObject * obj2 = 0 ;
34719 PyObject * obj3 = 0 ;
34720 char * kwnames[] = {
34721 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34722 };
34723
34724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34728 }
34729 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34730 ecode2 = SWIG_AsVal_int(obj1, &val2);
34731 if (!SWIG_IsOK(ecode2)) {
34732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34733 }
34734 arg2 = static_cast< int >(val2);
34735 ecode3 = SWIG_AsVal_int(obj2, &val3);
34736 if (!SWIG_IsOK(ecode3)) {
34737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34738 }
34739 arg3 = static_cast< int >(val3);
34740 {
34741 arg4 = wxString_in_helper(obj3);
34742 if (arg4 == NULL) SWIG_fail;
34743 temp4 = true;
34744 }
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 {
34752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34753 }
34754 {
34755 if (temp4)
34756 delete arg4;
34757 }
34758 return resultobj;
34759 fail:
34760 {
34761 if (temp4)
34762 delete arg4;
34763 }
34764 return NULL;
34765 }
34766
34767
34768 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34769 PyObject *resultobj = 0;
34770 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34771 int arg2 ;
34772 int arg3 ;
34773 wxDragResult arg4 ;
34774 wxDragResult result;
34775 void *argp1 = 0 ;
34776 int res1 = 0 ;
34777 int val2 ;
34778 int ecode2 = 0 ;
34779 int val3 ;
34780 int ecode3 = 0 ;
34781 int val4 ;
34782 int ecode4 = 0 ;
34783 PyObject * obj0 = 0 ;
34784 PyObject * obj1 = 0 ;
34785 PyObject * obj2 = 0 ;
34786 PyObject * obj3 = 0 ;
34787 char * kwnames[] = {
34788 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34789 };
34790
34791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34795 }
34796 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34797 ecode2 = SWIG_AsVal_int(obj1, &val2);
34798 if (!SWIG_IsOK(ecode2)) {
34799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34800 }
34801 arg2 = static_cast< int >(val2);
34802 ecode3 = SWIG_AsVal_int(obj2, &val3);
34803 if (!SWIG_IsOK(ecode3)) {
34804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34805 }
34806 arg3 = static_cast< int >(val3);
34807 ecode4 = SWIG_AsVal_int(obj3, &val4);
34808 if (!SWIG_IsOK(ecode4)) {
34809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34810 }
34811 arg4 = static_cast< wxDragResult >(val4);
34812 {
34813 PyThreadState* __tstate = wxPyBeginAllowThreads();
34814 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 resultobj = SWIG_From_int(static_cast< int >(result));
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34826 PyObject *resultobj = 0;
34827 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34828 int arg2 ;
34829 int arg3 ;
34830 wxDragResult arg4 ;
34831 wxDragResult result;
34832 void *argp1 = 0 ;
34833 int res1 = 0 ;
34834 int val2 ;
34835 int ecode2 = 0 ;
34836 int val3 ;
34837 int ecode3 = 0 ;
34838 int val4 ;
34839 int ecode4 = 0 ;
34840 PyObject * obj0 = 0 ;
34841 PyObject * obj1 = 0 ;
34842 PyObject * obj2 = 0 ;
34843 PyObject * obj3 = 0 ;
34844 char * kwnames[] = {
34845 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34846 };
34847
34848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34850 if (!SWIG_IsOK(res1)) {
34851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34852 }
34853 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34854 ecode2 = SWIG_AsVal_int(obj1, &val2);
34855 if (!SWIG_IsOK(ecode2)) {
34856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34857 }
34858 arg2 = static_cast< int >(val2);
34859 ecode3 = SWIG_AsVal_int(obj2, &val3);
34860 if (!SWIG_IsOK(ecode3)) {
34861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34862 }
34863 arg3 = static_cast< int >(val3);
34864 ecode4 = SWIG_AsVal_int(obj3, &val4);
34865 if (!SWIG_IsOK(ecode4)) {
34866 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34867 }
34868 arg4 = static_cast< wxDragResult >(val4);
34869 {
34870 PyThreadState* __tstate = wxPyBeginAllowThreads();
34871 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34872 wxPyEndAllowThreads(__tstate);
34873 if (PyErr_Occurred()) SWIG_fail;
34874 }
34875 resultobj = SWIG_From_int(static_cast< int >(result));
34876 return resultobj;
34877 fail:
34878 return NULL;
34879 }
34880
34881
34882 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34883 PyObject *resultobj = 0;
34884 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34885 void *argp1 = 0 ;
34886 int res1 = 0 ;
34887 PyObject *swig_obj[1] ;
34888
34889 if (!args) SWIG_fail;
34890 swig_obj[0] = args;
34891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34892 if (!SWIG_IsOK(res1)) {
34893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34894 }
34895 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34896 {
34897 PyThreadState* __tstate = wxPyBeginAllowThreads();
34898 (arg1)->OnLeave();
34899 wxPyEndAllowThreads(__tstate);
34900 if (PyErr_Occurred()) SWIG_fail;
34901 }
34902 resultobj = SWIG_Py_Void();
34903 return resultobj;
34904 fail:
34905 return NULL;
34906 }
34907
34908
34909 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34910 PyObject *resultobj = 0;
34911 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34912 int arg2 ;
34913 int arg3 ;
34914 bool result;
34915 void *argp1 = 0 ;
34916 int res1 = 0 ;
34917 int val2 ;
34918 int ecode2 = 0 ;
34919 int val3 ;
34920 int ecode3 = 0 ;
34921 PyObject * obj0 = 0 ;
34922 PyObject * obj1 = 0 ;
34923 PyObject * obj2 = 0 ;
34924 char * kwnames[] = {
34925 (char *) "self",(char *) "x",(char *) "y", NULL
34926 };
34927
34928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34930 if (!SWIG_IsOK(res1)) {
34931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34932 }
34933 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34934 ecode2 = SWIG_AsVal_int(obj1, &val2);
34935 if (!SWIG_IsOK(ecode2)) {
34936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34937 }
34938 arg2 = static_cast< int >(val2);
34939 ecode3 = SWIG_AsVal_int(obj2, &val3);
34940 if (!SWIG_IsOK(ecode3)) {
34941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34942 }
34943 arg3 = static_cast< int >(val3);
34944 {
34945 PyThreadState* __tstate = wxPyBeginAllowThreads();
34946 result = (bool)(arg1)->OnDrop(arg2,arg3);
34947 wxPyEndAllowThreads(__tstate);
34948 if (PyErr_Occurred()) SWIG_fail;
34949 }
34950 {
34951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34952 }
34953 return resultobj;
34954 fail:
34955 return NULL;
34956 }
34957
34958
34959 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34960 PyObject *resultobj = 0;
34961 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34962 int arg2 ;
34963 int arg3 ;
34964 wxDragResult arg4 ;
34965 wxDragResult result;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 int val2 ;
34969 int ecode2 = 0 ;
34970 int val3 ;
34971 int ecode3 = 0 ;
34972 int val4 ;
34973 int ecode4 = 0 ;
34974 PyObject * obj0 = 0 ;
34975 PyObject * obj1 = 0 ;
34976 PyObject * obj2 = 0 ;
34977 PyObject * obj3 = 0 ;
34978 char * kwnames[] = {
34979 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34980 };
34981
34982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34984 if (!SWIG_IsOK(res1)) {
34985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34986 }
34987 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34988 ecode2 = SWIG_AsVal_int(obj1, &val2);
34989 if (!SWIG_IsOK(ecode2)) {
34990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34991 }
34992 arg2 = static_cast< int >(val2);
34993 ecode3 = SWIG_AsVal_int(obj2, &val3);
34994 if (!SWIG_IsOK(ecode3)) {
34995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34996 }
34997 arg3 = static_cast< int >(val3);
34998 ecode4 = SWIG_AsVal_int(obj3, &val4);
34999 if (!SWIG_IsOK(ecode4)) {
35000 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35001 }
35002 arg4 = static_cast< wxDragResult >(val4);
35003 {
35004 PyThreadState* __tstate = wxPyBeginAllowThreads();
35005 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35006 wxPyEndAllowThreads(__tstate);
35007 if (PyErr_Occurred()) SWIG_fail;
35008 }
35009 resultobj = SWIG_From_int(static_cast< int >(result));
35010 return resultobj;
35011 fail:
35012 return NULL;
35013 }
35014
35015
35016 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35017 PyObject *obj;
35018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35019 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
35020 return SWIG_Py_Void();
35021 }
35022
35023 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35024 return SWIG_Python_InitShadowInstance(args);
35025 }
35026
35027 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35028 PyObject *resultobj = 0;
35029 wxPyFileDropTarget *result = 0 ;
35030
35031 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
35032 {
35033 PyThreadState* __tstate = wxPyBeginAllowThreads();
35034 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
35035 wxPyEndAllowThreads(__tstate);
35036 if (PyErr_Occurred()) SWIG_fail;
35037 }
35038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
35039 return resultobj;
35040 fail:
35041 return NULL;
35042 }
35043
35044
35045 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35046 PyObject *resultobj = 0;
35047 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35048 PyObject *arg2 = (PyObject *) 0 ;
35049 PyObject *arg3 = (PyObject *) 0 ;
35050 void *argp1 = 0 ;
35051 int res1 = 0 ;
35052 PyObject * obj0 = 0 ;
35053 PyObject * obj1 = 0 ;
35054 PyObject * obj2 = 0 ;
35055 char * kwnames[] = {
35056 (char *) "self",(char *) "self",(char *) "_class", NULL
35057 };
35058
35059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35061 if (!SWIG_IsOK(res1)) {
35062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35063 }
35064 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35065 arg2 = obj1;
35066 arg3 = obj2;
35067 {
35068 PyThreadState* __tstate = wxPyBeginAllowThreads();
35069 (arg1)->_setCallbackInfo(arg2,arg3);
35070 wxPyEndAllowThreads(__tstate);
35071 if (PyErr_Occurred()) SWIG_fail;
35072 }
35073 resultobj = SWIG_Py_Void();
35074 return resultobj;
35075 fail:
35076 return NULL;
35077 }
35078
35079
35080 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35081 PyObject *resultobj = 0;
35082 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35083 int arg2 ;
35084 int arg3 ;
35085 wxArrayString *arg4 = 0 ;
35086 bool result;
35087 void *argp1 = 0 ;
35088 int res1 = 0 ;
35089 int val2 ;
35090 int ecode2 = 0 ;
35091 int val3 ;
35092 int ecode3 = 0 ;
35093 bool temp4 = false ;
35094 PyObject * obj0 = 0 ;
35095 PyObject * obj1 = 0 ;
35096 PyObject * obj2 = 0 ;
35097 PyObject * obj3 = 0 ;
35098 char * kwnames[] = {
35099 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35100 };
35101
35102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35104 if (!SWIG_IsOK(res1)) {
35105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35106 }
35107 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35108 ecode2 = SWIG_AsVal_int(obj1, &val2);
35109 if (!SWIG_IsOK(ecode2)) {
35110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35111 }
35112 arg2 = static_cast< int >(val2);
35113 ecode3 = SWIG_AsVal_int(obj2, &val3);
35114 if (!SWIG_IsOK(ecode3)) {
35115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35116 }
35117 arg3 = static_cast< int >(val3);
35118 {
35119 if (! PySequence_Check(obj3)) {
35120 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35121 SWIG_fail;
35122 }
35123 arg4 = new wxArrayString;
35124 temp4 = true;
35125 int i, len=PySequence_Length(obj3);
35126 for (i=0; i<len; i++) {
35127 PyObject* item = PySequence_GetItem(obj3, i);
35128 wxString* s = wxString_in_helper(item);
35129 if (PyErr_Occurred()) SWIG_fail;
35130 arg4->Add(*s);
35131 delete s;
35132 Py_DECREF(item);
35133 }
35134 }
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 {
35142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35143 }
35144 {
35145 if (temp4) delete arg4;
35146 }
35147 return resultobj;
35148 fail:
35149 {
35150 if (temp4) delete arg4;
35151 }
35152 return NULL;
35153 }
35154
35155
35156 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35157 PyObject *resultobj = 0;
35158 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35159 int arg2 ;
35160 int arg3 ;
35161 wxDragResult arg4 ;
35162 wxDragResult result;
35163 void *argp1 = 0 ;
35164 int res1 = 0 ;
35165 int val2 ;
35166 int ecode2 = 0 ;
35167 int val3 ;
35168 int ecode3 = 0 ;
35169 int val4 ;
35170 int ecode4 = 0 ;
35171 PyObject * obj0 = 0 ;
35172 PyObject * obj1 = 0 ;
35173 PyObject * obj2 = 0 ;
35174 PyObject * obj3 = 0 ;
35175 char * kwnames[] = {
35176 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35177 };
35178
35179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35183 }
35184 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35185 ecode2 = SWIG_AsVal_int(obj1, &val2);
35186 if (!SWIG_IsOK(ecode2)) {
35187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35188 }
35189 arg2 = static_cast< int >(val2);
35190 ecode3 = SWIG_AsVal_int(obj2, &val3);
35191 if (!SWIG_IsOK(ecode3)) {
35192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35193 }
35194 arg3 = static_cast< int >(val3);
35195 ecode4 = SWIG_AsVal_int(obj3, &val4);
35196 if (!SWIG_IsOK(ecode4)) {
35197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35198 }
35199 arg4 = static_cast< wxDragResult >(val4);
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35203 wxPyEndAllowThreads(__tstate);
35204 if (PyErr_Occurred()) SWIG_fail;
35205 }
35206 resultobj = SWIG_From_int(static_cast< int >(result));
35207 return resultobj;
35208 fail:
35209 return NULL;
35210 }
35211
35212
35213 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35214 PyObject *resultobj = 0;
35215 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35216 int arg2 ;
35217 int arg3 ;
35218 wxDragResult arg4 ;
35219 wxDragResult result;
35220 void *argp1 = 0 ;
35221 int res1 = 0 ;
35222 int val2 ;
35223 int ecode2 = 0 ;
35224 int val3 ;
35225 int ecode3 = 0 ;
35226 int val4 ;
35227 int ecode4 = 0 ;
35228 PyObject * obj0 = 0 ;
35229 PyObject * obj1 = 0 ;
35230 PyObject * obj2 = 0 ;
35231 PyObject * obj3 = 0 ;
35232 char * kwnames[] = {
35233 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35234 };
35235
35236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35238 if (!SWIG_IsOK(res1)) {
35239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35240 }
35241 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35242 ecode2 = SWIG_AsVal_int(obj1, &val2);
35243 if (!SWIG_IsOK(ecode2)) {
35244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35245 }
35246 arg2 = static_cast< int >(val2);
35247 ecode3 = SWIG_AsVal_int(obj2, &val3);
35248 if (!SWIG_IsOK(ecode3)) {
35249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35250 }
35251 arg3 = static_cast< int >(val3);
35252 ecode4 = SWIG_AsVal_int(obj3, &val4);
35253 if (!SWIG_IsOK(ecode4)) {
35254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35255 }
35256 arg4 = static_cast< wxDragResult >(val4);
35257 {
35258 PyThreadState* __tstate = wxPyBeginAllowThreads();
35259 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35260 wxPyEndAllowThreads(__tstate);
35261 if (PyErr_Occurred()) SWIG_fail;
35262 }
35263 resultobj = SWIG_From_int(static_cast< int >(result));
35264 return resultobj;
35265 fail:
35266 return NULL;
35267 }
35268
35269
35270 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35271 PyObject *resultobj = 0;
35272 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35273 void *argp1 = 0 ;
35274 int res1 = 0 ;
35275 PyObject *swig_obj[1] ;
35276
35277 if (!args) SWIG_fail;
35278 swig_obj[0] = args;
35279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35280 if (!SWIG_IsOK(res1)) {
35281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35282 }
35283 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35284 {
35285 PyThreadState* __tstate = wxPyBeginAllowThreads();
35286 (arg1)->OnLeave();
35287 wxPyEndAllowThreads(__tstate);
35288 if (PyErr_Occurred()) SWIG_fail;
35289 }
35290 resultobj = SWIG_Py_Void();
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35298 PyObject *resultobj = 0;
35299 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35300 int arg2 ;
35301 int arg3 ;
35302 bool result;
35303 void *argp1 = 0 ;
35304 int res1 = 0 ;
35305 int val2 ;
35306 int ecode2 = 0 ;
35307 int val3 ;
35308 int ecode3 = 0 ;
35309 PyObject * obj0 = 0 ;
35310 PyObject * obj1 = 0 ;
35311 PyObject * obj2 = 0 ;
35312 char * kwnames[] = {
35313 (char *) "self",(char *) "x",(char *) "y", NULL
35314 };
35315
35316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35318 if (!SWIG_IsOK(res1)) {
35319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35320 }
35321 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35322 ecode2 = SWIG_AsVal_int(obj1, &val2);
35323 if (!SWIG_IsOK(ecode2)) {
35324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35325 }
35326 arg2 = static_cast< int >(val2);
35327 ecode3 = SWIG_AsVal_int(obj2, &val3);
35328 if (!SWIG_IsOK(ecode3)) {
35329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35330 }
35331 arg3 = static_cast< int >(val3);
35332 {
35333 PyThreadState* __tstate = wxPyBeginAllowThreads();
35334 result = (bool)(arg1)->OnDrop(arg2,arg3);
35335 wxPyEndAllowThreads(__tstate);
35336 if (PyErr_Occurred()) SWIG_fail;
35337 }
35338 {
35339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35340 }
35341 return resultobj;
35342 fail:
35343 return NULL;
35344 }
35345
35346
35347 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35348 PyObject *resultobj = 0;
35349 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35350 int arg2 ;
35351 int arg3 ;
35352 wxDragResult arg4 ;
35353 wxDragResult result;
35354 void *argp1 = 0 ;
35355 int res1 = 0 ;
35356 int val2 ;
35357 int ecode2 = 0 ;
35358 int val3 ;
35359 int ecode3 = 0 ;
35360 int val4 ;
35361 int ecode4 = 0 ;
35362 PyObject * obj0 = 0 ;
35363 PyObject * obj1 = 0 ;
35364 PyObject * obj2 = 0 ;
35365 PyObject * obj3 = 0 ;
35366 char * kwnames[] = {
35367 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35368 };
35369
35370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35372 if (!SWIG_IsOK(res1)) {
35373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35374 }
35375 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35376 ecode2 = SWIG_AsVal_int(obj1, &val2);
35377 if (!SWIG_IsOK(ecode2)) {
35378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35379 }
35380 arg2 = static_cast< int >(val2);
35381 ecode3 = SWIG_AsVal_int(obj2, &val3);
35382 if (!SWIG_IsOK(ecode3)) {
35383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35384 }
35385 arg3 = static_cast< int >(val3);
35386 ecode4 = SWIG_AsVal_int(obj3, &val4);
35387 if (!SWIG_IsOK(ecode4)) {
35388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35389 }
35390 arg4 = static_cast< wxDragResult >(val4);
35391 {
35392 PyThreadState* __tstate = wxPyBeginAllowThreads();
35393 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35394 wxPyEndAllowThreads(__tstate);
35395 if (PyErr_Occurred()) SWIG_fail;
35396 }
35397 resultobj = SWIG_From_int(static_cast< int >(result));
35398 return resultobj;
35399 fail:
35400 return NULL;
35401 }
35402
35403
35404 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35405 PyObject *obj;
35406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35407 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35408 return SWIG_Py_Void();
35409 }
35410
35411 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35412 return SWIG_Python_InitShadowInstance(args);
35413 }
35414
35415 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35416 PyObject *resultobj = 0;
35417 wxClipboard *result = 0 ;
35418
35419 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35420 {
35421 PyThreadState* __tstate = wxPyBeginAllowThreads();
35422 result = (wxClipboard *)new wxClipboard();
35423 wxPyEndAllowThreads(__tstate);
35424 if (PyErr_Occurred()) SWIG_fail;
35425 }
35426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35427 return resultobj;
35428 fail:
35429 return NULL;
35430 }
35431
35432
35433 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35434 PyObject *resultobj = 0;
35435 wxClipboard *arg1 = (wxClipboard *) 0 ;
35436 void *argp1 = 0 ;
35437 int res1 = 0 ;
35438 PyObject *swig_obj[1] ;
35439
35440 if (!args) SWIG_fail;
35441 swig_obj[0] = args;
35442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35443 if (!SWIG_IsOK(res1)) {
35444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35445 }
35446 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 delete arg1;
35450
35451 wxPyEndAllowThreads(__tstate);
35452 if (PyErr_Occurred()) SWIG_fail;
35453 }
35454 resultobj = SWIG_Py_Void();
35455 return resultobj;
35456 fail:
35457 return NULL;
35458 }
35459
35460
35461 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35462 PyObject *resultobj = 0;
35463 wxClipboard *arg1 = (wxClipboard *) 0 ;
35464 bool result;
35465 void *argp1 = 0 ;
35466 int res1 = 0 ;
35467 PyObject *swig_obj[1] ;
35468
35469 if (!args) SWIG_fail;
35470 swig_obj[0] = args;
35471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35472 if (!SWIG_IsOK(res1)) {
35473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35474 }
35475 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35476 {
35477 PyThreadState* __tstate = wxPyBeginAllowThreads();
35478 result = (bool)(arg1)->Open();
35479 wxPyEndAllowThreads(__tstate);
35480 if (PyErr_Occurred()) SWIG_fail;
35481 }
35482 {
35483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35484 }
35485 return resultobj;
35486 fail:
35487 return NULL;
35488 }
35489
35490
35491 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35492 PyObject *resultobj = 0;
35493 wxClipboard *arg1 = (wxClipboard *) 0 ;
35494 void *argp1 = 0 ;
35495 int res1 = 0 ;
35496 PyObject *swig_obj[1] ;
35497
35498 if (!args) SWIG_fail;
35499 swig_obj[0] = args;
35500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35501 if (!SWIG_IsOK(res1)) {
35502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35503 }
35504 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35505 {
35506 PyThreadState* __tstate = wxPyBeginAllowThreads();
35507 (arg1)->Close();
35508 wxPyEndAllowThreads(__tstate);
35509 if (PyErr_Occurred()) SWIG_fail;
35510 }
35511 resultobj = SWIG_Py_Void();
35512 return resultobj;
35513 fail:
35514 return NULL;
35515 }
35516
35517
35518 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35519 PyObject *resultobj = 0;
35520 wxClipboard *arg1 = (wxClipboard *) 0 ;
35521 bool result;
35522 void *argp1 = 0 ;
35523 int res1 = 0 ;
35524 PyObject *swig_obj[1] ;
35525
35526 if (!args) SWIG_fail;
35527 swig_obj[0] = args;
35528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35529 if (!SWIG_IsOK(res1)) {
35530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35531 }
35532 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35533 {
35534 PyThreadState* __tstate = wxPyBeginAllowThreads();
35535 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35536 wxPyEndAllowThreads(__tstate);
35537 if (PyErr_Occurred()) SWIG_fail;
35538 }
35539 {
35540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35541 }
35542 return resultobj;
35543 fail:
35544 return NULL;
35545 }
35546
35547
35548 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35549 PyObject *resultobj = 0;
35550 wxClipboard *arg1 = (wxClipboard *) 0 ;
35551 wxDataObject *arg2 = (wxDataObject *) 0 ;
35552 bool result;
35553 void *argp1 = 0 ;
35554 int res1 = 0 ;
35555 int res2 = 0 ;
35556 PyObject * obj0 = 0 ;
35557 PyObject * obj1 = 0 ;
35558 char * kwnames[] = {
35559 (char *) "self",(char *) "data", NULL
35560 };
35561
35562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35564 if (!SWIG_IsOK(res1)) {
35565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35566 }
35567 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35568 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35569 if (!SWIG_IsOK(res2)) {
35570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35571 }
35572 {
35573 PyThreadState* __tstate = wxPyBeginAllowThreads();
35574 result = (bool)(arg1)->AddData(arg2);
35575 wxPyEndAllowThreads(__tstate);
35576 if (PyErr_Occurred()) SWIG_fail;
35577 }
35578 {
35579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35580 }
35581 return resultobj;
35582 fail:
35583 return NULL;
35584 }
35585
35586
35587 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35588 PyObject *resultobj = 0;
35589 wxClipboard *arg1 = (wxClipboard *) 0 ;
35590 wxDataObject *arg2 = (wxDataObject *) 0 ;
35591 bool result;
35592 void *argp1 = 0 ;
35593 int res1 = 0 ;
35594 int res2 = 0 ;
35595 PyObject * obj0 = 0 ;
35596 PyObject * obj1 = 0 ;
35597 char * kwnames[] = {
35598 (char *) "self",(char *) "data", NULL
35599 };
35600
35601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35603 if (!SWIG_IsOK(res1)) {
35604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35605 }
35606 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35607 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35608 if (!SWIG_IsOK(res2)) {
35609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35610 }
35611 {
35612 PyThreadState* __tstate = wxPyBeginAllowThreads();
35613 result = (bool)(arg1)->SetData(arg2);
35614 wxPyEndAllowThreads(__tstate);
35615 if (PyErr_Occurred()) SWIG_fail;
35616 }
35617 {
35618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35619 }
35620 return resultobj;
35621 fail:
35622 return NULL;
35623 }
35624
35625
35626 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35627 PyObject *resultobj = 0;
35628 wxClipboard *arg1 = (wxClipboard *) 0 ;
35629 wxDataFormat *arg2 = 0 ;
35630 bool result;
35631 void *argp1 = 0 ;
35632 int res1 = 0 ;
35633 void *argp2 = 0 ;
35634 int res2 = 0 ;
35635 PyObject * obj0 = 0 ;
35636 PyObject * obj1 = 0 ;
35637 char * kwnames[] = {
35638 (char *) "self",(char *) "format", NULL
35639 };
35640
35641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35643 if (!SWIG_IsOK(res1)) {
35644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35645 }
35646 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35647 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35648 if (!SWIG_IsOK(res2)) {
35649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35650 }
35651 if (!argp2) {
35652 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35653 }
35654 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35655 {
35656 PyThreadState* __tstate = wxPyBeginAllowThreads();
35657 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35658 wxPyEndAllowThreads(__tstate);
35659 if (PyErr_Occurred()) SWIG_fail;
35660 }
35661 {
35662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35663 }
35664 return resultobj;
35665 fail:
35666 return NULL;
35667 }
35668
35669
35670 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35671 PyObject *resultobj = 0;
35672 wxClipboard *arg1 = (wxClipboard *) 0 ;
35673 wxDataObject *arg2 = 0 ;
35674 bool result;
35675 void *argp1 = 0 ;
35676 int res1 = 0 ;
35677 void *argp2 = 0 ;
35678 int res2 = 0 ;
35679 PyObject * obj0 = 0 ;
35680 PyObject * obj1 = 0 ;
35681 char * kwnames[] = {
35682 (char *) "self",(char *) "data", NULL
35683 };
35684
35685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35687 if (!SWIG_IsOK(res1)) {
35688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35689 }
35690 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35691 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35692 if (!SWIG_IsOK(res2)) {
35693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35694 }
35695 if (!argp2) {
35696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35697 }
35698 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35699 {
35700 PyThreadState* __tstate = wxPyBeginAllowThreads();
35701 result = (bool)(arg1)->GetData(*arg2);
35702 wxPyEndAllowThreads(__tstate);
35703 if (PyErr_Occurred()) SWIG_fail;
35704 }
35705 {
35706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35707 }
35708 return resultobj;
35709 fail:
35710 return NULL;
35711 }
35712
35713
35714 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35715 PyObject *resultobj = 0;
35716 wxClipboard *arg1 = (wxClipboard *) 0 ;
35717 void *argp1 = 0 ;
35718 int res1 = 0 ;
35719 PyObject *swig_obj[1] ;
35720
35721 if (!args) SWIG_fail;
35722 swig_obj[0] = args;
35723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35724 if (!SWIG_IsOK(res1)) {
35725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35726 }
35727 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35728 {
35729 PyThreadState* __tstate = wxPyBeginAllowThreads();
35730 (arg1)->Clear();
35731 wxPyEndAllowThreads(__tstate);
35732 if (PyErr_Occurred()) SWIG_fail;
35733 }
35734 resultobj = SWIG_Py_Void();
35735 return resultobj;
35736 fail:
35737 return NULL;
35738 }
35739
35740
35741 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35742 PyObject *resultobj = 0;
35743 wxClipboard *arg1 = (wxClipboard *) 0 ;
35744 bool result;
35745 void *argp1 = 0 ;
35746 int res1 = 0 ;
35747 PyObject *swig_obj[1] ;
35748
35749 if (!args) SWIG_fail;
35750 swig_obj[0] = args;
35751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35752 if (!SWIG_IsOK(res1)) {
35753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35754 }
35755 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35756 {
35757 PyThreadState* __tstate = wxPyBeginAllowThreads();
35758 result = (bool)(arg1)->Flush();
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 {
35763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35764 }
35765 return resultobj;
35766 fail:
35767 return NULL;
35768 }
35769
35770
35771 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35772 PyObject *resultobj = 0;
35773 wxClipboard *arg1 = (wxClipboard *) 0 ;
35774 bool arg2 = (bool) true ;
35775 void *argp1 = 0 ;
35776 int res1 = 0 ;
35777 bool val2 ;
35778 int ecode2 = 0 ;
35779 PyObject * obj0 = 0 ;
35780 PyObject * obj1 = 0 ;
35781 char * kwnames[] = {
35782 (char *) "self",(char *) "primary", NULL
35783 };
35784
35785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35787 if (!SWIG_IsOK(res1)) {
35788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35789 }
35790 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35791 if (obj1) {
35792 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35793 if (!SWIG_IsOK(ecode2)) {
35794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35795 }
35796 arg2 = static_cast< bool >(val2);
35797 }
35798 {
35799 PyThreadState* __tstate = wxPyBeginAllowThreads();
35800 (arg1)->UsePrimarySelection(arg2);
35801 wxPyEndAllowThreads(__tstate);
35802 if (PyErr_Occurred()) SWIG_fail;
35803 }
35804 resultobj = SWIG_Py_Void();
35805 return resultobj;
35806 fail:
35807 return NULL;
35808 }
35809
35810
35811 SWIGINTERN PyObject *_wrap_Clipboard_IsUsingPrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35812 PyObject *resultobj = 0;
35813 wxClipboard *arg1 = (wxClipboard *) 0 ;
35814 bool result;
35815 void *argp1 = 0 ;
35816 int res1 = 0 ;
35817 PyObject *swig_obj[1] ;
35818
35819 if (!args) SWIG_fail;
35820 swig_obj[0] = args;
35821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35822 if (!SWIG_IsOK(res1)) {
35823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsUsingPrimarySelection" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35824 }
35825 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35826 {
35827 PyThreadState* __tstate = wxPyBeginAllowThreads();
35828 result = (bool)((wxClipboard const *)arg1)->IsUsingPrimarySelection();
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 {
35833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35834 }
35835 return resultobj;
35836 fail:
35837 return NULL;
35838 }
35839
35840
35841 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35842 PyObject *resultobj = 0;
35843 wxClipboard *result = 0 ;
35844
35845 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35846 {
35847 PyThreadState* __tstate = wxPyBeginAllowThreads();
35848 result = (wxClipboard *)wxClipboard::Get();
35849 wxPyEndAllowThreads(__tstate);
35850 if (PyErr_Occurred()) SWIG_fail;
35851 }
35852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35853 return resultobj;
35854 fail:
35855 return NULL;
35856 }
35857
35858
35859 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35860 PyObject *obj;
35861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35862 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35863 return SWIG_Py_Void();
35864 }
35865
35866 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35867 return SWIG_Python_InitShadowInstance(args);
35868 }
35869
35870 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35871 PyObject *resultobj = 0;
35872 wxClipboard *arg1 = (wxClipboard *) NULL ;
35873 wxClipboardLocker *result = 0 ;
35874 void *argp1 = 0 ;
35875 int res1 = 0 ;
35876 PyObject * obj0 = 0 ;
35877 char * kwnames[] = {
35878 (char *) "clipboard", NULL
35879 };
35880
35881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35882 if (obj0) {
35883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35884 if (!SWIG_IsOK(res1)) {
35885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35886 }
35887 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35888 }
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35896 return resultobj;
35897 fail:
35898 return NULL;
35899 }
35900
35901
35902 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35903 PyObject *resultobj = 0;
35904 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35905 void *argp1 = 0 ;
35906 int res1 = 0 ;
35907 PyObject *swig_obj[1] ;
35908
35909 if (!args) SWIG_fail;
35910 swig_obj[0] = args;
35911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35912 if (!SWIG_IsOK(res1)) {
35913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35914 }
35915 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35916 {
35917 PyThreadState* __tstate = wxPyBeginAllowThreads();
35918 delete arg1;
35919
35920 wxPyEndAllowThreads(__tstate);
35921 if (PyErr_Occurred()) SWIG_fail;
35922 }
35923 resultobj = SWIG_Py_Void();
35924 return resultobj;
35925 fail:
35926 return NULL;
35927 }
35928
35929
35930 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35931 PyObject *resultobj = 0;
35932 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35933 bool result;
35934 void *argp1 = 0 ;
35935 int res1 = 0 ;
35936 PyObject *swig_obj[1] ;
35937
35938 if (!args) SWIG_fail;
35939 swig_obj[0] = args;
35940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35941 if (!SWIG_IsOK(res1)) {
35942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35943 }
35944 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35945 {
35946 PyThreadState* __tstate = wxPyBeginAllowThreads();
35947 result = (bool)wxClipboardLocker___nonzero__(arg1);
35948 wxPyEndAllowThreads(__tstate);
35949 if (PyErr_Occurred()) SWIG_fail;
35950 }
35951 {
35952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35953 }
35954 return resultobj;
35955 fail:
35956 return NULL;
35957 }
35958
35959
35960 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35961 PyObject *obj;
35962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35963 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35964 return SWIG_Py_Void();
35965 }
35966
35967 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35968 return SWIG_Python_InitShadowInstance(args);
35969 }
35970
35971 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35972 PyObject *resultobj = 0;
35973 int arg1 = (int) 0 ;
35974 int arg2 = (int) 0 ;
35975 int arg3 = (int) 0 ;
35976 int arg4 = (int) 0 ;
35977 wxVideoMode *result = 0 ;
35978 int val1 ;
35979 int ecode1 = 0 ;
35980 int val2 ;
35981 int ecode2 = 0 ;
35982 int val3 ;
35983 int ecode3 = 0 ;
35984 int val4 ;
35985 int ecode4 = 0 ;
35986 PyObject * obj0 = 0 ;
35987 PyObject * obj1 = 0 ;
35988 PyObject * obj2 = 0 ;
35989 PyObject * obj3 = 0 ;
35990 char * kwnames[] = {
35991 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35992 };
35993
35994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35995 if (obj0) {
35996 ecode1 = SWIG_AsVal_int(obj0, &val1);
35997 if (!SWIG_IsOK(ecode1)) {
35998 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35999 }
36000 arg1 = static_cast< int >(val1);
36001 }
36002 if (obj1) {
36003 ecode2 = SWIG_AsVal_int(obj1, &val2);
36004 if (!SWIG_IsOK(ecode2)) {
36005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
36006 }
36007 arg2 = static_cast< int >(val2);
36008 }
36009 if (obj2) {
36010 ecode3 = SWIG_AsVal_int(obj2, &val3);
36011 if (!SWIG_IsOK(ecode3)) {
36012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
36013 }
36014 arg3 = static_cast< int >(val3);
36015 }
36016 if (obj3) {
36017 ecode4 = SWIG_AsVal_int(obj3, &val4);
36018 if (!SWIG_IsOK(ecode4)) {
36019 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
36020 }
36021 arg4 = static_cast< int >(val4);
36022 }
36023 {
36024 PyThreadState* __tstate = wxPyBeginAllowThreads();
36025 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
36030 return resultobj;
36031 fail:
36032 return NULL;
36033 }
36034
36035
36036 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36037 PyObject *resultobj = 0;
36038 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36039 void *argp1 = 0 ;
36040 int res1 = 0 ;
36041 PyObject *swig_obj[1] ;
36042
36043 if (!args) SWIG_fail;
36044 swig_obj[0] = args;
36045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
36046 if (!SWIG_IsOK(res1)) {
36047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36048 }
36049 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36050 {
36051 PyThreadState* __tstate = wxPyBeginAllowThreads();
36052 delete arg1;
36053
36054 wxPyEndAllowThreads(__tstate);
36055 if (PyErr_Occurred()) SWIG_fail;
36056 }
36057 resultobj = SWIG_Py_Void();
36058 return resultobj;
36059 fail:
36060 return NULL;
36061 }
36062
36063
36064 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36065 PyObject *resultobj = 0;
36066 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36067 wxVideoMode *arg2 = 0 ;
36068 bool result;
36069 void *argp1 = 0 ;
36070 int res1 = 0 ;
36071 void *argp2 = 0 ;
36072 int res2 = 0 ;
36073 PyObject * obj0 = 0 ;
36074 PyObject * obj1 = 0 ;
36075 char * kwnames[] = {
36076 (char *) "self",(char *) "other", NULL
36077 };
36078
36079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
36080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36081 if (!SWIG_IsOK(res1)) {
36082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36083 }
36084 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36085 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36086 if (!SWIG_IsOK(res2)) {
36087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36088 }
36089 if (!argp2) {
36090 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36091 }
36092 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36093 {
36094 PyThreadState* __tstate = wxPyBeginAllowThreads();
36095 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
36096 wxPyEndAllowThreads(__tstate);
36097 if (PyErr_Occurred()) SWIG_fail;
36098 }
36099 {
36100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36101 }
36102 return resultobj;
36103 fail:
36104 return NULL;
36105 }
36106
36107
36108 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36109 PyObject *resultobj = 0;
36110 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36111 int result;
36112 void *argp1 = 0 ;
36113 int res1 = 0 ;
36114 PyObject *swig_obj[1] ;
36115
36116 if (!args) SWIG_fail;
36117 swig_obj[0] = args;
36118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36119 if (!SWIG_IsOK(res1)) {
36120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36121 }
36122 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36123 {
36124 PyThreadState* __tstate = wxPyBeginAllowThreads();
36125 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36126 wxPyEndAllowThreads(__tstate);
36127 if (PyErr_Occurred()) SWIG_fail;
36128 }
36129 resultobj = SWIG_From_int(static_cast< int >(result));
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36137 PyObject *resultobj = 0;
36138 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36139 int result;
36140 void *argp1 = 0 ;
36141 int res1 = 0 ;
36142 PyObject *swig_obj[1] ;
36143
36144 if (!args) SWIG_fail;
36145 swig_obj[0] = args;
36146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36147 if (!SWIG_IsOK(res1)) {
36148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36149 }
36150 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36154 wxPyEndAllowThreads(__tstate);
36155 if (PyErr_Occurred()) SWIG_fail;
36156 }
36157 resultobj = SWIG_From_int(static_cast< int >(result));
36158 return resultobj;
36159 fail:
36160 return NULL;
36161 }
36162
36163
36164 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36165 PyObject *resultobj = 0;
36166 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36167 int result;
36168 void *argp1 = 0 ;
36169 int res1 = 0 ;
36170 PyObject *swig_obj[1] ;
36171
36172 if (!args) SWIG_fail;
36173 swig_obj[0] = args;
36174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36175 if (!SWIG_IsOK(res1)) {
36176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36177 }
36178 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36179 {
36180 PyThreadState* __tstate = wxPyBeginAllowThreads();
36181 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36182 wxPyEndAllowThreads(__tstate);
36183 if (PyErr_Occurred()) SWIG_fail;
36184 }
36185 resultobj = SWIG_From_int(static_cast< int >(result));
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36193 PyObject *resultobj = 0;
36194 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36195 bool result;
36196 void *argp1 = 0 ;
36197 int res1 = 0 ;
36198 PyObject *swig_obj[1] ;
36199
36200 if (!args) SWIG_fail;
36201 swig_obj[0] = args;
36202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36203 if (!SWIG_IsOK(res1)) {
36204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36205 }
36206 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36207 {
36208 PyThreadState* __tstate = wxPyBeginAllowThreads();
36209 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36210 wxPyEndAllowThreads(__tstate);
36211 if (PyErr_Occurred()) SWIG_fail;
36212 }
36213 {
36214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36215 }
36216 return resultobj;
36217 fail:
36218 return NULL;
36219 }
36220
36221
36222 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36223 PyObject *resultobj = 0;
36224 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36225 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36226 bool result;
36227 void *argp1 = 0 ;
36228 int res1 = 0 ;
36229 void *argp2 = 0 ;
36230 int res2 = 0 ;
36231 PyObject * obj0 = 0 ;
36232 PyObject * obj1 = 0 ;
36233 char * kwnames[] = {
36234 (char *) "self",(char *) "other", NULL
36235 };
36236
36237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36239 if (!SWIG_IsOK(res1)) {
36240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36241 }
36242 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36244 if (!SWIG_IsOK(res2)) {
36245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36246 }
36247 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36248 {
36249 PyThreadState* __tstate = wxPyBeginAllowThreads();
36250 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36251 wxPyEndAllowThreads(__tstate);
36252 if (PyErr_Occurred()) SWIG_fail;
36253 }
36254 {
36255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36256 }
36257 return resultobj;
36258 fail:
36259 return NULL;
36260 }
36261
36262
36263 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36264 PyObject *resultobj = 0;
36265 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36266 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36267 bool result;
36268 void *argp1 = 0 ;
36269 int res1 = 0 ;
36270 void *argp2 = 0 ;
36271 int res2 = 0 ;
36272 PyObject * obj0 = 0 ;
36273 PyObject * obj1 = 0 ;
36274 char * kwnames[] = {
36275 (char *) "self",(char *) "other", NULL
36276 };
36277
36278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36280 if (!SWIG_IsOK(res1)) {
36281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36282 }
36283 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36285 if (!SWIG_IsOK(res2)) {
36286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36287 }
36288 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36289 {
36290 PyThreadState* __tstate = wxPyBeginAllowThreads();
36291 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36292 wxPyEndAllowThreads(__tstate);
36293 if (PyErr_Occurred()) SWIG_fail;
36294 }
36295 {
36296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36297 }
36298 return resultobj;
36299 fail:
36300 return NULL;
36301 }
36302
36303
36304 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36305 PyObject *resultobj = 0;
36306 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36307 int arg2 ;
36308 void *argp1 = 0 ;
36309 int res1 = 0 ;
36310 int val2 ;
36311 int ecode2 = 0 ;
36312 PyObject *swig_obj[2] ;
36313
36314 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36318 }
36319 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36320 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36321 if (!SWIG_IsOK(ecode2)) {
36322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36323 }
36324 arg2 = static_cast< int >(val2);
36325 if (arg1) (arg1)->w = arg2;
36326
36327 resultobj = SWIG_Py_Void();
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36335 PyObject *resultobj = 0;
36336 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36337 int result;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 PyObject *swig_obj[1] ;
36341
36342 if (!args) SWIG_fail;
36343 swig_obj[0] = args;
36344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36345 if (!SWIG_IsOK(res1)) {
36346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36347 }
36348 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36349 result = (int) ((arg1)->w);
36350 resultobj = SWIG_From_int(static_cast< int >(result));
36351 return resultobj;
36352 fail:
36353 return NULL;
36354 }
36355
36356
36357 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36358 PyObject *resultobj = 0;
36359 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36360 int arg2 ;
36361 void *argp1 = 0 ;
36362 int res1 = 0 ;
36363 int val2 ;
36364 int ecode2 = 0 ;
36365 PyObject *swig_obj[2] ;
36366
36367 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36369 if (!SWIG_IsOK(res1)) {
36370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36371 }
36372 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36373 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36374 if (!SWIG_IsOK(ecode2)) {
36375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36376 }
36377 arg2 = static_cast< int >(val2);
36378 if (arg1) (arg1)->h = arg2;
36379
36380 resultobj = SWIG_Py_Void();
36381 return resultobj;
36382 fail:
36383 return NULL;
36384 }
36385
36386
36387 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36388 PyObject *resultobj = 0;
36389 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36390 int result;
36391 void *argp1 = 0 ;
36392 int res1 = 0 ;
36393 PyObject *swig_obj[1] ;
36394
36395 if (!args) SWIG_fail;
36396 swig_obj[0] = args;
36397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36398 if (!SWIG_IsOK(res1)) {
36399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36400 }
36401 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36402 result = (int) ((arg1)->h);
36403 resultobj = SWIG_From_int(static_cast< int >(result));
36404 return resultobj;
36405 fail:
36406 return NULL;
36407 }
36408
36409
36410 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36411 PyObject *resultobj = 0;
36412 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36413 int arg2 ;
36414 void *argp1 = 0 ;
36415 int res1 = 0 ;
36416 int val2 ;
36417 int ecode2 = 0 ;
36418 PyObject *swig_obj[2] ;
36419
36420 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36422 if (!SWIG_IsOK(res1)) {
36423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36424 }
36425 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36426 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36427 if (!SWIG_IsOK(ecode2)) {
36428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36429 }
36430 arg2 = static_cast< int >(val2);
36431 if (arg1) (arg1)->bpp = arg2;
36432
36433 resultobj = SWIG_Py_Void();
36434 return resultobj;
36435 fail:
36436 return NULL;
36437 }
36438
36439
36440 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36441 PyObject *resultobj = 0;
36442 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36443 int result;
36444 void *argp1 = 0 ;
36445 int res1 = 0 ;
36446 PyObject *swig_obj[1] ;
36447
36448 if (!args) SWIG_fail;
36449 swig_obj[0] = args;
36450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36451 if (!SWIG_IsOK(res1)) {
36452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36453 }
36454 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36455 result = (int) ((arg1)->bpp);
36456 resultobj = SWIG_From_int(static_cast< int >(result));
36457 return resultobj;
36458 fail:
36459 return NULL;
36460 }
36461
36462
36463 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36464 PyObject *resultobj = 0;
36465 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36466 int arg2 ;
36467 void *argp1 = 0 ;
36468 int res1 = 0 ;
36469 int val2 ;
36470 int ecode2 = 0 ;
36471 PyObject *swig_obj[2] ;
36472
36473 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36477 }
36478 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36479 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36480 if (!SWIG_IsOK(ecode2)) {
36481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36482 }
36483 arg2 = static_cast< int >(val2);
36484 if (arg1) (arg1)->refresh = arg2;
36485
36486 resultobj = SWIG_Py_Void();
36487 return resultobj;
36488 fail:
36489 return NULL;
36490 }
36491
36492
36493 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36494 PyObject *resultobj = 0;
36495 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36496 int result;
36497 void *argp1 = 0 ;
36498 int res1 = 0 ;
36499 PyObject *swig_obj[1] ;
36500
36501 if (!args) SWIG_fail;
36502 swig_obj[0] = args;
36503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36504 if (!SWIG_IsOK(res1)) {
36505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36506 }
36507 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36508 result = (int) ((arg1)->refresh);
36509 resultobj = SWIG_From_int(static_cast< int >(result));
36510 return resultobj;
36511 fail:
36512 return NULL;
36513 }
36514
36515
36516 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36517 PyObject *obj;
36518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36519 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36520 return SWIG_Py_Void();
36521 }
36522
36523 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36524 return SWIG_Python_InitShadowInstance(args);
36525 }
36526
36527 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36528 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36529 return 1;
36530 }
36531
36532
36533 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36534 PyObject *pyobj = 0;
36535
36536 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36537 return pyobj;
36538 }
36539
36540
36541 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36542 PyObject *resultobj = 0;
36543 unsigned int arg1 = (unsigned int) 0 ;
36544 wxDisplay *result = 0 ;
36545 unsigned int val1 ;
36546 int ecode1 = 0 ;
36547 PyObject * obj0 = 0 ;
36548 char * kwnames[] = {
36549 (char *) "index", NULL
36550 };
36551
36552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36553 if (obj0) {
36554 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36555 if (!SWIG_IsOK(ecode1)) {
36556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36557 }
36558 arg1 = static_cast< unsigned int >(val1);
36559 }
36560 {
36561 PyThreadState* __tstate = wxPyBeginAllowThreads();
36562 result = (wxDisplay *)new wxDisplay(arg1);
36563 wxPyEndAllowThreads(__tstate);
36564 if (PyErr_Occurred()) SWIG_fail;
36565 }
36566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36567 return resultobj;
36568 fail:
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36574 PyObject *resultobj = 0;
36575 wxDisplay *arg1 = (wxDisplay *) 0 ;
36576 void *argp1 = 0 ;
36577 int res1 = 0 ;
36578 PyObject *swig_obj[1] ;
36579
36580 if (!args) SWIG_fail;
36581 swig_obj[0] = args;
36582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36583 if (!SWIG_IsOK(res1)) {
36584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36585 }
36586 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36587 {
36588 PyThreadState* __tstate = wxPyBeginAllowThreads();
36589 delete arg1;
36590
36591 wxPyEndAllowThreads(__tstate);
36592 if (PyErr_Occurred()) SWIG_fail;
36593 }
36594 resultobj = SWIG_Py_Void();
36595 return resultobj;
36596 fail:
36597 return NULL;
36598 }
36599
36600
36601 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36602 PyObject *resultobj = 0;
36603 unsigned int result;
36604
36605 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36606 {
36607 PyThreadState* __tstate = wxPyBeginAllowThreads();
36608 result = (unsigned int)wxDisplay::GetCount();
36609 wxPyEndAllowThreads(__tstate);
36610 if (PyErr_Occurred()) SWIG_fail;
36611 }
36612 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36613 return resultobj;
36614 fail:
36615 return NULL;
36616 }
36617
36618
36619 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36620 PyObject *resultobj = 0;
36621 wxPoint *arg1 = 0 ;
36622 int result;
36623 wxPoint temp1 ;
36624 PyObject * obj0 = 0 ;
36625 char * kwnames[] = {
36626 (char *) "pt", NULL
36627 };
36628
36629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36630 {
36631 arg1 = &temp1;
36632 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36633 }
36634 {
36635 PyThreadState* __tstate = wxPyBeginAllowThreads();
36636 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36637 wxPyEndAllowThreads(__tstate);
36638 if (PyErr_Occurred()) SWIG_fail;
36639 }
36640 resultobj = SWIG_From_int(static_cast< int >(result));
36641 return resultobj;
36642 fail:
36643 return NULL;
36644 }
36645
36646
36647 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36648 PyObject *resultobj = 0;
36649 wxWindow *arg1 = (wxWindow *) 0 ;
36650 int result;
36651 void *argp1 = 0 ;
36652 int res1 = 0 ;
36653 PyObject * obj0 = 0 ;
36654 char * kwnames[] = {
36655 (char *) "window", NULL
36656 };
36657
36658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36660 if (!SWIG_IsOK(res1)) {
36661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow const *""'");
36662 }
36663 arg1 = reinterpret_cast< wxWindow * >(argp1);
36664 {
36665 PyThreadState* __tstate = wxPyBeginAllowThreads();
36666 result = (int)wxDisplay::GetFromWindow((wxWindow const *)arg1);
36667 wxPyEndAllowThreads(__tstate);
36668 if (PyErr_Occurred()) SWIG_fail;
36669 }
36670 resultobj = SWIG_From_int(static_cast< int >(result));
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36678 PyObject *resultobj = 0;
36679 wxDisplay *arg1 = (wxDisplay *) 0 ;
36680 bool result;
36681 void *argp1 = 0 ;
36682 int res1 = 0 ;
36683 PyObject *swig_obj[1] ;
36684
36685 if (!args) SWIG_fail;
36686 swig_obj[0] = args;
36687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36688 if (!SWIG_IsOK(res1)) {
36689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36690 }
36691 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36692 {
36693 PyThreadState* __tstate = wxPyBeginAllowThreads();
36694 result = (bool)((wxDisplay const *)arg1)->IsOk();
36695 wxPyEndAllowThreads(__tstate);
36696 if (PyErr_Occurred()) SWIG_fail;
36697 }
36698 {
36699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36700 }
36701 return resultobj;
36702 fail:
36703 return NULL;
36704 }
36705
36706
36707 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36708 PyObject *resultobj = 0;
36709 wxDisplay *arg1 = (wxDisplay *) 0 ;
36710 wxRect result;
36711 void *argp1 = 0 ;
36712 int res1 = 0 ;
36713 PyObject *swig_obj[1] ;
36714
36715 if (!args) SWIG_fail;
36716 swig_obj[0] = args;
36717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36718 if (!SWIG_IsOK(res1)) {
36719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36720 }
36721 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36722 {
36723 PyThreadState* __tstate = wxPyBeginAllowThreads();
36724 result = ((wxDisplay const *)arg1)->GetGeometry();
36725 wxPyEndAllowThreads(__tstate);
36726 if (PyErr_Occurred()) SWIG_fail;
36727 }
36728 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36729 return resultobj;
36730 fail:
36731 return NULL;
36732 }
36733
36734
36735 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36736 PyObject *resultobj = 0;
36737 wxDisplay *arg1 = (wxDisplay *) 0 ;
36738 wxRect result;
36739 void *argp1 = 0 ;
36740 int res1 = 0 ;
36741 PyObject *swig_obj[1] ;
36742
36743 if (!args) SWIG_fail;
36744 swig_obj[0] = args;
36745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36746 if (!SWIG_IsOK(res1)) {
36747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36748 }
36749 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 result = ((wxDisplay const *)arg1)->GetClientArea();
36753 wxPyEndAllowThreads(__tstate);
36754 if (PyErr_Occurred()) SWIG_fail;
36755 }
36756 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36757 return resultobj;
36758 fail:
36759 return NULL;
36760 }
36761
36762
36763 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36764 PyObject *resultobj = 0;
36765 wxDisplay *arg1 = (wxDisplay *) 0 ;
36766 wxString result;
36767 void *argp1 = 0 ;
36768 int res1 = 0 ;
36769 PyObject *swig_obj[1] ;
36770
36771 if (!args) SWIG_fail;
36772 swig_obj[0] = args;
36773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36774 if (!SWIG_IsOK(res1)) {
36775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36776 }
36777 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36778 {
36779 PyThreadState* __tstate = wxPyBeginAllowThreads();
36780 result = ((wxDisplay const *)arg1)->GetName();
36781 wxPyEndAllowThreads(__tstate);
36782 if (PyErr_Occurred()) SWIG_fail;
36783 }
36784 {
36785 #if wxUSE_UNICODE
36786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36787 #else
36788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36789 #endif
36790 }
36791 return resultobj;
36792 fail:
36793 return NULL;
36794 }
36795
36796
36797 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36798 PyObject *resultobj = 0;
36799 wxDisplay *arg1 = (wxDisplay *) 0 ;
36800 bool result;
36801 void *argp1 = 0 ;
36802 int res1 = 0 ;
36803 PyObject *swig_obj[1] ;
36804
36805 if (!args) SWIG_fail;
36806 swig_obj[0] = args;
36807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36808 if (!SWIG_IsOK(res1)) {
36809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36810 }
36811 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36812 {
36813 PyThreadState* __tstate = wxPyBeginAllowThreads();
36814 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36815 wxPyEndAllowThreads(__tstate);
36816 if (PyErr_Occurred()) SWIG_fail;
36817 }
36818 {
36819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36820 }
36821 return resultobj;
36822 fail:
36823 return NULL;
36824 }
36825
36826
36827 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36828 PyObject *resultobj = 0;
36829 wxDisplay *arg1 = (wxDisplay *) 0 ;
36830 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36831 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36832 PyObject *result = 0 ;
36833 void *argp1 = 0 ;
36834 int res1 = 0 ;
36835 void *argp2 = 0 ;
36836 int res2 = 0 ;
36837 PyObject * obj0 = 0 ;
36838 PyObject * obj1 = 0 ;
36839 char * kwnames[] = {
36840 (char *) "self",(char *) "mode", NULL
36841 };
36842
36843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36845 if (!SWIG_IsOK(res1)) {
36846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36847 }
36848 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36849 if (obj1) {
36850 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36851 if (!SWIG_IsOK(res2)) {
36852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36853 }
36854 if (!argp2) {
36855 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36856 }
36857 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36858 }
36859 {
36860 PyThreadState* __tstate = wxPyBeginAllowThreads();
36861 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36862 wxPyEndAllowThreads(__tstate);
36863 if (PyErr_Occurred()) SWIG_fail;
36864 }
36865 resultobj = result;
36866 return resultobj;
36867 fail:
36868 return NULL;
36869 }
36870
36871
36872 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36873 PyObject *resultobj = 0;
36874 wxDisplay *arg1 = (wxDisplay *) 0 ;
36875 wxVideoMode result;
36876 void *argp1 = 0 ;
36877 int res1 = 0 ;
36878 PyObject *swig_obj[1] ;
36879
36880 if (!args) SWIG_fail;
36881 swig_obj[0] = args;
36882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36883 if (!SWIG_IsOK(res1)) {
36884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36885 }
36886 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36887 {
36888 PyThreadState* __tstate = wxPyBeginAllowThreads();
36889 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36890 wxPyEndAllowThreads(__tstate);
36891 if (PyErr_Occurred()) SWIG_fail;
36892 }
36893 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36894 return resultobj;
36895 fail:
36896 return NULL;
36897 }
36898
36899
36900 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36901 PyObject *resultobj = 0;
36902 wxDisplay *arg1 = (wxDisplay *) 0 ;
36903 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36904 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36905 bool result;
36906 void *argp1 = 0 ;
36907 int res1 = 0 ;
36908 void *argp2 = 0 ;
36909 int res2 = 0 ;
36910 PyObject * obj0 = 0 ;
36911 PyObject * obj1 = 0 ;
36912 char * kwnames[] = {
36913 (char *) "self",(char *) "mode", NULL
36914 };
36915
36916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36920 }
36921 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36922 if (obj1) {
36923 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36924 if (!SWIG_IsOK(res2)) {
36925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36926 }
36927 if (!argp2) {
36928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36929 }
36930 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36931 }
36932 {
36933 PyThreadState* __tstate = wxPyBeginAllowThreads();
36934 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36935 wxPyEndAllowThreads(__tstate);
36936 if (PyErr_Occurred()) SWIG_fail;
36937 }
36938 {
36939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36940 }
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36948 PyObject *resultobj = 0;
36949 wxDisplay *arg1 = (wxDisplay *) 0 ;
36950 void *argp1 = 0 ;
36951 int res1 = 0 ;
36952 PyObject *swig_obj[1] ;
36953
36954 if (!args) SWIG_fail;
36955 swig_obj[0] = args;
36956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36957 if (!SWIG_IsOK(res1)) {
36958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36959 }
36960 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 wxDisplay_ResetMode(arg1);
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 resultobj = SWIG_Py_Void();
36968 return resultobj;
36969 fail:
36970 return NULL;
36971 }
36972
36973
36974 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36975 PyObject *obj;
36976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36977 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36978 return SWIG_Py_Void();
36979 }
36980
36981 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36982 return SWIG_Python_InitShadowInstance(args);
36983 }
36984
36985 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36986 PyObject *resultobj = 0;
36987 wxStandardPaths *result = 0 ;
36988
36989 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36990 {
36991 PyThreadState* __tstate = wxPyBeginAllowThreads();
36992 result = (wxStandardPaths *)wxStandardPaths_Get();
36993 wxPyEndAllowThreads(__tstate);
36994 if (PyErr_Occurred()) SWIG_fail;
36995 }
36996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36997 return resultobj;
36998 fail:
36999 return NULL;
37000 }
37001
37002
37003 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37004 PyObject *resultobj = 0;
37005 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37006 wxString result;
37007 void *argp1 = 0 ;
37008 int res1 = 0 ;
37009 PyObject *swig_obj[1] ;
37010
37011 if (!args) SWIG_fail;
37012 swig_obj[0] = args;
37013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37014 if (!SWIG_IsOK(res1)) {
37015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37016 }
37017 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37018 {
37019 PyThreadState* __tstate = wxPyBeginAllowThreads();
37020 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
37021 wxPyEndAllowThreads(__tstate);
37022 if (PyErr_Occurred()) SWIG_fail;
37023 }
37024 {
37025 #if wxUSE_UNICODE
37026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37027 #else
37028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37029 #endif
37030 }
37031 return resultobj;
37032 fail:
37033 return NULL;
37034 }
37035
37036
37037 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37038 PyObject *resultobj = 0;
37039 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37040 wxString result;
37041 void *argp1 = 0 ;
37042 int res1 = 0 ;
37043 PyObject *swig_obj[1] ;
37044
37045 if (!args) SWIG_fail;
37046 swig_obj[0] = args;
37047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37048 if (!SWIG_IsOK(res1)) {
37049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37050 }
37051 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37052 {
37053 PyThreadState* __tstate = wxPyBeginAllowThreads();
37054 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
37055 wxPyEndAllowThreads(__tstate);
37056 if (PyErr_Occurred()) SWIG_fail;
37057 }
37058 {
37059 #if wxUSE_UNICODE
37060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37061 #else
37062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37063 #endif
37064 }
37065 return resultobj;
37066 fail:
37067 return NULL;
37068 }
37069
37070
37071 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37072 PyObject *resultobj = 0;
37073 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37074 wxString result;
37075 void *argp1 = 0 ;
37076 int res1 = 0 ;
37077 PyObject *swig_obj[1] ;
37078
37079 if (!args) SWIG_fail;
37080 swig_obj[0] = args;
37081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37082 if (!SWIG_IsOK(res1)) {
37083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37084 }
37085 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37086 {
37087 PyThreadState* __tstate = wxPyBeginAllowThreads();
37088 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
37089 wxPyEndAllowThreads(__tstate);
37090 if (PyErr_Occurred()) SWIG_fail;
37091 }
37092 {
37093 #if wxUSE_UNICODE
37094 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37095 #else
37096 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37097 #endif
37098 }
37099 return resultobj;
37100 fail:
37101 return NULL;
37102 }
37103
37104
37105 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37106 PyObject *resultobj = 0;
37107 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37108 wxString result;
37109 void *argp1 = 0 ;
37110 int res1 = 0 ;
37111 PyObject *swig_obj[1] ;
37112
37113 if (!args) SWIG_fail;
37114 swig_obj[0] = args;
37115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37116 if (!SWIG_IsOK(res1)) {
37117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37118 }
37119 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37120 {
37121 PyThreadState* __tstate = wxPyBeginAllowThreads();
37122 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37123 wxPyEndAllowThreads(__tstate);
37124 if (PyErr_Occurred()) SWIG_fail;
37125 }
37126 {
37127 #if wxUSE_UNICODE
37128 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37129 #else
37130 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37131 #endif
37132 }
37133 return resultobj;
37134 fail:
37135 return NULL;
37136 }
37137
37138
37139 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37140 PyObject *resultobj = 0;
37141 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37142 wxString result;
37143 void *argp1 = 0 ;
37144 int res1 = 0 ;
37145 PyObject *swig_obj[1] ;
37146
37147 if (!args) SWIG_fail;
37148 swig_obj[0] = args;
37149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37150 if (!SWIG_IsOK(res1)) {
37151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37152 }
37153 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 {
37161 #if wxUSE_UNICODE
37162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37163 #else
37164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37165 #endif
37166 }
37167 return resultobj;
37168 fail:
37169 return NULL;
37170 }
37171
37172
37173 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37174 PyObject *resultobj = 0;
37175 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37176 wxString result;
37177 void *argp1 = 0 ;
37178 int res1 = 0 ;
37179 PyObject *swig_obj[1] ;
37180
37181 if (!args) SWIG_fail;
37182 swig_obj[0] = args;
37183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37184 if (!SWIG_IsOK(res1)) {
37185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37186 }
37187 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 {
37195 #if wxUSE_UNICODE
37196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37197 #else
37198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37199 #endif
37200 }
37201 return resultobj;
37202 fail:
37203 return NULL;
37204 }
37205
37206
37207 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37208 PyObject *resultobj = 0;
37209 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37210 wxString result;
37211 void *argp1 = 0 ;
37212 int res1 = 0 ;
37213 PyObject *swig_obj[1] ;
37214
37215 if (!args) SWIG_fail;
37216 swig_obj[0] = args;
37217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37218 if (!SWIG_IsOK(res1)) {
37219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37220 }
37221 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37222 {
37223 PyThreadState* __tstate = wxPyBeginAllowThreads();
37224 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37225 wxPyEndAllowThreads(__tstate);
37226 if (PyErr_Occurred()) SWIG_fail;
37227 }
37228 {
37229 #if wxUSE_UNICODE
37230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37231 #else
37232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37233 #endif
37234 }
37235 return resultobj;
37236 fail:
37237 return NULL;
37238 }
37239
37240
37241 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37242 PyObject *resultobj = 0;
37243 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37244 wxString result;
37245 void *argp1 = 0 ;
37246 int res1 = 0 ;
37247 PyObject *swig_obj[1] ;
37248
37249 if (!args) SWIG_fail;
37250 swig_obj[0] = args;
37251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37252 if (!SWIG_IsOK(res1)) {
37253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37254 }
37255 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37256 {
37257 PyThreadState* __tstate = wxPyBeginAllowThreads();
37258 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37259 wxPyEndAllowThreads(__tstate);
37260 if (PyErr_Occurred()) SWIG_fail;
37261 }
37262 {
37263 #if wxUSE_UNICODE
37264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37265 #else
37266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37267 #endif
37268 }
37269 return resultobj;
37270 fail:
37271 return NULL;
37272 }
37273
37274
37275 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37276 PyObject *resultobj = 0;
37277 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37278 wxString result;
37279 void *argp1 = 0 ;
37280 int res1 = 0 ;
37281 PyObject *swig_obj[1] ;
37282
37283 if (!args) SWIG_fail;
37284 swig_obj[0] = args;
37285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37286 if (!SWIG_IsOK(res1)) {
37287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37288 }
37289 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37290 {
37291 PyThreadState* __tstate = wxPyBeginAllowThreads();
37292 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37293 wxPyEndAllowThreads(__tstate);
37294 if (PyErr_Occurred()) SWIG_fail;
37295 }
37296 {
37297 #if wxUSE_UNICODE
37298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37299 #else
37300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37301 #endif
37302 }
37303 return resultobj;
37304 fail:
37305 return NULL;
37306 }
37307
37308
37309 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37310 PyObject *resultobj = 0;
37311 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37312 wxString *arg2 = 0 ;
37313 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37314 wxString result;
37315 void *argp1 = 0 ;
37316 int res1 = 0 ;
37317 bool temp2 = false ;
37318 int val3 ;
37319 int ecode3 = 0 ;
37320 PyObject * obj0 = 0 ;
37321 PyObject * obj1 = 0 ;
37322 PyObject * obj2 = 0 ;
37323 char * kwnames[] = {
37324 (char *) "self",(char *) "lang",(char *) "category", NULL
37325 };
37326
37327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37329 if (!SWIG_IsOK(res1)) {
37330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37331 }
37332 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37333 {
37334 arg2 = wxString_in_helper(obj1);
37335 if (arg2 == NULL) SWIG_fail;
37336 temp2 = true;
37337 }
37338 if (obj2) {
37339 ecode3 = SWIG_AsVal_int(obj2, &val3);
37340 if (!SWIG_IsOK(ecode3)) {
37341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37342 }
37343 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37344 }
37345 {
37346 PyThreadState* __tstate = wxPyBeginAllowThreads();
37347 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37348 wxPyEndAllowThreads(__tstate);
37349 if (PyErr_Occurred()) SWIG_fail;
37350 }
37351 {
37352 #if wxUSE_UNICODE
37353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37354 #else
37355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37356 #endif
37357 }
37358 {
37359 if (temp2)
37360 delete arg2;
37361 }
37362 return resultobj;
37363 fail:
37364 {
37365 if (temp2)
37366 delete arg2;
37367 }
37368 return NULL;
37369 }
37370
37371
37372 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37373 PyObject *resultobj = 0;
37374 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37375 wxString result;
37376 void *argp1 = 0 ;
37377 int res1 = 0 ;
37378 PyObject *swig_obj[1] ;
37379
37380 if (!args) SWIG_fail;
37381 swig_obj[0] = args;
37382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37383 if (!SWIG_IsOK(res1)) {
37384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37385 }
37386 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37387 {
37388 PyThreadState* __tstate = wxPyBeginAllowThreads();
37389 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37390 wxPyEndAllowThreads(__tstate);
37391 if (PyErr_Occurred()) SWIG_fail;
37392 }
37393 {
37394 #if wxUSE_UNICODE
37395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37396 #else
37397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37398 #endif
37399 }
37400 return resultobj;
37401 fail:
37402 return NULL;
37403 }
37404
37405
37406 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37407 PyObject *resultobj = 0;
37408 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37409 wxString result;
37410 void *argp1 = 0 ;
37411 int res1 = 0 ;
37412 PyObject *swig_obj[1] ;
37413
37414 if (!args) SWIG_fail;
37415 swig_obj[0] = args;
37416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37417 if (!SWIG_IsOK(res1)) {
37418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37419 }
37420 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37421 {
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37424 wxPyEndAllowThreads(__tstate);
37425 if (PyErr_Occurred()) SWIG_fail;
37426 }
37427 {
37428 #if wxUSE_UNICODE
37429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37430 #else
37431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37432 #endif
37433 }
37434 return resultobj;
37435 fail:
37436 return NULL;
37437 }
37438
37439
37440 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37441 PyObject *resultobj = 0;
37442 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37443 wxString *arg2 = 0 ;
37444 void *argp1 = 0 ;
37445 int res1 = 0 ;
37446 bool temp2 = false ;
37447 PyObject * obj0 = 0 ;
37448 PyObject * obj1 = 0 ;
37449 char * kwnames[] = {
37450 (char *) "self",(char *) "prefix", NULL
37451 };
37452
37453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37455 if (!SWIG_IsOK(res1)) {
37456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37457 }
37458 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37459 {
37460 arg2 = wxString_in_helper(obj1);
37461 if (arg2 == NULL) SWIG_fail;
37462 temp2 = true;
37463 }
37464 {
37465 PyThreadState* __tstate = wxPyBeginAllowThreads();
37466 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37467 wxPyEndAllowThreads(__tstate);
37468 if (PyErr_Occurred()) SWIG_fail;
37469 }
37470 resultobj = SWIG_Py_Void();
37471 {
37472 if (temp2)
37473 delete arg2;
37474 }
37475 return resultobj;
37476 fail:
37477 {
37478 if (temp2)
37479 delete arg2;
37480 }
37481 return NULL;
37482 }
37483
37484
37485 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37486 PyObject *resultobj = 0;
37487 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37488 wxString result;
37489 void *argp1 = 0 ;
37490 int res1 = 0 ;
37491 PyObject *swig_obj[1] ;
37492
37493 if (!args) SWIG_fail;
37494 swig_obj[0] = args;
37495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37496 if (!SWIG_IsOK(res1)) {
37497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37498 }
37499 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37500 {
37501 PyThreadState* __tstate = wxPyBeginAllowThreads();
37502 result = wxStandardPaths_GetInstallPrefix(arg1);
37503 wxPyEndAllowThreads(__tstate);
37504 if (PyErr_Occurred()) SWIG_fail;
37505 }
37506 {
37507 #if wxUSE_UNICODE
37508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37509 #else
37510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37511 #endif
37512 }
37513 return resultobj;
37514 fail:
37515 return NULL;
37516 }
37517
37518
37519 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37520 PyObject *obj;
37521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37522 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37523 return SWIG_Py_Void();
37524 }
37525
37526 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37527 PyObject *resultobj = 0;
37528 wxEventType arg1 ;
37529 wxPowerEvent *result = 0 ;
37530 int val1 ;
37531 int ecode1 = 0 ;
37532 PyObject * obj0 = 0 ;
37533 char * kwnames[] = {
37534 (char *) "evtType", NULL
37535 };
37536
37537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37538 ecode1 = SWIG_AsVal_int(obj0, &val1);
37539 if (!SWIG_IsOK(ecode1)) {
37540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37541 }
37542 arg1 = static_cast< wxEventType >(val1);
37543 {
37544 PyThreadState* __tstate = wxPyBeginAllowThreads();
37545 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37546 wxPyEndAllowThreads(__tstate);
37547 if (PyErr_Occurred()) SWIG_fail;
37548 }
37549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37550 return resultobj;
37551 fail:
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37557 PyObject *resultobj = 0;
37558 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37559 void *argp1 = 0 ;
37560 int res1 = 0 ;
37561 PyObject *swig_obj[1] ;
37562
37563 if (!args) SWIG_fail;
37564 swig_obj[0] = args;
37565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37566 if (!SWIG_IsOK(res1)) {
37567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37568 }
37569 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37570 {
37571 PyThreadState* __tstate = wxPyBeginAllowThreads();
37572 (arg1)->Veto();
37573 wxPyEndAllowThreads(__tstate);
37574 if (PyErr_Occurred()) SWIG_fail;
37575 }
37576 resultobj = SWIG_Py_Void();
37577 return resultobj;
37578 fail:
37579 return NULL;
37580 }
37581
37582
37583 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37584 PyObject *resultobj = 0;
37585 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37586 bool result;
37587 void *argp1 = 0 ;
37588 int res1 = 0 ;
37589 PyObject *swig_obj[1] ;
37590
37591 if (!args) SWIG_fail;
37592 swig_obj[0] = args;
37593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37594 if (!SWIG_IsOK(res1)) {
37595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37596 }
37597 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37598 {
37599 PyThreadState* __tstate = wxPyBeginAllowThreads();
37600 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37601 wxPyEndAllowThreads(__tstate);
37602 if (PyErr_Occurred()) SWIG_fail;
37603 }
37604 {
37605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37606 }
37607 return resultobj;
37608 fail:
37609 return NULL;
37610 }
37611
37612
37613 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37614 PyObject *obj;
37615 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37616 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37617 return SWIG_Py_Void();
37618 }
37619
37620 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37621 return SWIG_Python_InitShadowInstance(args);
37622 }
37623
37624 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37625 PyObject *resultobj = 0;
37626 wxPowerType result;
37627
37628 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37629 {
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 result = (wxPowerType)wxGetPowerType();
37632 wxPyEndAllowThreads(__tstate);
37633 if (PyErr_Occurred()) SWIG_fail;
37634 }
37635 resultobj = SWIG_From_int(static_cast< int >(result));
37636 return resultobj;
37637 fail:
37638 return NULL;
37639 }
37640
37641
37642 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37643 PyObject *resultobj = 0;
37644 wxBatteryState result;
37645
37646 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 result = (wxBatteryState)wxGetBatteryState();
37650 wxPyEndAllowThreads(__tstate);
37651 if (PyErr_Occurred()) SWIG_fail;
37652 }
37653 resultobj = SWIG_From_int(static_cast< int >(result));
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37661 PyObject *resultobj = 0;
37662 wxAboutDialogInfo *result = 0 ;
37663
37664 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37665 {
37666 PyThreadState* __tstate = wxPyBeginAllowThreads();
37667 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37668 wxPyEndAllowThreads(__tstate);
37669 if (PyErr_Occurred()) SWIG_fail;
37670 }
37671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37672 return resultobj;
37673 fail:
37674 return NULL;
37675 }
37676
37677
37678 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37679 PyObject *resultobj = 0;
37680 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37681 void *argp1 = 0 ;
37682 int res1 = 0 ;
37683 PyObject *swig_obj[1] ;
37684
37685 if (!args) SWIG_fail;
37686 swig_obj[0] = args;
37687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37688 if (!SWIG_IsOK(res1)) {
37689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37690 }
37691 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37692 {
37693 PyThreadState* __tstate = wxPyBeginAllowThreads();
37694 delete arg1;
37695
37696 wxPyEndAllowThreads(__tstate);
37697 if (PyErr_Occurred()) SWIG_fail;
37698 }
37699 resultobj = SWIG_Py_Void();
37700 return resultobj;
37701 fail:
37702 return NULL;
37703 }
37704
37705
37706 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37707 PyObject *resultobj = 0;
37708 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37709 wxString *arg2 = 0 ;
37710 void *argp1 = 0 ;
37711 int res1 = 0 ;
37712 bool temp2 = false ;
37713 PyObject * obj0 = 0 ;
37714 PyObject * obj1 = 0 ;
37715 char * kwnames[] = {
37716 (char *) "self",(char *) "name", NULL
37717 };
37718
37719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37721 if (!SWIG_IsOK(res1)) {
37722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37723 }
37724 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37725 {
37726 arg2 = wxString_in_helper(obj1);
37727 if (arg2 == NULL) SWIG_fail;
37728 temp2 = true;
37729 }
37730 {
37731 PyThreadState* __tstate = wxPyBeginAllowThreads();
37732 (arg1)->SetName((wxString const &)*arg2);
37733 wxPyEndAllowThreads(__tstate);
37734 if (PyErr_Occurred()) SWIG_fail;
37735 }
37736 resultobj = SWIG_Py_Void();
37737 {
37738 if (temp2)
37739 delete arg2;
37740 }
37741 return resultobj;
37742 fail:
37743 {
37744 if (temp2)
37745 delete arg2;
37746 }
37747 return NULL;
37748 }
37749
37750
37751 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37752 PyObject *resultobj = 0;
37753 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37754 wxString result;
37755 void *argp1 = 0 ;
37756 int res1 = 0 ;
37757 PyObject *swig_obj[1] ;
37758
37759 if (!args) SWIG_fail;
37760 swig_obj[0] = args;
37761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37762 if (!SWIG_IsOK(res1)) {
37763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37764 }
37765 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37766 {
37767 PyThreadState* __tstate = wxPyBeginAllowThreads();
37768 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37769 wxPyEndAllowThreads(__tstate);
37770 if (PyErr_Occurred()) SWIG_fail;
37771 }
37772 {
37773 #if wxUSE_UNICODE
37774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37775 #else
37776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37777 #endif
37778 }
37779 return resultobj;
37780 fail:
37781 return NULL;
37782 }
37783
37784
37785 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37786 PyObject *resultobj = 0;
37787 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37788 wxString *arg2 = 0 ;
37789 void *argp1 = 0 ;
37790 int res1 = 0 ;
37791 bool temp2 = false ;
37792 PyObject * obj0 = 0 ;
37793 PyObject * obj1 = 0 ;
37794 char * kwnames[] = {
37795 (char *) "self",(char *) "version", NULL
37796 };
37797
37798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37800 if (!SWIG_IsOK(res1)) {
37801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37802 }
37803 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37804 {
37805 arg2 = wxString_in_helper(obj1);
37806 if (arg2 == NULL) SWIG_fail;
37807 temp2 = true;
37808 }
37809 {
37810 PyThreadState* __tstate = wxPyBeginAllowThreads();
37811 (arg1)->SetVersion((wxString const &)*arg2);
37812 wxPyEndAllowThreads(__tstate);
37813 if (PyErr_Occurred()) SWIG_fail;
37814 }
37815 resultobj = SWIG_Py_Void();
37816 {
37817 if (temp2)
37818 delete arg2;
37819 }
37820 return resultobj;
37821 fail:
37822 {
37823 if (temp2)
37824 delete arg2;
37825 }
37826 return NULL;
37827 }
37828
37829
37830 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37831 PyObject *resultobj = 0;
37832 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37833 bool result;
37834 void *argp1 = 0 ;
37835 int res1 = 0 ;
37836 PyObject *swig_obj[1] ;
37837
37838 if (!args) SWIG_fail;
37839 swig_obj[0] = args;
37840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37841 if (!SWIG_IsOK(res1)) {
37842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37843 }
37844 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37845 {
37846 PyThreadState* __tstate = wxPyBeginAllowThreads();
37847 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37848 wxPyEndAllowThreads(__tstate);
37849 if (PyErr_Occurred()) SWIG_fail;
37850 }
37851 {
37852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37853 }
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37861 PyObject *resultobj = 0;
37862 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37863 wxString result;
37864 void *argp1 = 0 ;
37865 int res1 = 0 ;
37866 PyObject *swig_obj[1] ;
37867
37868 if (!args) SWIG_fail;
37869 swig_obj[0] = args;
37870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37871 if (!SWIG_IsOK(res1)) {
37872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37873 }
37874 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37875 {
37876 PyThreadState* __tstate = wxPyBeginAllowThreads();
37877 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 #if wxUSE_UNICODE
37883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37884 #else
37885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37886 #endif
37887 }
37888 return resultobj;
37889 fail:
37890 return NULL;
37891 }
37892
37893
37894 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37895 PyObject *resultobj = 0;
37896 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37897 wxString *arg2 = 0 ;
37898 void *argp1 = 0 ;
37899 int res1 = 0 ;
37900 bool temp2 = false ;
37901 PyObject * obj0 = 0 ;
37902 PyObject * obj1 = 0 ;
37903 char * kwnames[] = {
37904 (char *) "self",(char *) "desc", NULL
37905 };
37906
37907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37909 if (!SWIG_IsOK(res1)) {
37910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37911 }
37912 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37913 {
37914 arg2 = wxString_in_helper(obj1);
37915 if (arg2 == NULL) SWIG_fail;
37916 temp2 = true;
37917 }
37918 {
37919 PyThreadState* __tstate = wxPyBeginAllowThreads();
37920 (arg1)->SetDescription((wxString const &)*arg2);
37921 wxPyEndAllowThreads(__tstate);
37922 if (PyErr_Occurred()) SWIG_fail;
37923 }
37924 resultobj = SWIG_Py_Void();
37925 {
37926 if (temp2)
37927 delete arg2;
37928 }
37929 return resultobj;
37930 fail:
37931 {
37932 if (temp2)
37933 delete arg2;
37934 }
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37940 PyObject *resultobj = 0;
37941 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37942 bool result;
37943 void *argp1 = 0 ;
37944 int res1 = 0 ;
37945 PyObject *swig_obj[1] ;
37946
37947 if (!args) SWIG_fail;
37948 swig_obj[0] = args;
37949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37950 if (!SWIG_IsOK(res1)) {
37951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37952 }
37953 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37954 {
37955 PyThreadState* __tstate = wxPyBeginAllowThreads();
37956 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37957 wxPyEndAllowThreads(__tstate);
37958 if (PyErr_Occurred()) SWIG_fail;
37959 }
37960 {
37961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37962 }
37963 return resultobj;
37964 fail:
37965 return NULL;
37966 }
37967
37968
37969 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37970 PyObject *resultobj = 0;
37971 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37972 wxString result;
37973 void *argp1 = 0 ;
37974 int res1 = 0 ;
37975 PyObject *swig_obj[1] ;
37976
37977 if (!args) SWIG_fail;
37978 swig_obj[0] = args;
37979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37980 if (!SWIG_IsOK(res1)) {
37981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37982 }
37983 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37984 {
37985 PyThreadState* __tstate = wxPyBeginAllowThreads();
37986 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 {
37991 #if wxUSE_UNICODE
37992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37993 #else
37994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37995 #endif
37996 }
37997 return resultobj;
37998 fail:
37999 return NULL;
38000 }
38001
38002
38003 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38004 PyObject *resultobj = 0;
38005 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38006 wxString *arg2 = 0 ;
38007 void *argp1 = 0 ;
38008 int res1 = 0 ;
38009 bool temp2 = false ;
38010 PyObject * obj0 = 0 ;
38011 PyObject * obj1 = 0 ;
38012 char * kwnames[] = {
38013 (char *) "self",(char *) "copyright", NULL
38014 };
38015
38016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
38017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38018 if (!SWIG_IsOK(res1)) {
38019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38020 }
38021 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38022 {
38023 arg2 = wxString_in_helper(obj1);
38024 if (arg2 == NULL) SWIG_fail;
38025 temp2 = true;
38026 }
38027 {
38028 PyThreadState* __tstate = wxPyBeginAllowThreads();
38029 (arg1)->SetCopyright((wxString const &)*arg2);
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 resultobj = SWIG_Py_Void();
38034 {
38035 if (temp2)
38036 delete arg2;
38037 }
38038 return resultobj;
38039 fail:
38040 {
38041 if (temp2)
38042 delete arg2;
38043 }
38044 return NULL;
38045 }
38046
38047
38048 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38049 PyObject *resultobj = 0;
38050 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38051 bool result;
38052 void *argp1 = 0 ;
38053 int res1 = 0 ;
38054 PyObject *swig_obj[1] ;
38055
38056 if (!args) SWIG_fail;
38057 swig_obj[0] = args;
38058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38059 if (!SWIG_IsOK(res1)) {
38060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38061 }
38062 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38063 {
38064 PyThreadState* __tstate = wxPyBeginAllowThreads();
38065 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
38066 wxPyEndAllowThreads(__tstate);
38067 if (PyErr_Occurred()) SWIG_fail;
38068 }
38069 {
38070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38071 }
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38079 PyObject *resultobj = 0;
38080 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38081 wxString result;
38082 void *argp1 = 0 ;
38083 int res1 = 0 ;
38084 PyObject *swig_obj[1] ;
38085
38086 if (!args) SWIG_fail;
38087 swig_obj[0] = args;
38088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38089 if (!SWIG_IsOK(res1)) {
38090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38091 }
38092 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38093 {
38094 PyThreadState* __tstate = wxPyBeginAllowThreads();
38095 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
38096 wxPyEndAllowThreads(__tstate);
38097 if (PyErr_Occurred()) SWIG_fail;
38098 }
38099 {
38100 #if wxUSE_UNICODE
38101 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38102 #else
38103 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38104 #endif
38105 }
38106 return resultobj;
38107 fail:
38108 return NULL;
38109 }
38110
38111
38112 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38113 PyObject *resultobj = 0;
38114 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38115 wxString *arg2 = 0 ;
38116 void *argp1 = 0 ;
38117 int res1 = 0 ;
38118 bool temp2 = false ;
38119 PyObject * obj0 = 0 ;
38120 PyObject * obj1 = 0 ;
38121 char * kwnames[] = {
38122 (char *) "self",(char *) "licence", NULL
38123 };
38124
38125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38127 if (!SWIG_IsOK(res1)) {
38128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38129 }
38130 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38131 {
38132 arg2 = wxString_in_helper(obj1);
38133 if (arg2 == NULL) SWIG_fail;
38134 temp2 = true;
38135 }
38136 {
38137 PyThreadState* __tstate = wxPyBeginAllowThreads();
38138 (arg1)->SetLicence((wxString const &)*arg2);
38139 wxPyEndAllowThreads(__tstate);
38140 if (PyErr_Occurred()) SWIG_fail;
38141 }
38142 resultobj = SWIG_Py_Void();
38143 {
38144 if (temp2)
38145 delete arg2;
38146 }
38147 return resultobj;
38148 fail:
38149 {
38150 if (temp2)
38151 delete arg2;
38152 }
38153 return NULL;
38154 }
38155
38156
38157 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38158 PyObject *resultobj = 0;
38159 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38160 wxString *arg2 = 0 ;
38161 void *argp1 = 0 ;
38162 int res1 = 0 ;
38163 bool temp2 = false ;
38164 PyObject * obj0 = 0 ;
38165 PyObject * obj1 = 0 ;
38166 char * kwnames[] = {
38167 (char *) "self",(char *) "licence", NULL
38168 };
38169
38170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38172 if (!SWIG_IsOK(res1)) {
38173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38174 }
38175 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38176 {
38177 arg2 = wxString_in_helper(obj1);
38178 if (arg2 == NULL) SWIG_fail;
38179 temp2 = true;
38180 }
38181 {
38182 PyThreadState* __tstate = wxPyBeginAllowThreads();
38183 (arg1)->SetLicense((wxString const &)*arg2);
38184 wxPyEndAllowThreads(__tstate);
38185 if (PyErr_Occurred()) SWIG_fail;
38186 }
38187 resultobj = SWIG_Py_Void();
38188 {
38189 if (temp2)
38190 delete arg2;
38191 }
38192 return resultobj;
38193 fail:
38194 {
38195 if (temp2)
38196 delete arg2;
38197 }
38198 return NULL;
38199 }
38200
38201
38202 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38203 PyObject *resultobj = 0;
38204 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38205 bool result;
38206 void *argp1 = 0 ;
38207 int res1 = 0 ;
38208 PyObject *swig_obj[1] ;
38209
38210 if (!args) SWIG_fail;
38211 swig_obj[0] = args;
38212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38213 if (!SWIG_IsOK(res1)) {
38214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38215 }
38216 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38217 {
38218 PyThreadState* __tstate = wxPyBeginAllowThreads();
38219 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38220 wxPyEndAllowThreads(__tstate);
38221 if (PyErr_Occurred()) SWIG_fail;
38222 }
38223 {
38224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38225 }
38226 return resultobj;
38227 fail:
38228 return NULL;
38229 }
38230
38231
38232 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38233 PyObject *resultobj = 0;
38234 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38235 wxString result;
38236 void *argp1 = 0 ;
38237 int res1 = 0 ;
38238 PyObject *swig_obj[1] ;
38239
38240 if (!args) SWIG_fail;
38241 swig_obj[0] = args;
38242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38243 if (!SWIG_IsOK(res1)) {
38244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38245 }
38246 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38247 {
38248 PyThreadState* __tstate = wxPyBeginAllowThreads();
38249 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38250 wxPyEndAllowThreads(__tstate);
38251 if (PyErr_Occurred()) SWIG_fail;
38252 }
38253 {
38254 #if wxUSE_UNICODE
38255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38256 #else
38257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38258 #endif
38259 }
38260 return resultobj;
38261 fail:
38262 return NULL;
38263 }
38264
38265
38266 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38267 PyObject *resultobj = 0;
38268 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38269 wxIcon *arg2 = 0 ;
38270 void *argp1 = 0 ;
38271 int res1 = 0 ;
38272 void *argp2 = 0 ;
38273 int res2 = 0 ;
38274 PyObject * obj0 = 0 ;
38275 PyObject * obj1 = 0 ;
38276 char * kwnames[] = {
38277 (char *) "self",(char *) "icon", NULL
38278 };
38279
38280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38282 if (!SWIG_IsOK(res1)) {
38283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38284 }
38285 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38286 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38287 if (!SWIG_IsOK(res2)) {
38288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38289 }
38290 if (!argp2) {
38291 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38292 }
38293 arg2 = reinterpret_cast< wxIcon * >(argp2);
38294 {
38295 PyThreadState* __tstate = wxPyBeginAllowThreads();
38296 (arg1)->SetIcon((wxIcon const &)*arg2);
38297 wxPyEndAllowThreads(__tstate);
38298 if (PyErr_Occurred()) SWIG_fail;
38299 }
38300 resultobj = SWIG_Py_Void();
38301 return resultobj;
38302 fail:
38303 return NULL;
38304 }
38305
38306
38307 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38308 PyObject *resultobj = 0;
38309 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38310 bool result;
38311 void *argp1 = 0 ;
38312 int res1 = 0 ;
38313 PyObject *swig_obj[1] ;
38314
38315 if (!args) SWIG_fail;
38316 swig_obj[0] = args;
38317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38318 if (!SWIG_IsOK(res1)) {
38319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38320 }
38321 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38322 {
38323 PyThreadState* __tstate = wxPyBeginAllowThreads();
38324 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38325 wxPyEndAllowThreads(__tstate);
38326 if (PyErr_Occurred()) SWIG_fail;
38327 }
38328 {
38329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38330 }
38331 return resultobj;
38332 fail:
38333 return NULL;
38334 }
38335
38336
38337 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38338 PyObject *resultobj = 0;
38339 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38340 wxIcon result;
38341 void *argp1 = 0 ;
38342 int res1 = 0 ;
38343 PyObject *swig_obj[1] ;
38344
38345 if (!args) SWIG_fail;
38346 swig_obj[0] = args;
38347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38348 if (!SWIG_IsOK(res1)) {
38349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38350 }
38351 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38352 {
38353 PyThreadState* __tstate = wxPyBeginAllowThreads();
38354 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38355 wxPyEndAllowThreads(__tstate);
38356 if (PyErr_Occurred()) SWIG_fail;
38357 }
38358 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38359 return resultobj;
38360 fail:
38361 return NULL;
38362 }
38363
38364
38365 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38366 PyObject *resultobj = 0;
38367 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38368 wxString *arg2 = 0 ;
38369 wxString const &arg3_defvalue = wxEmptyString ;
38370 wxString *arg3 = (wxString *) &arg3_defvalue ;
38371 void *argp1 = 0 ;
38372 int res1 = 0 ;
38373 bool temp2 = false ;
38374 bool temp3 = false ;
38375 PyObject * obj0 = 0 ;
38376 PyObject * obj1 = 0 ;
38377 PyObject * obj2 = 0 ;
38378 char * kwnames[] = {
38379 (char *) "self",(char *) "url",(char *) "desc", NULL
38380 };
38381
38382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38384 if (!SWIG_IsOK(res1)) {
38385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38386 }
38387 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38388 {
38389 arg2 = wxString_in_helper(obj1);
38390 if (arg2 == NULL) SWIG_fail;
38391 temp2 = true;
38392 }
38393 if (obj2) {
38394 {
38395 arg3 = wxString_in_helper(obj2);
38396 if (arg3 == NULL) SWIG_fail;
38397 temp3 = true;
38398 }
38399 }
38400 {
38401 PyThreadState* __tstate = wxPyBeginAllowThreads();
38402 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38403 wxPyEndAllowThreads(__tstate);
38404 if (PyErr_Occurred()) SWIG_fail;
38405 }
38406 resultobj = SWIG_Py_Void();
38407 {
38408 if (temp2)
38409 delete arg2;
38410 }
38411 {
38412 if (temp3)
38413 delete arg3;
38414 }
38415 return resultobj;
38416 fail:
38417 {
38418 if (temp2)
38419 delete arg2;
38420 }
38421 {
38422 if (temp3)
38423 delete arg3;
38424 }
38425 return NULL;
38426 }
38427
38428
38429 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38430 PyObject *resultobj = 0;
38431 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38432 wxString result;
38433 void *argp1 = 0 ;
38434 int res1 = 0 ;
38435 PyObject *swig_obj[1] ;
38436
38437 if (!args) SWIG_fail;
38438 swig_obj[0] = args;
38439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38440 if (!SWIG_IsOK(res1)) {
38441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38442 }
38443 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38444 {
38445 PyThreadState* __tstate = wxPyBeginAllowThreads();
38446 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38447 wxPyEndAllowThreads(__tstate);
38448 if (PyErr_Occurred()) SWIG_fail;
38449 }
38450 {
38451 #if wxUSE_UNICODE
38452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38453 #else
38454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38455 #endif
38456 }
38457 return resultobj;
38458 fail:
38459 return NULL;
38460 }
38461
38462
38463 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38464 PyObject *resultobj = 0;
38465 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38466 wxString result;
38467 void *argp1 = 0 ;
38468 int res1 = 0 ;
38469 PyObject *swig_obj[1] ;
38470
38471 if (!args) SWIG_fail;
38472 swig_obj[0] = args;
38473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38474 if (!SWIG_IsOK(res1)) {
38475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38476 }
38477 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38478 {
38479 PyThreadState* __tstate = wxPyBeginAllowThreads();
38480 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38481 wxPyEndAllowThreads(__tstate);
38482 if (PyErr_Occurred()) SWIG_fail;
38483 }
38484 {
38485 #if wxUSE_UNICODE
38486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38487 #else
38488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38489 #endif
38490 }
38491 return resultobj;
38492 fail:
38493 return NULL;
38494 }
38495
38496
38497 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38498 PyObject *resultobj = 0;
38499 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38500 bool result;
38501 void *argp1 = 0 ;
38502 int res1 = 0 ;
38503 PyObject *swig_obj[1] ;
38504
38505 if (!args) SWIG_fail;
38506 swig_obj[0] = args;
38507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38508 if (!SWIG_IsOK(res1)) {
38509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38510 }
38511 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38512 {
38513 PyThreadState* __tstate = wxPyBeginAllowThreads();
38514 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38515 wxPyEndAllowThreads(__tstate);
38516 if (PyErr_Occurred()) SWIG_fail;
38517 }
38518 {
38519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38520 }
38521 return resultobj;
38522 fail:
38523 return NULL;
38524 }
38525
38526
38527 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38528 PyObject *resultobj = 0;
38529 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38530 wxArrayString *arg2 = 0 ;
38531 void *argp1 = 0 ;
38532 int res1 = 0 ;
38533 bool temp2 = false ;
38534 PyObject * obj0 = 0 ;
38535 PyObject * obj1 = 0 ;
38536 char * kwnames[] = {
38537 (char *) "self",(char *) "developers", NULL
38538 };
38539
38540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38542 if (!SWIG_IsOK(res1)) {
38543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38544 }
38545 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38546 {
38547 if (! PySequence_Check(obj1)) {
38548 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38549 SWIG_fail;
38550 }
38551 arg2 = new wxArrayString;
38552 temp2 = true;
38553 int i, len=PySequence_Length(obj1);
38554 for (i=0; i<len; i++) {
38555 PyObject* item = PySequence_GetItem(obj1, i);
38556 wxString* s = wxString_in_helper(item);
38557 if (PyErr_Occurred()) SWIG_fail;
38558 arg2->Add(*s);
38559 delete s;
38560 Py_DECREF(item);
38561 }
38562 }
38563 {
38564 PyThreadState* __tstate = wxPyBeginAllowThreads();
38565 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38566 wxPyEndAllowThreads(__tstate);
38567 if (PyErr_Occurred()) SWIG_fail;
38568 }
38569 resultobj = SWIG_Py_Void();
38570 {
38571 if (temp2) delete arg2;
38572 }
38573 return resultobj;
38574 fail:
38575 {
38576 if (temp2) delete arg2;
38577 }
38578 return NULL;
38579 }
38580
38581
38582 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38583 PyObject *resultobj = 0;
38584 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38585 wxString *arg2 = 0 ;
38586 void *argp1 = 0 ;
38587 int res1 = 0 ;
38588 bool temp2 = false ;
38589 PyObject * obj0 = 0 ;
38590 PyObject * obj1 = 0 ;
38591 char * kwnames[] = {
38592 (char *) "self",(char *) "developer", NULL
38593 };
38594
38595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38597 if (!SWIG_IsOK(res1)) {
38598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38599 }
38600 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38601 {
38602 arg2 = wxString_in_helper(obj1);
38603 if (arg2 == NULL) SWIG_fail;
38604 temp2 = true;
38605 }
38606 {
38607 PyThreadState* __tstate = wxPyBeginAllowThreads();
38608 (arg1)->AddDeveloper((wxString const &)*arg2);
38609 wxPyEndAllowThreads(__tstate);
38610 if (PyErr_Occurred()) SWIG_fail;
38611 }
38612 resultobj = SWIG_Py_Void();
38613 {
38614 if (temp2)
38615 delete arg2;
38616 }
38617 return resultobj;
38618 fail:
38619 {
38620 if (temp2)
38621 delete arg2;
38622 }
38623 return NULL;
38624 }
38625
38626
38627 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38628 PyObject *resultobj = 0;
38629 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38630 bool result;
38631 void *argp1 = 0 ;
38632 int res1 = 0 ;
38633 PyObject *swig_obj[1] ;
38634
38635 if (!args) SWIG_fail;
38636 swig_obj[0] = args;
38637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38638 if (!SWIG_IsOK(res1)) {
38639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38640 }
38641 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38642 {
38643 PyThreadState* __tstate = wxPyBeginAllowThreads();
38644 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38645 wxPyEndAllowThreads(__tstate);
38646 if (PyErr_Occurred()) SWIG_fail;
38647 }
38648 {
38649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38650 }
38651 return resultobj;
38652 fail:
38653 return NULL;
38654 }
38655
38656
38657 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38658 PyObject *resultobj = 0;
38659 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38660 wxArrayString *result = 0 ;
38661 void *argp1 = 0 ;
38662 int res1 = 0 ;
38663 PyObject *swig_obj[1] ;
38664
38665 if (!args) SWIG_fail;
38666 swig_obj[0] = args;
38667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38668 if (!SWIG_IsOK(res1)) {
38669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38670 }
38671 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38672 {
38673 PyThreadState* __tstate = wxPyBeginAllowThreads();
38674 {
38675 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38676 result = (wxArrayString *) &_result_ref;
38677 }
38678 wxPyEndAllowThreads(__tstate);
38679 if (PyErr_Occurred()) SWIG_fail;
38680 }
38681 {
38682 resultobj = wxArrayString2PyList_helper(*result);
38683 }
38684 return resultobj;
38685 fail:
38686 return NULL;
38687 }
38688
38689
38690 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38691 PyObject *resultobj = 0;
38692 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38693 wxArrayString *arg2 = 0 ;
38694 void *argp1 = 0 ;
38695 int res1 = 0 ;
38696 bool temp2 = false ;
38697 PyObject * obj0 = 0 ;
38698 PyObject * obj1 = 0 ;
38699 char * kwnames[] = {
38700 (char *) "self",(char *) "docwriters", NULL
38701 };
38702
38703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38705 if (!SWIG_IsOK(res1)) {
38706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38707 }
38708 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38709 {
38710 if (! PySequence_Check(obj1)) {
38711 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38712 SWIG_fail;
38713 }
38714 arg2 = new wxArrayString;
38715 temp2 = true;
38716 int i, len=PySequence_Length(obj1);
38717 for (i=0; i<len; i++) {
38718 PyObject* item = PySequence_GetItem(obj1, i);
38719 wxString* s = wxString_in_helper(item);
38720 if (PyErr_Occurred()) SWIG_fail;
38721 arg2->Add(*s);
38722 delete s;
38723 Py_DECREF(item);
38724 }
38725 }
38726 {
38727 PyThreadState* __tstate = wxPyBeginAllowThreads();
38728 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38729 wxPyEndAllowThreads(__tstate);
38730 if (PyErr_Occurred()) SWIG_fail;
38731 }
38732 resultobj = SWIG_Py_Void();
38733 {
38734 if (temp2) delete arg2;
38735 }
38736 return resultobj;
38737 fail:
38738 {
38739 if (temp2) delete arg2;
38740 }
38741 return NULL;
38742 }
38743
38744
38745 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38746 PyObject *resultobj = 0;
38747 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38748 wxString *arg2 = 0 ;
38749 void *argp1 = 0 ;
38750 int res1 = 0 ;
38751 bool temp2 = false ;
38752 PyObject * obj0 = 0 ;
38753 PyObject * obj1 = 0 ;
38754 char * kwnames[] = {
38755 (char *) "self",(char *) "docwriter", NULL
38756 };
38757
38758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38760 if (!SWIG_IsOK(res1)) {
38761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38762 }
38763 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38764 {
38765 arg2 = wxString_in_helper(obj1);
38766 if (arg2 == NULL) SWIG_fail;
38767 temp2 = true;
38768 }
38769 {
38770 PyThreadState* __tstate = wxPyBeginAllowThreads();
38771 (arg1)->AddDocWriter((wxString const &)*arg2);
38772 wxPyEndAllowThreads(__tstate);
38773 if (PyErr_Occurred()) SWIG_fail;
38774 }
38775 resultobj = SWIG_Py_Void();
38776 {
38777 if (temp2)
38778 delete arg2;
38779 }
38780 return resultobj;
38781 fail:
38782 {
38783 if (temp2)
38784 delete arg2;
38785 }
38786 return NULL;
38787 }
38788
38789
38790 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38791 PyObject *resultobj = 0;
38792 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38793 bool result;
38794 void *argp1 = 0 ;
38795 int res1 = 0 ;
38796 PyObject *swig_obj[1] ;
38797
38798 if (!args) SWIG_fail;
38799 swig_obj[0] = args;
38800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38803 }
38804 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38805 {
38806 PyThreadState* __tstate = wxPyBeginAllowThreads();
38807 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38808 wxPyEndAllowThreads(__tstate);
38809 if (PyErr_Occurred()) SWIG_fail;
38810 }
38811 {
38812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38813 }
38814 return resultobj;
38815 fail:
38816 return NULL;
38817 }
38818
38819
38820 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38821 PyObject *resultobj = 0;
38822 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38823 wxArrayString *result = 0 ;
38824 void *argp1 = 0 ;
38825 int res1 = 0 ;
38826 PyObject *swig_obj[1] ;
38827
38828 if (!args) SWIG_fail;
38829 swig_obj[0] = args;
38830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38831 if (!SWIG_IsOK(res1)) {
38832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38833 }
38834 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38835 {
38836 PyThreadState* __tstate = wxPyBeginAllowThreads();
38837 {
38838 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38839 result = (wxArrayString *) &_result_ref;
38840 }
38841 wxPyEndAllowThreads(__tstate);
38842 if (PyErr_Occurred()) SWIG_fail;
38843 }
38844 {
38845 resultobj = wxArrayString2PyList_helper(*result);
38846 }
38847 return resultobj;
38848 fail:
38849 return NULL;
38850 }
38851
38852
38853 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38854 PyObject *resultobj = 0;
38855 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38856 wxArrayString *arg2 = 0 ;
38857 void *argp1 = 0 ;
38858 int res1 = 0 ;
38859 bool temp2 = false ;
38860 PyObject * obj0 = 0 ;
38861 PyObject * obj1 = 0 ;
38862 char * kwnames[] = {
38863 (char *) "self",(char *) "artists", NULL
38864 };
38865
38866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38868 if (!SWIG_IsOK(res1)) {
38869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38870 }
38871 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38872 {
38873 if (! PySequence_Check(obj1)) {
38874 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38875 SWIG_fail;
38876 }
38877 arg2 = new wxArrayString;
38878 temp2 = true;
38879 int i, len=PySequence_Length(obj1);
38880 for (i=0; i<len; i++) {
38881 PyObject* item = PySequence_GetItem(obj1, i);
38882 wxString* s = wxString_in_helper(item);
38883 if (PyErr_Occurred()) SWIG_fail;
38884 arg2->Add(*s);
38885 delete s;
38886 Py_DECREF(item);
38887 }
38888 }
38889 {
38890 PyThreadState* __tstate = wxPyBeginAllowThreads();
38891 (arg1)->SetArtists((wxArrayString const &)*arg2);
38892 wxPyEndAllowThreads(__tstate);
38893 if (PyErr_Occurred()) SWIG_fail;
38894 }
38895 resultobj = SWIG_Py_Void();
38896 {
38897 if (temp2) delete arg2;
38898 }
38899 return resultobj;
38900 fail:
38901 {
38902 if (temp2) delete arg2;
38903 }
38904 return NULL;
38905 }
38906
38907
38908 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38909 PyObject *resultobj = 0;
38910 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38911 wxString *arg2 = 0 ;
38912 void *argp1 = 0 ;
38913 int res1 = 0 ;
38914 bool temp2 = false ;
38915 PyObject * obj0 = 0 ;
38916 PyObject * obj1 = 0 ;
38917 char * kwnames[] = {
38918 (char *) "self",(char *) "artist", NULL
38919 };
38920
38921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38923 if (!SWIG_IsOK(res1)) {
38924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38925 }
38926 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38927 {
38928 arg2 = wxString_in_helper(obj1);
38929 if (arg2 == NULL) SWIG_fail;
38930 temp2 = true;
38931 }
38932 {
38933 PyThreadState* __tstate = wxPyBeginAllowThreads();
38934 (arg1)->AddArtist((wxString const &)*arg2);
38935 wxPyEndAllowThreads(__tstate);
38936 if (PyErr_Occurred()) SWIG_fail;
38937 }
38938 resultobj = SWIG_Py_Void();
38939 {
38940 if (temp2)
38941 delete arg2;
38942 }
38943 return resultobj;
38944 fail:
38945 {
38946 if (temp2)
38947 delete arg2;
38948 }
38949 return NULL;
38950 }
38951
38952
38953 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38954 PyObject *resultobj = 0;
38955 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38956 bool result;
38957 void *argp1 = 0 ;
38958 int res1 = 0 ;
38959 PyObject *swig_obj[1] ;
38960
38961 if (!args) SWIG_fail;
38962 swig_obj[0] = args;
38963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38964 if (!SWIG_IsOK(res1)) {
38965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38966 }
38967 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38968 {
38969 PyThreadState* __tstate = wxPyBeginAllowThreads();
38970 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38971 wxPyEndAllowThreads(__tstate);
38972 if (PyErr_Occurred()) SWIG_fail;
38973 }
38974 {
38975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38976 }
38977 return resultobj;
38978 fail:
38979 return NULL;
38980 }
38981
38982
38983 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38984 PyObject *resultobj = 0;
38985 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38986 wxArrayString *result = 0 ;
38987 void *argp1 = 0 ;
38988 int res1 = 0 ;
38989 PyObject *swig_obj[1] ;
38990
38991 if (!args) SWIG_fail;
38992 swig_obj[0] = args;
38993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38994 if (!SWIG_IsOK(res1)) {
38995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38996 }
38997 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38998 {
38999 PyThreadState* __tstate = wxPyBeginAllowThreads();
39000 {
39001 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
39002 result = (wxArrayString *) &_result_ref;
39003 }
39004 wxPyEndAllowThreads(__tstate);
39005 if (PyErr_Occurred()) SWIG_fail;
39006 }
39007 {
39008 resultobj = wxArrayString2PyList_helper(*result);
39009 }
39010 return resultobj;
39011 fail:
39012 return NULL;
39013 }
39014
39015
39016 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39017 PyObject *resultobj = 0;
39018 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39019 wxArrayString *arg2 = 0 ;
39020 void *argp1 = 0 ;
39021 int res1 = 0 ;
39022 bool temp2 = false ;
39023 PyObject * obj0 = 0 ;
39024 PyObject * obj1 = 0 ;
39025 char * kwnames[] = {
39026 (char *) "self",(char *) "translators", NULL
39027 };
39028
39029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
39030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39031 if (!SWIG_IsOK(res1)) {
39032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
39033 }
39034 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39035 {
39036 if (! PySequence_Check(obj1)) {
39037 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
39038 SWIG_fail;
39039 }
39040 arg2 = new wxArrayString;
39041 temp2 = true;
39042 int i, len=PySequence_Length(obj1);
39043 for (i=0; i<len; i++) {
39044 PyObject* item = PySequence_GetItem(obj1, i);
39045 wxString* s = wxString_in_helper(item);
39046 if (PyErr_Occurred()) SWIG_fail;
39047 arg2->Add(*s);
39048 delete s;
39049 Py_DECREF(item);
39050 }
39051 }
39052 {
39053 PyThreadState* __tstate = wxPyBeginAllowThreads();
39054 (arg1)->SetTranslators((wxArrayString const &)*arg2);
39055 wxPyEndAllowThreads(__tstate);
39056 if (PyErr_Occurred()) SWIG_fail;
39057 }
39058 resultobj = SWIG_Py_Void();
39059 {
39060 if (temp2) delete arg2;
39061 }
39062 return resultobj;
39063 fail:
39064 {
39065 if (temp2) delete arg2;
39066 }
39067 return NULL;
39068 }
39069
39070
39071 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39072 PyObject *resultobj = 0;
39073 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39074 wxString *arg2 = 0 ;
39075 void *argp1 = 0 ;
39076 int res1 = 0 ;
39077 bool temp2 = false ;
39078 PyObject * obj0 = 0 ;
39079 PyObject * obj1 = 0 ;
39080 char * kwnames[] = {
39081 (char *) "self",(char *) "translator", NULL
39082 };
39083
39084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
39085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39086 if (!SWIG_IsOK(res1)) {
39087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
39088 }
39089 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39090 {
39091 arg2 = wxString_in_helper(obj1);
39092 if (arg2 == NULL) SWIG_fail;
39093 temp2 = true;
39094 }
39095 {
39096 PyThreadState* __tstate = wxPyBeginAllowThreads();
39097 (arg1)->AddTranslator((wxString const &)*arg2);
39098 wxPyEndAllowThreads(__tstate);
39099 if (PyErr_Occurred()) SWIG_fail;
39100 }
39101 resultobj = SWIG_Py_Void();
39102 {
39103 if (temp2)
39104 delete arg2;
39105 }
39106 return resultobj;
39107 fail:
39108 {
39109 if (temp2)
39110 delete arg2;
39111 }
39112 return NULL;
39113 }
39114
39115
39116 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39117 PyObject *resultobj = 0;
39118 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39119 bool result;
39120 void *argp1 = 0 ;
39121 int res1 = 0 ;
39122 PyObject *swig_obj[1] ;
39123
39124 if (!args) SWIG_fail;
39125 swig_obj[0] = args;
39126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39127 if (!SWIG_IsOK(res1)) {
39128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39129 }
39130 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39131 {
39132 PyThreadState* __tstate = wxPyBeginAllowThreads();
39133 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39134 wxPyEndAllowThreads(__tstate);
39135 if (PyErr_Occurred()) SWIG_fail;
39136 }
39137 {
39138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39139 }
39140 return resultobj;
39141 fail:
39142 return NULL;
39143 }
39144
39145
39146 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39147 PyObject *resultobj = 0;
39148 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39149 wxArrayString *result = 0 ;
39150 void *argp1 = 0 ;
39151 int res1 = 0 ;
39152 PyObject *swig_obj[1] ;
39153
39154 if (!args) SWIG_fail;
39155 swig_obj[0] = args;
39156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39157 if (!SWIG_IsOK(res1)) {
39158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39159 }
39160 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39161 {
39162 PyThreadState* __tstate = wxPyBeginAllowThreads();
39163 {
39164 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39165 result = (wxArrayString *) &_result_ref;
39166 }
39167 wxPyEndAllowThreads(__tstate);
39168 if (PyErr_Occurred()) SWIG_fail;
39169 }
39170 {
39171 resultobj = wxArrayString2PyList_helper(*result);
39172 }
39173 return resultobj;
39174 fail:
39175 return NULL;
39176 }
39177
39178
39179 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39180 PyObject *resultobj = 0;
39181 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39182 bool result;
39183 void *argp1 = 0 ;
39184 int res1 = 0 ;
39185 PyObject *swig_obj[1] ;
39186
39187 if (!args) SWIG_fail;
39188 swig_obj[0] = args;
39189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39190 if (!SWIG_IsOK(res1)) {
39191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39192 }
39193 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39194 {
39195 PyThreadState* __tstate = wxPyBeginAllowThreads();
39196 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39197 wxPyEndAllowThreads(__tstate);
39198 if (PyErr_Occurred()) SWIG_fail;
39199 }
39200 {
39201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39202 }
39203 return resultobj;
39204 fail:
39205 return NULL;
39206 }
39207
39208
39209 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39210 PyObject *resultobj = 0;
39211 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39212 wxString result;
39213 void *argp1 = 0 ;
39214 int res1 = 0 ;
39215 PyObject *swig_obj[1] ;
39216
39217 if (!args) SWIG_fail;
39218 swig_obj[0] = args;
39219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39220 if (!SWIG_IsOK(res1)) {
39221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39222 }
39223 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39224 {
39225 PyThreadState* __tstate = wxPyBeginAllowThreads();
39226 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39227 wxPyEndAllowThreads(__tstate);
39228 if (PyErr_Occurred()) SWIG_fail;
39229 }
39230 {
39231 #if wxUSE_UNICODE
39232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39233 #else
39234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39235 #endif
39236 }
39237 return resultobj;
39238 fail:
39239 return NULL;
39240 }
39241
39242
39243 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39244 PyObject *obj;
39245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39246 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39247 return SWIG_Py_Void();
39248 }
39249
39250 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39251 return SWIG_Python_InitShadowInstance(args);
39252 }
39253
39254 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39255 PyObject *resultobj = 0;
39256 wxAboutDialogInfo *arg1 = 0 ;
39257 void *argp1 = 0 ;
39258 int res1 = 0 ;
39259 PyObject * obj0 = 0 ;
39260 char * kwnames[] = {
39261 (char *) "info", NULL
39262 };
39263
39264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39265 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39266 if (!SWIG_IsOK(res1)) {
39267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39268 }
39269 if (!argp1) {
39270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39271 }
39272 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39273 {
39274 PyThreadState* __tstate = wxPyBeginAllowThreads();
39275 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39276 wxPyEndAllowThreads(__tstate);
39277 if (PyErr_Occurred()) SWIG_fail;
39278 }
39279 resultobj = SWIG_Py_Void();
39280 return resultobj;
39281 fail:
39282 return NULL;
39283 }
39284
39285
39286 static PyMethodDef SwigMethods[] = {
39287 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39291 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39292 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39293 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39294 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39295 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39296 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39297 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39298 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39299 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39302 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39303 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39304 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39305 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39306 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39307 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39310 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39311 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39312 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39313 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39314 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39316 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39317 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39318 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39319 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39320 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39324 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39326 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39327 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39328 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39329 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39330 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39331 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39332 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39333 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39334 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39335 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39336 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39337 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39338 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39340 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39341 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39342 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39346 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39347 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39348 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39349 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39350 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39351 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39352 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39353 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39354 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39355 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39356 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39357 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39358 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39359 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39360 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39363 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39365 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39366 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39367 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39368 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39369 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39370 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39371 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39372 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39373 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39374 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39375 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39376 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39377 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39379 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39383 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39384 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39385 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39387 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39388 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39389 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39390 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39391 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39392 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39393 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39394 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39395 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39396 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39397 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39398 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39399 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39401 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39402 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39405 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39406 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39408 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39409 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39410 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39411 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39412 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39413 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39414 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39415 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39416 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39418 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39419 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39420 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39421 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39422 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39423 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39425 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39426 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39427 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39428 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39429 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39430 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39431 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39432 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39433 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39434 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39436 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39437 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39438 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39439 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39440 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39442 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39443 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39444 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39445 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39446 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39447 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39448 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39450 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39451 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39456 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39457 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39458 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39459 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39460 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39461 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39462 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39463 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39464 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39466 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39467 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39468 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39469 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39470 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39472 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39473 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39474 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39475 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39476 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39477 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39478 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39479 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39480 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39481 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39482 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39483 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39484 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39485 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39486 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39487 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39488 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39489 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39491 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39492 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39493 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39494 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39495 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39496 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39497 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39498 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39499 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39500 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39501 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39502 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39503 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39504 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39506 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39507 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39511 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39512 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39514 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39515 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39516 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39517 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39518 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39519 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39520 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39521 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39522 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39523 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39525 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39526 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39527 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39528 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39529 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39530 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39531 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39532 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39533 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39534 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39535 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39537 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39538 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39539 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39540 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39541 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39542 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39543 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39544 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39545 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39546 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39548 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39551 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39552 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39553 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39554 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39555 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39556 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39558 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39559 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39560 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39561 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39562 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39563 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39564 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39565 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39566 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39568 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39569 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39570 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39571 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39572 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39575 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39576 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39577 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39578 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39579 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39580 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39581 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39583 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39584 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39585 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39586 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39587 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39588 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39589 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39590 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39591 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39592 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39594 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39595 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39598 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39599 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39600 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39601 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39603 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39605 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39606 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39607 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39608 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39609 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39610 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39611 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39613 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39614 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39619 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39621 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39623 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39624 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39625 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39626 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39627 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39628 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39629 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39630 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39631 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39632 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39633 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39634 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39636 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39637 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39638 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39639 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39640 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39641 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39642 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39643 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39644 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39645 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39647 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39648 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39649 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39650 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39651 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39652 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39653 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39654 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39655 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39656 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39658 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39659 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39660 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39661 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39662 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39663 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39664 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39665 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39666 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39667 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39668 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39669 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39670 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39671 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39672 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39673 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39674 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39675 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39676 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39677 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39678 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39679 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39680 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39681 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39682 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39683 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39684 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39685 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39686 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39687 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39689 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39690 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39691 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39693 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39694 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39695 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39696 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39697 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39703 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39704 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39705 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39709 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39710 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39713 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39716 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39719 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39720 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39721 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39724 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39725 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39728 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39729 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39730 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39731 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39732 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39733 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39734 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39735 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39736 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39737 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39738 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39740 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39741 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39742 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39743 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39744 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39745 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39746 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39752 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39754 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39755 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39757 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39759 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39764 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39768 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39769 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39770 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39771 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39772 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39776 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"ArtProvider_GetIconBundle", (PyCFunction) _wrap_ArtProvider_GetIconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39782 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39783 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39784 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39785 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39788 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39789 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39791 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39792 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39794 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39815 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39817 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39819 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39821 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39822 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39826 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39827 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39829 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39830 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39831 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39833 { (char *)"FileConfig_GetGlobalFileName", (PyCFunction) _wrap_FileConfig_GetGlobalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"FileConfig_GetLocalFileName", (PyCFunction) _wrap_FileConfig_GetLocalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39836 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39837 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39839 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39840 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39841 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39842 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39845 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39856 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39860 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39861 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39862 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39863 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39865 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39869 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39870 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39875 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39876 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39894 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39898 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39899 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39900 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39901 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39902 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39912 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39913 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39914 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39915 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39917 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39919 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39921 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39935 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39941 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39942 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39943 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39944 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39948 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39949 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39955 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39957 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39958 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39959 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39960 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39961 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39962 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39964 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39965 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39966 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39968 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39970 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39972 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39974 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39975 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39976 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39977 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39978 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39979 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39980 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39981 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39985 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39992 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39994 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39995 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39996 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39997 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39998 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39999 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
40002 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
40003 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
40004 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
40005 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
40006 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
40007 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
40008 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
40009 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
40010 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
40012 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
40014 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
40016 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
40018 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
40019 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
40020 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
40023 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
40024 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
40025 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
40026 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
40027 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
40028 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
40029 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
40032 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
40034 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
40035 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
40036 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
40037 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
40038 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
40039 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
40040 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40042 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40043 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
40044 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
40045 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
40046 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
40047 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
40048 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
40049 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40051 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
40052 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
40053 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
40054 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
40055 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
40056 { (char *)"DataFormat__GetId", (PyCFunction)_wrap_DataFormat__GetId, METH_O, NULL},
40057 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
40059 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
40060 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
40061 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40062 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
40063 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
40065 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
40069 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40070 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
40071 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40072 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
40073 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
40074 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40075 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
40076 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
40077 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40078 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
40080 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
40081 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
40082 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
40083 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
40084 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
40085 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
40086 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
40088 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
40089 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
40091 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
40092 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40093 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40094 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
40095 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
40096 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40097 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
40098 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
40099 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
40100 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
40101 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40102 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40103 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
40104 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
40105 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
40106 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
40107 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
40108 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
40109 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40110 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40111 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40112 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40113 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40114 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40115 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40116 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40117 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40118 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40119 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40120 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40121 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40122 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
40123 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
40124 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40125 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40126 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40127 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40128 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40129 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40130 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40131 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40132 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40133 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40134 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40135 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40136 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40137 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40138 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40139 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40140 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40141 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40142 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40143 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40144 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40145 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40146 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40147 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40148 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40149 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40150 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40151 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40152 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40153 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40154 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40155 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40156 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40157 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40158 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40159 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40160 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40161 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40162 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40163 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40164 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40165 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40166 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40167 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40168 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40169 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40170 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40171 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40172 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40173 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40174 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40175 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40176 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40177 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40178 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40179 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40180 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40181 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40182 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40183 { (char *)"Clipboard_IsUsingPrimarySelection", (PyCFunction)_wrap_Clipboard_IsUsingPrimarySelection, METH_O, NULL},
40184 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40185 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40186 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40187 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40188 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40189 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40190 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40191 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40192 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40193 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40194 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40195 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40196 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40197 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40198 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40199 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40200 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40201 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40202 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40203 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40204 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40205 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40206 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40207 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40208 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40209 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40210 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40211 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40212 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40213 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40214 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40215 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40216 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40217 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40218 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40219 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40220 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40221 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40222 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40223 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40224 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40225 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40226 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40227 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40228 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40229 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40230 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40231 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40232 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40233 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40234 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40235 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40236 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40237 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40238 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40239 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40240 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40241 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40242 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40243 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40244 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40245 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40246 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40247 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40248 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40249 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40250 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40251 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40252 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40253 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40254 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40255 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40256 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40257 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40258 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40259 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40260 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40261 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40262 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40263 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40264 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40265 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40266 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40267 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40268 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40269 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40270 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40271 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40272 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40273 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40274 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40275 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40276 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40277 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40278 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40279 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40280 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40281 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40282 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40283 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40284 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40285 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40286 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40287 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40288 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40289 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40290 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40291 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40292 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40293 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40294 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40295 { NULL, NULL, 0, NULL }
40296 };
40297
40298
40299 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40300
40301 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40302 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40303 }
40304 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40305 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40306 }
40307 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40308 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40309 }
40310 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40311 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40312 }
40313 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40314 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40315 }
40316 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40317 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40318 }
40319 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40320 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40321 }
40322 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40323 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40324 }
40325 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40326 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40327 }
40328 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40329 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40330 }
40331 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40332 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40333 }
40334 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40335 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40336 }
40337 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40338 return (void *)((wxEvent *) ((wxPyEvent *) x));
40339 }
40340 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40341 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40342 }
40343 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40344 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40345 }
40346 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40347 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40348 }
40349 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40350 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40351 }
40352 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40353 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40354 }
40355 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40356 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40357 }
40358 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40359 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40360 }
40361 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40362 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40363 }
40364 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40365 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40366 }
40367 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40368 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40369 }
40370 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40371 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40372 }
40373 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40374 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40375 }
40376 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40377 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40378 }
40379 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40380 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40381 }
40382 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40383 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40384 }
40385 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40386 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40387 }
40388 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40389 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40390 }
40391 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40392 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40393 }
40394 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40395 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40396 }
40397 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40398 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40399 }
40400 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40401 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40402 }
40403 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40404 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40405 }
40406 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40407 return (void *)((wxEvent *) ((wxShowEvent *) x));
40408 }
40409 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40410 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40411 }
40412 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40413 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40414 }
40415 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40416 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40417 }
40418 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40419 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40420 }
40421 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40422 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40423 }
40424 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40425 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40426 }
40427 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40428 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40429 }
40430 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40431 return (void *)((wxConfigBase *) ((wxConfig *) x));
40432 }
40433 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40434 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40435 }
40436 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40437 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40438 }
40439 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40440 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40441 }
40442 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40443 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40444 }
40445 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40446 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40447 }
40448 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40449 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40450 }
40451 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40452 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40453 }
40454 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40455 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40456 }
40457 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40458 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40459 }
40460 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40461 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40462 }
40463 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40464 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40465 }
40466 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40467 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40468 }
40469 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40470 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40471 }
40472 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40473 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40474 }
40475 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40476 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40477 }
40478 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40479 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40480 }
40481 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40482 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40483 }
40484 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40485 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40486 }
40487 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40488 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40489 }
40490 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40491 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40492 }
40493 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40494 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40495 }
40496 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40497 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40498 }
40499 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40500 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40501 }
40502 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40503 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40504 }
40505 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40506 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40507 }
40508 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40509 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40510 }
40511 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40512 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40513 }
40514 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40515 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40516 }
40517 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40518 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40519 }
40520 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
40521 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
40522 }
40523 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40524 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40525 }
40526 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40527 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40528 }
40529 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40530 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40531 }
40532 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40533 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40534 }
40535 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
40536 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
40537 }
40538 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40539 return (void *)((wxObject *) ((wxSizerItem *) x));
40540 }
40541 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40542 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40543 }
40544 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40545 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40546 }
40547 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40548 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40549 }
40550 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40551 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40552 }
40553 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40554 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40555 }
40556 static void *_p_wxSizerTo_p_wxObject(void *x) {
40557 return (void *)((wxObject *) ((wxSizer *) x));
40558 }
40559 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40560 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40561 }
40562 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40563 return (void *)((wxObject *) ((wxFileHistory *) x));
40564 }
40565 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40566 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40567 }
40568 static void *_p_wxEventTo_p_wxObject(void *x) {
40569 return (void *)((wxObject *) ((wxEvent *) x));
40570 }
40571 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40572 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40573 }
40574 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40575 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40576 }
40577 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40578 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40579 }
40580 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40581 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40582 }
40583 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40584 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40585 }
40586 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40587 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40588 }
40589 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40590 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40591 }
40592 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40593 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40594 }
40595 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40596 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40597 }
40598 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40599 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40600 }
40601 static void *_p_wxControlTo_p_wxObject(void *x) {
40602 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40603 }
40604 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40605 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40606 }
40607 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40608 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40609 }
40610 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40611 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40612 }
40613 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40614 return (void *)((wxObject *) ((wxFSFile *) x));
40615 }
40616 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40617 return (void *)((wxObject *) ((wxClipboard *) x));
40618 }
40619 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40620 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40621 }
40622 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40623 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40624 }
40625 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40626 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40627 }
40628 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40629 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40630 }
40631 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40632 return (void *)((wxObject *) ((wxToolTip *) x));
40633 }
40634 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40635 return (void *)((wxObject *) ((wxMenuItem *) x));
40636 }
40637 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40638 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40639 }
40640 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40641 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40642 }
40643 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40644 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40645 }
40646 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40647 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40648 }
40649 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40650 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40651 }
40652 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40653 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40654 }
40655 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40656 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40657 }
40658 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40659 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40660 }
40661 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40662 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40663 }
40664 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40665 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40666 }
40667 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40668 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40669 }
40670 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40671 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40672 }
40673 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40674 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40675 }
40676 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40677 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40678 }
40679 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40680 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40681 }
40682 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40683 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40684 }
40685 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40686 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40687 }
40688 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40689 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40690 }
40691 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40692 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40693 }
40694 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40695 return (void *)((wxObject *) ((wxImageHandler *) x));
40696 }
40697 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40698 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40699 }
40700 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40701 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40702 }
40703 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40704 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40705 }
40706 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40707 return (void *)((wxObject *) ((wxEvtHandler *) x));
40708 }
40709 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40710 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40711 }
40712 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40713 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40714 }
40715 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40716 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40717 }
40718 static void *_p_wxImageTo_p_wxObject(void *x) {
40719 return (void *)((wxObject *) ((wxImage *) x));
40720 }
40721 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40722 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40723 }
40724 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40725 return (void *)((wxObject *) ((wxSystemOptions *) x));
40726 }
40727 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40728 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40729 }
40730 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40731 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40732 }
40733 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40734 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40735 }
40736 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40737 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40738 }
40739 static void *_p_wxWindowTo_p_wxObject(void *x) {
40740 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40741 }
40742 static void *_p_wxMenuTo_p_wxObject(void *x) {
40743 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40744 }
40745 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40746 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40747 }
40748 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40749 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40750 }
40751 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40752 return (void *)((wxObject *) ((wxFileSystem *) x));
40753 }
40754 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40755 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40756 }
40757 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40758 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40759 }
40760 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40761 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40762 }
40763 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40764 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40765 }
40766 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40767 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40768 }
40769 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40770 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40771 }
40772 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40773 return (void *)((wxObject *) ((wxBusyInfo *) x));
40774 }
40775 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40776 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40777 }
40778 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40779 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40780 }
40781 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40782 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40783 }
40784 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40785 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40786 }
40787 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40788 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40789 }
40790 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40791 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40792 }
40793 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40794 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40795 }
40796 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40797 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40798 }
40799 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40800 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40801 }
40802 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40803 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40804 }
40805 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40806 return (void *)((wxLog *) ((wxLogBuffer *) x));
40807 }
40808 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40809 return (void *)((wxLog *) ((wxLogStderr *) x));
40810 }
40811 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40812 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40813 }
40814 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40815 return (void *)((wxLog *) ((wxLogWindow *) x));
40816 }
40817 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40818 return (void *)((wxLog *) ((wxLogChain *) x));
40819 }
40820 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40821 return (void *)((wxLog *) ((wxLogGui *) x));
40822 }
40823 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40824 return (void *)((wxLog *) ((wxPyLog *) x));
40825 }
40826 static void *_p_wxControlTo_p_wxWindow(void *x) {
40827 return (void *)((wxWindow *) ((wxControl *) x));
40828 }
40829 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40830 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40831 }
40832 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40833 return (void *)((wxWindow *) ((wxMenuBar *) x));
40834 }
40835 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40836 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40837 }
40838 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40839 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40840 }
40841 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40842 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};
40843 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40850 static swig_type_info _swigt__p_wxArtClient = {"_p_wxArtClient", "wxArtClient *", 0, 0, (void*)0, 0};
40851 static swig_type_info _swigt__p_wxArtID = {"_p_wxArtID", "wxArtID *", 0, 0, (void*)0, 0};
40852 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40853 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40854 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40855 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40856 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40857 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40858 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40859 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40860 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40861 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40862 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40863 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40866 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40867 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40868 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40870 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40871 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40875 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40876 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40877 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40878 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40879 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40880 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40881 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40882 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40883 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40884 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40885 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40886 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40887 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40888 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40889 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40890 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40891 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40892 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40893 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40894 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40895 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40896 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40897 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40898 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40899 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40900 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40901 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40902 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40903 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40904 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40905 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40906 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40907 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40908 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40909 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40910 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40911 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40912 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40913 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40914 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40915 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40916 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40917 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40918 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40919 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40920 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40921 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40922 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
40923 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40924 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40925 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40926 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40927 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40928 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40929 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40930 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40931 static swig_type_info _swigt__p_wxIconBundle = {"_p_wxIconBundle", "wxIconBundle *", 0, 0, (void*)0, 0};
40932 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40933 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40934 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40935 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40936 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40937 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40938 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40939 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40940 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40941 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40942 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40943 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40944 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40945 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40946 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40947 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40948 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40949 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40950 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40951 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40952 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40953 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40954 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40955 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40956 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40957 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40958 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40959 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40960 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40961 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40962 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40963 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40964 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40965 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40966 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40967 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40968 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40969 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40970 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40971 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40972 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40973 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40974 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40975 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40976 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40977 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40978 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40979 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40980 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40981 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40982 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40983 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40984 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40985 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40986 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40987 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40988 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40989 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40990 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40991 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40992 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40993 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40994 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40995 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40996 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40997 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40998 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40999 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
41000 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
41001 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
41002 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
41003 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
41004 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
41005 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
41006 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
41007 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
41008 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
41009 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
41010 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
41011 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
41012 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
41013 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
41014 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
41015 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
41016 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
41017 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
41018 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
41019 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
41020
41021 static swig_type_info *swig_type_initial[] = {
41022 &_swigt__p_char,
41023 &_swigt__p_form_ops_t,
41024 &_swigt__p_int,
41025 &_swigt__p_unsigned_char,
41026 &_swigt__p_unsigned_int,
41027 &_swigt__p_unsigned_long,
41028 &_swigt__p_void,
41029 &_swigt__p_wxANIHandler,
41030 &_swigt__p_wxAboutDialogInfo,
41031 &_swigt__p_wxAcceleratorTable,
41032 &_swigt__p_wxActivateEvent,
41033 &_swigt__p_wxArrayString,
41034 &_swigt__p_wxArtClient,
41035 &_swigt__p_wxArtID,
41036 &_swigt__p_wxBMPHandler,
41037 &_swigt__p_wxBitmap,
41038 &_swigt__p_wxBitmapDataObject,
41039 &_swigt__p_wxBoxSizer,
41040 &_swigt__p_wxBusyCursor,
41041 &_swigt__p_wxBusyInfo,
41042 &_swigt__p_wxCURHandler,
41043 &_swigt__p_wxCaret,
41044 &_swigt__p_wxChar,
41045 &_swigt__p_wxChildFocusEvent,
41046 &_swigt__p_wxClipboard,
41047 &_swigt__p_wxClipboardLocker,
41048 &_swigt__p_wxClipboardTextEvent,
41049 &_swigt__p_wxCloseEvent,
41050 &_swigt__p_wxColour,
41051 &_swigt__p_wxCommandEvent,
41052 &_swigt__p_wxConfig,
41053 &_swigt__p_wxConfigBase,
41054 &_swigt__p_wxConfigPathChanger,
41055 &_swigt__p_wxContextMenuEvent,
41056 &_swigt__p_wxControl,
41057 &_swigt__p_wxControlWithItems,
41058 &_swigt__p_wxCursor,
41059 &_swigt__p_wxCustomDataObject,
41060 &_swigt__p_wxDC,
41061 &_swigt__p_wxDataFormat,
41062 &_swigt__p_wxDataObject,
41063 &_swigt__p_wxDataObjectComposite,
41064 &_swigt__p_wxDataObjectSimple,
41065 &_swigt__p_wxDateEvent,
41066 &_swigt__p_wxDateSpan,
41067 &_swigt__p_wxDateTime,
41068 &_swigt__p_wxDateTime__TimeZone,
41069 &_swigt__p_wxDisplay,
41070 &_swigt__p_wxDisplayChangedEvent,
41071 &_swigt__p_wxDropFilesEvent,
41072 &_swigt__p_wxDuplexMode,
41073 &_swigt__p_wxEraseEvent,
41074 &_swigt__p_wxEvent,
41075 &_swigt__p_wxEventBlocker,
41076 &_swigt__p_wxEvtHandler,
41077 &_swigt__p_wxFSFile,
41078 &_swigt__p_wxFileConfig,
41079 &_swigt__p_wxFileDataObject,
41080 &_swigt__p_wxFileHistory,
41081 &_swigt__p_wxFileSystem,
41082 &_swigt__p_wxFileType,
41083 &_swigt__p_wxFileTypeInfo,
41084 &_swigt__p_wxFlexGridSizer,
41085 &_swigt__p_wxFocusEvent,
41086 &_swigt__p_wxFont,
41087 &_swigt__p_wxFrame,
41088 &_swigt__p_wxGBSizerItem,
41089 &_swigt__p_wxGIFHandler,
41090 &_swigt__p_wxGridBagSizer,
41091 &_swigt__p_wxGridSizer,
41092 &_swigt__p_wxICOHandler,
41093 &_swigt__p_wxIcon,
41094 &_swigt__p_wxIconBundle,
41095 &_swigt__p_wxIconizeEvent,
41096 &_swigt__p_wxIdleEvent,
41097 &_swigt__p_wxImage,
41098 &_swigt__p_wxImageHandler,
41099 &_swigt__p_wxIndividualLayoutConstraint,
41100 &_swigt__p_wxInitDialogEvent,
41101 &_swigt__p_wxJPEGHandler,
41102 &_swigt__p_wxJoystick,
41103 &_swigt__p_wxJoystickEvent,
41104 &_swigt__p_wxKeyEvent,
41105 &_swigt__p_wxKillError,
41106 &_swigt__p_wxLayoutConstraints,
41107 &_swigt__p_wxLog,
41108 &_swigt__p_wxLogBuffer,
41109 &_swigt__p_wxLogChain,
41110 &_swigt__p_wxLogGui,
41111 &_swigt__p_wxLogNull,
41112 &_swigt__p_wxLogStderr,
41113 &_swigt__p_wxLogTextCtrl,
41114 &_swigt__p_wxLogWindow,
41115 &_swigt__p_wxMaximizeEvent,
41116 &_swigt__p_wxMenu,
41117 &_swigt__p_wxMenuBar,
41118 &_swigt__p_wxMenuEvent,
41119 &_swigt__p_wxMenuItem,
41120 &_swigt__p_wxMetafile,
41121 &_swigt__p_wxMetafileDataObject,
41122 &_swigt__p_wxMimeTypesManager,
41123 &_swigt__p_wxMouseCaptureChangedEvent,
41124 &_swigt__p_wxMouseCaptureLostEvent,
41125 &_swigt__p_wxMouseEvent,
41126 &_swigt__p_wxMouseState,
41127 &_swigt__p_wxMoveEvent,
41128 &_swigt__p_wxMutexGuiLocker,
41129 &_swigt__p_wxNavigationKeyEvent,
41130 &_swigt__p_wxNcPaintEvent,
41131 &_swigt__p_wxNotifyEvent,
41132 &_swigt__p_wxObject,
41133 &_swigt__p_wxOutputStream,
41134 &_swigt__p_wxPCXHandler,
41135 &_swigt__p_wxPNGHandler,
41136 &_swigt__p_wxPNMHandler,
41137 &_swigt__p_wxPaintEvent,
41138 &_swigt__p_wxPaletteChangedEvent,
41139 &_swigt__p_wxPaperSize,
41140 &_swigt__p_wxPlatformInfo,
41141 &_swigt__p_wxPoint,
41142 &_swigt__p_wxPowerEvent,
41143 &_swigt__p_wxProcessEvent,
41144 &_swigt__p_wxPyApp,
41145 &_swigt__p_wxPyArtProvider,
41146 &_swigt__p_wxPyBitmapDataObject,
41147 &_swigt__p_wxPyCommandEvent,
41148 &_swigt__p_wxPyDataObjectSimple,
41149 &_swigt__p_wxPyDropSource,
41150 &_swigt__p_wxPyDropTarget,
41151 &_swigt__p_wxPyEvent,
41152 &_swigt__p_wxPyFileDropTarget,
41153 &_swigt__p_wxPyImageHandler,
41154 &_swigt__p_wxPyLog,
41155 &_swigt__p_wxPyProcess,
41156 &_swigt__p_wxPySizer,
41157 &_swigt__p_wxPyTextDataObject,
41158 &_swigt__p_wxPyTextDropTarget,
41159 &_swigt__p_wxPyTimer,
41160 &_swigt__p_wxPyTipProvider,
41161 &_swigt__p_wxPyValidator,
41162 &_swigt__p_wxQueryNewPaletteEvent,
41163 &_swigt__p_wxRect,
41164 &_swigt__p_wxScrollEvent,
41165 &_swigt__p_wxScrollWinEvent,
41166 &_swigt__p_wxSetCursorEvent,
41167 &_swigt__p_wxShowEvent,
41168 &_swigt__p_wxSingleInstanceChecker,
41169 &_swigt__p_wxSize,
41170 &_swigt__p_wxSizeEvent,
41171 &_swigt__p_wxSizer,
41172 &_swigt__p_wxSizerItem,
41173 &_swigt__p_wxSound,
41174 &_swigt__p_wxStandardPaths,
41175 &_swigt__p_wxStaticBoxSizer,
41176 &_swigt__p_wxStdDialogButtonSizer,
41177 &_swigt__p_wxStopWatch,
41178 &_swigt__p_wxString,
41179 &_swigt__p_wxSysColourChangedEvent,
41180 &_swigt__p_wxSystemOptions,
41181 &_swigt__p_wxSystemSettings,
41182 &_swigt__p_wxTGAHandler,
41183 &_swigt__p_wxTIFFHandler,
41184 &_swigt__p_wxTextCtrl,
41185 &_swigt__p_wxTextDataObject,
41186 &_swigt__p_wxTimeSpan,
41187 &_swigt__p_wxTimer,
41188 &_swigt__p_wxTimerEvent,
41189 &_swigt__p_wxTimerRunner,
41190 &_swigt__p_wxTipProvider,
41191 &_swigt__p_wxToolTip,
41192 &_swigt__p_wxURLDataObject,
41193 &_swigt__p_wxUpdateUIEvent,
41194 &_swigt__p_wxValidator,
41195 &_swigt__p_wxVideoMode,
41196 &_swigt__p_wxWindow,
41197 &_swigt__p_wxWindowCreateEvent,
41198 &_swigt__p_wxWindowDestroyEvent,
41199 &_swigt__p_wxWindowDisabler,
41200 &_swigt__p_wxXPMHandler,
41201 };
41202
41203 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxArtClient[] = { {&_swigt__p_wxArtClient, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxArtID[] = { {&_swigt__p_wxArtID, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41215 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}};
41216 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41219 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41224 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}};
41225 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41230 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}};
41231 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41232 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}};
41233 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41237 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41241 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41244 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41245 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41246 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41247 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41248 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41251 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41252 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41255 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41256 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41257 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41258 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41259 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41260 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41261 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41262 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41263 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41264 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41265 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41266 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41267 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41268 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41269 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41270 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41271 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41272 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41273 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41274 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41275 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41276 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}};
41277 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41278 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41279 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41280 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41281 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41282 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41283 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
41284 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}};
41285 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41286 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41287 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41288 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41289 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41290 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41291 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41292 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41293 static swig_cast_info _swigc__p_wxIconBundle[] = { {&_swigt__p_wxIconBundle, 0, 0, 0},{0, 0, 0, 0}};
41294 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41295 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41296 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41297 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}};
41298 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41299 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41300 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41301 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41302 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41303 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41304 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41305 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41306 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41307 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41308 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41309 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41310 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41311 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41312 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41313 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41314 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41315 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41316 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41317 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41318 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41319 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41320 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41321 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41322 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41323 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41324 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41325 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41326 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41327 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41328 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41329 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41330 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41331 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41332 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41333 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41334 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41335 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41336 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41337 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41338 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41339 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41340 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41341 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41342 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}};
41343 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41344 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41345 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41346 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41347 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41348 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41349 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41350 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41351 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41352 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41353 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}};
41354 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41355 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41356 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41357 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41358 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41359 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41360 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41361 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41362 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41363 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41364 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41365 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41366 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41367 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41368 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41369 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41370 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41371 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}};
41372 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41373 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41374 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41375 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41376 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}};
41377 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41378 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41379 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41380 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}};
41381 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41382
41383 static swig_cast_info *swig_cast_initial[] = {
41384 _swigc__p_char,
41385 _swigc__p_form_ops_t,
41386 _swigc__p_int,
41387 _swigc__p_unsigned_char,
41388 _swigc__p_unsigned_int,
41389 _swigc__p_unsigned_long,
41390 _swigc__p_void,
41391 _swigc__p_wxANIHandler,
41392 _swigc__p_wxAboutDialogInfo,
41393 _swigc__p_wxAcceleratorTable,
41394 _swigc__p_wxActivateEvent,
41395 _swigc__p_wxArrayString,
41396 _swigc__p_wxArtClient,
41397 _swigc__p_wxArtID,
41398 _swigc__p_wxBMPHandler,
41399 _swigc__p_wxBitmap,
41400 _swigc__p_wxBitmapDataObject,
41401 _swigc__p_wxBoxSizer,
41402 _swigc__p_wxBusyCursor,
41403 _swigc__p_wxBusyInfo,
41404 _swigc__p_wxCURHandler,
41405 _swigc__p_wxCaret,
41406 _swigc__p_wxChar,
41407 _swigc__p_wxChildFocusEvent,
41408 _swigc__p_wxClipboard,
41409 _swigc__p_wxClipboardLocker,
41410 _swigc__p_wxClipboardTextEvent,
41411 _swigc__p_wxCloseEvent,
41412 _swigc__p_wxColour,
41413 _swigc__p_wxCommandEvent,
41414 _swigc__p_wxConfig,
41415 _swigc__p_wxConfigBase,
41416 _swigc__p_wxConfigPathChanger,
41417 _swigc__p_wxContextMenuEvent,
41418 _swigc__p_wxControl,
41419 _swigc__p_wxControlWithItems,
41420 _swigc__p_wxCursor,
41421 _swigc__p_wxCustomDataObject,
41422 _swigc__p_wxDC,
41423 _swigc__p_wxDataFormat,
41424 _swigc__p_wxDataObject,
41425 _swigc__p_wxDataObjectComposite,
41426 _swigc__p_wxDataObjectSimple,
41427 _swigc__p_wxDateEvent,
41428 _swigc__p_wxDateSpan,
41429 _swigc__p_wxDateTime,
41430 _swigc__p_wxDateTime__TimeZone,
41431 _swigc__p_wxDisplay,
41432 _swigc__p_wxDisplayChangedEvent,
41433 _swigc__p_wxDropFilesEvent,
41434 _swigc__p_wxDuplexMode,
41435 _swigc__p_wxEraseEvent,
41436 _swigc__p_wxEvent,
41437 _swigc__p_wxEventBlocker,
41438 _swigc__p_wxEvtHandler,
41439 _swigc__p_wxFSFile,
41440 _swigc__p_wxFileConfig,
41441 _swigc__p_wxFileDataObject,
41442 _swigc__p_wxFileHistory,
41443 _swigc__p_wxFileSystem,
41444 _swigc__p_wxFileType,
41445 _swigc__p_wxFileTypeInfo,
41446 _swigc__p_wxFlexGridSizer,
41447 _swigc__p_wxFocusEvent,
41448 _swigc__p_wxFont,
41449 _swigc__p_wxFrame,
41450 _swigc__p_wxGBSizerItem,
41451 _swigc__p_wxGIFHandler,
41452 _swigc__p_wxGridBagSizer,
41453 _swigc__p_wxGridSizer,
41454 _swigc__p_wxICOHandler,
41455 _swigc__p_wxIcon,
41456 _swigc__p_wxIconBundle,
41457 _swigc__p_wxIconizeEvent,
41458 _swigc__p_wxIdleEvent,
41459 _swigc__p_wxImage,
41460 _swigc__p_wxImageHandler,
41461 _swigc__p_wxIndividualLayoutConstraint,
41462 _swigc__p_wxInitDialogEvent,
41463 _swigc__p_wxJPEGHandler,
41464 _swigc__p_wxJoystick,
41465 _swigc__p_wxJoystickEvent,
41466 _swigc__p_wxKeyEvent,
41467 _swigc__p_wxKillError,
41468 _swigc__p_wxLayoutConstraints,
41469 _swigc__p_wxLog,
41470 _swigc__p_wxLogBuffer,
41471 _swigc__p_wxLogChain,
41472 _swigc__p_wxLogGui,
41473 _swigc__p_wxLogNull,
41474 _swigc__p_wxLogStderr,
41475 _swigc__p_wxLogTextCtrl,
41476 _swigc__p_wxLogWindow,
41477 _swigc__p_wxMaximizeEvent,
41478 _swigc__p_wxMenu,
41479 _swigc__p_wxMenuBar,
41480 _swigc__p_wxMenuEvent,
41481 _swigc__p_wxMenuItem,
41482 _swigc__p_wxMetafile,
41483 _swigc__p_wxMetafileDataObject,
41484 _swigc__p_wxMimeTypesManager,
41485 _swigc__p_wxMouseCaptureChangedEvent,
41486 _swigc__p_wxMouseCaptureLostEvent,
41487 _swigc__p_wxMouseEvent,
41488 _swigc__p_wxMouseState,
41489 _swigc__p_wxMoveEvent,
41490 _swigc__p_wxMutexGuiLocker,
41491 _swigc__p_wxNavigationKeyEvent,
41492 _swigc__p_wxNcPaintEvent,
41493 _swigc__p_wxNotifyEvent,
41494 _swigc__p_wxObject,
41495 _swigc__p_wxOutputStream,
41496 _swigc__p_wxPCXHandler,
41497 _swigc__p_wxPNGHandler,
41498 _swigc__p_wxPNMHandler,
41499 _swigc__p_wxPaintEvent,
41500 _swigc__p_wxPaletteChangedEvent,
41501 _swigc__p_wxPaperSize,
41502 _swigc__p_wxPlatformInfo,
41503 _swigc__p_wxPoint,
41504 _swigc__p_wxPowerEvent,
41505 _swigc__p_wxProcessEvent,
41506 _swigc__p_wxPyApp,
41507 _swigc__p_wxPyArtProvider,
41508 _swigc__p_wxPyBitmapDataObject,
41509 _swigc__p_wxPyCommandEvent,
41510 _swigc__p_wxPyDataObjectSimple,
41511 _swigc__p_wxPyDropSource,
41512 _swigc__p_wxPyDropTarget,
41513 _swigc__p_wxPyEvent,
41514 _swigc__p_wxPyFileDropTarget,
41515 _swigc__p_wxPyImageHandler,
41516 _swigc__p_wxPyLog,
41517 _swigc__p_wxPyProcess,
41518 _swigc__p_wxPySizer,
41519 _swigc__p_wxPyTextDataObject,
41520 _swigc__p_wxPyTextDropTarget,
41521 _swigc__p_wxPyTimer,
41522 _swigc__p_wxPyTipProvider,
41523 _swigc__p_wxPyValidator,
41524 _swigc__p_wxQueryNewPaletteEvent,
41525 _swigc__p_wxRect,
41526 _swigc__p_wxScrollEvent,
41527 _swigc__p_wxScrollWinEvent,
41528 _swigc__p_wxSetCursorEvent,
41529 _swigc__p_wxShowEvent,
41530 _swigc__p_wxSingleInstanceChecker,
41531 _swigc__p_wxSize,
41532 _swigc__p_wxSizeEvent,
41533 _swigc__p_wxSizer,
41534 _swigc__p_wxSizerItem,
41535 _swigc__p_wxSound,
41536 _swigc__p_wxStandardPaths,
41537 _swigc__p_wxStaticBoxSizer,
41538 _swigc__p_wxStdDialogButtonSizer,
41539 _swigc__p_wxStopWatch,
41540 _swigc__p_wxString,
41541 _swigc__p_wxSysColourChangedEvent,
41542 _swigc__p_wxSystemOptions,
41543 _swigc__p_wxSystemSettings,
41544 _swigc__p_wxTGAHandler,
41545 _swigc__p_wxTIFFHandler,
41546 _swigc__p_wxTextCtrl,
41547 _swigc__p_wxTextDataObject,
41548 _swigc__p_wxTimeSpan,
41549 _swigc__p_wxTimer,
41550 _swigc__p_wxTimerEvent,
41551 _swigc__p_wxTimerRunner,
41552 _swigc__p_wxTipProvider,
41553 _swigc__p_wxToolTip,
41554 _swigc__p_wxURLDataObject,
41555 _swigc__p_wxUpdateUIEvent,
41556 _swigc__p_wxValidator,
41557 _swigc__p_wxVideoMode,
41558 _swigc__p_wxWindow,
41559 _swigc__p_wxWindowCreateEvent,
41560 _swigc__p_wxWindowDestroyEvent,
41561 _swigc__p_wxWindowDisabler,
41562 _swigc__p_wxXPMHandler,
41563 };
41564
41565
41566 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41567
41568 static swig_const_info swig_const_table[] = {
41569 {0, 0, 0, 0.0, 0, 0}};
41570
41571 #ifdef __cplusplus
41572 }
41573 #endif
41574 /* -----------------------------------------------------------------------------
41575 * Type initialization:
41576 * This problem is tough by the requirement that no dynamic
41577 * memory is used. Also, since swig_type_info structures store pointers to
41578 * swig_cast_info structures and swig_cast_info structures store pointers back
41579 * to swig_type_info structures, we need some lookup code at initialization.
41580 * The idea is that swig generates all the structures that are needed.
41581 * The runtime then collects these partially filled structures.
41582 * The SWIG_InitializeModule function takes these initial arrays out of
41583 * swig_module, and does all the lookup, filling in the swig_module.types
41584 * array with the correct data and linking the correct swig_cast_info
41585 * structures together.
41586 *
41587 * The generated swig_type_info structures are assigned staticly to an initial
41588 * array. We just loop though that array, and handle each type individually.
41589 * First we lookup if this type has been already loaded, and if so, use the
41590 * loaded structure instead of the generated one. Then we have to fill in the
41591 * cast linked list. The cast data is initially stored in something like a
41592 * two-dimensional array. Each row corresponds to a type (there are the same
41593 * number of rows as there are in the swig_type_initial array). Each entry in
41594 * a column is one of the swig_cast_info structures for that type.
41595 * The cast_initial array is actually an array of arrays, because each row has
41596 * a variable number of columns. So to actually build the cast linked list,
41597 * we find the array of casts associated with the type, and loop through it
41598 * adding the casts to the list. The one last trick we need to do is making
41599 * sure the type pointer in the swig_cast_info struct is correct.
41600 *
41601 * First off, we lookup the cast->type name to see if it is already loaded.
41602 * There are three cases to handle:
41603 * 1) If the cast->type has already been loaded AND the type we are adding
41604 * casting info to has not been loaded (it is in this module), THEN we
41605 * replace the cast->type pointer with the type pointer that has already
41606 * been loaded.
41607 * 2) If BOTH types (the one we are adding casting info to, and the
41608 * cast->type) are loaded, THEN the cast info has already been loaded by
41609 * the previous module so we just ignore it.
41610 * 3) Finally, if cast->type has not already been loaded, then we add that
41611 * swig_cast_info to the linked list (because the cast->type) pointer will
41612 * be correct.
41613 * ----------------------------------------------------------------------------- */
41614
41615 #ifdef __cplusplus
41616 extern "C" {
41617 #if 0
41618 } /* c-mode */
41619 #endif
41620 #endif
41621
41622 #if 0
41623 #define SWIGRUNTIME_DEBUG
41624 #endif
41625
41626 SWIGRUNTIME void
41627 SWIG_InitializeModule(void *clientdata) {
41628 size_t i;
41629 swig_module_info *module_head;
41630 static int init_run = 0;
41631
41632 clientdata = clientdata;
41633
41634 if (init_run) return;
41635 init_run = 1;
41636
41637 /* Initialize the swig_module */
41638 swig_module.type_initial = swig_type_initial;
41639 swig_module.cast_initial = swig_cast_initial;
41640
41641 /* Try and load any already created modules */
41642 module_head = SWIG_GetModule(clientdata);
41643 if (module_head) {
41644 swig_module.next = module_head->next;
41645 module_head->next = &swig_module;
41646 } else {
41647 /* This is the first module loaded */
41648 swig_module.next = &swig_module;
41649 SWIG_SetModule(clientdata, &swig_module);
41650 }
41651
41652 /* Now work on filling in swig_module.types */
41653 #ifdef SWIGRUNTIME_DEBUG
41654 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41655 #endif
41656 for (i = 0; i < swig_module.size; ++i) {
41657 swig_type_info *type = 0;
41658 swig_type_info *ret;
41659 swig_cast_info *cast;
41660
41661 #ifdef SWIGRUNTIME_DEBUG
41662 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41663 #endif
41664
41665 /* if there is another module already loaded */
41666 if (swig_module.next != &swig_module) {
41667 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41668 }
41669 if (type) {
41670 /* Overwrite clientdata field */
41671 #ifdef SWIGRUNTIME_DEBUG
41672 printf("SWIG_InitializeModule: found type %s\n", type->name);
41673 #endif
41674 if (swig_module.type_initial[i]->clientdata) {
41675 type->clientdata = swig_module.type_initial[i]->clientdata;
41676 #ifdef SWIGRUNTIME_DEBUG
41677 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41678 #endif
41679 }
41680 } else {
41681 type = swig_module.type_initial[i];
41682 }
41683
41684 /* Insert casting types */
41685 cast = swig_module.cast_initial[i];
41686 while (cast->type) {
41687 /* Don't need to add information already in the list */
41688 ret = 0;
41689 #ifdef SWIGRUNTIME_DEBUG
41690 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41691 #endif
41692 if (swig_module.next != &swig_module) {
41693 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41694 #ifdef SWIGRUNTIME_DEBUG
41695 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41696 #endif
41697 }
41698 if (ret) {
41699 if (type == swig_module.type_initial[i]) {
41700 #ifdef SWIGRUNTIME_DEBUG
41701 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41702 #endif
41703 cast->type = ret;
41704 ret = 0;
41705 } else {
41706 /* Check for casting already in the list */
41707 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41708 #ifdef SWIGRUNTIME_DEBUG
41709 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41710 #endif
41711 if (!ocast) ret = 0;
41712 }
41713 }
41714
41715 if (!ret) {
41716 #ifdef SWIGRUNTIME_DEBUG
41717 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41718 #endif
41719 if (type->cast) {
41720 type->cast->prev = cast;
41721 cast->next = type->cast;
41722 }
41723 type->cast = cast;
41724 }
41725 cast++;
41726 }
41727 /* Set entry in modules->types array equal to the type */
41728 swig_module.types[i] = type;
41729 }
41730 swig_module.types[i] = 0;
41731
41732 #ifdef SWIGRUNTIME_DEBUG
41733 printf("**** SWIG_InitializeModule: Cast List ******\n");
41734 for (i = 0; i < swig_module.size; ++i) {
41735 int j = 0;
41736 swig_cast_info *cast = swig_module.cast_initial[i];
41737 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41738 while (cast->type) {
41739 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41740 cast++;
41741 ++j;
41742 }
41743 printf("---- Total casts: %d\n",j);
41744 }
41745 printf("**** SWIG_InitializeModule: Cast List ******\n");
41746 #endif
41747 }
41748
41749 /* This function will propagate the clientdata field of type to
41750 * any new swig_type_info structures that have been added into the list
41751 * of equivalent types. It is like calling
41752 * SWIG_TypeClientData(type, clientdata) a second time.
41753 */
41754 SWIGRUNTIME void
41755 SWIG_PropagateClientData(void) {
41756 size_t i;
41757 swig_cast_info *equiv;
41758 static int init_run = 0;
41759
41760 if (init_run) return;
41761 init_run = 1;
41762
41763 for (i = 0; i < swig_module.size; i++) {
41764 if (swig_module.types[i]->clientdata) {
41765 equiv = swig_module.types[i]->cast;
41766 while (equiv) {
41767 if (!equiv->converter) {
41768 if (equiv->type && !equiv->type->clientdata)
41769 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41770 }
41771 equiv = equiv->next;
41772 }
41773 }
41774 }
41775 }
41776
41777 #ifdef __cplusplus
41778 #if 0
41779 {
41780 /* c-mode */
41781 #endif
41782 }
41783 #endif
41784
41785
41786
41787 #ifdef __cplusplus
41788 extern "C" {
41789 #endif
41790
41791 /* Python-specific SWIG API */
41792 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41793 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41794 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41795
41796 /* -----------------------------------------------------------------------------
41797 * global variable support code.
41798 * ----------------------------------------------------------------------------- */
41799
41800 typedef struct swig_globalvar {
41801 char *name; /* Name of global variable */
41802 PyObject *(*get_attr)(void); /* Return the current value */
41803 int (*set_attr)(PyObject *); /* Set the value */
41804 struct swig_globalvar *next;
41805 } swig_globalvar;
41806
41807 typedef struct swig_varlinkobject {
41808 PyObject_HEAD
41809 swig_globalvar *vars;
41810 } swig_varlinkobject;
41811
41812 SWIGINTERN PyObject *
41813 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41814 return PyString_FromString("<Swig global variables>");
41815 }
41816
41817 SWIGINTERN PyObject *
41818 swig_varlink_str(swig_varlinkobject *v) {
41819 PyObject *str = PyString_FromString("(");
41820 swig_globalvar *var;
41821 for (var = v->vars; var; var=var->next) {
41822 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41823 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41824 }
41825 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41826 return str;
41827 }
41828
41829 SWIGINTERN int
41830 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41831 PyObject *str = swig_varlink_str(v);
41832 fprintf(fp,"Swig global variables ");
41833 fprintf(fp,"%s\n", PyString_AsString(str));
41834 Py_DECREF(str);
41835 return 0;
41836 }
41837
41838 SWIGINTERN void
41839 swig_varlink_dealloc(swig_varlinkobject *v) {
41840 swig_globalvar *var = v->vars;
41841 while (var) {
41842 swig_globalvar *n = var->next;
41843 free(var->name);
41844 free(var);
41845 var = n;
41846 }
41847 }
41848
41849 SWIGINTERN PyObject *
41850 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41851 PyObject *res = NULL;
41852 swig_globalvar *var = v->vars;
41853 while (var) {
41854 if (strcmp(var->name,n) == 0) {
41855 res = (*var->get_attr)();
41856 break;
41857 }
41858 var = var->next;
41859 }
41860 if (res == NULL && !PyErr_Occurred()) {
41861 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41862 }
41863 return res;
41864 }
41865
41866 SWIGINTERN int
41867 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41868 int res = 1;
41869 swig_globalvar *var = v->vars;
41870 while (var) {
41871 if (strcmp(var->name,n) == 0) {
41872 res = (*var->set_attr)(p);
41873 break;
41874 }
41875 var = var->next;
41876 }
41877 if (res == 1 && !PyErr_Occurred()) {
41878 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41879 }
41880 return res;
41881 }
41882
41883 SWIGINTERN PyTypeObject*
41884 swig_varlink_type(void) {
41885 static char varlink__doc__[] = "Swig var link object";
41886 static PyTypeObject varlink_type;
41887 static int type_init = 0;
41888 if (!type_init) {
41889 const PyTypeObject tmp
41890 = {
41891 PyObject_HEAD_INIT(NULL)
41892 0, /* Number of items in variable part (ob_size) */
41893 (char *)"swigvarlink", /* Type name (tp_name) */
41894 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41895 0, /* Itemsize (tp_itemsize) */
41896 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41897 (printfunc) swig_varlink_print, /* Print (tp_print) */
41898 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41899 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41900 0, /* tp_compare */
41901 (reprfunc) swig_varlink_repr, /* tp_repr */
41902 0, /* tp_as_number */
41903 0, /* tp_as_sequence */
41904 0, /* tp_as_mapping */
41905 0, /* tp_hash */
41906 0, /* tp_call */
41907 (reprfunc)swig_varlink_str, /* tp_str */
41908 0, /* tp_getattro */
41909 0, /* tp_setattro */
41910 0, /* tp_as_buffer */
41911 0, /* tp_flags */
41912 varlink__doc__, /* tp_doc */
41913 0, /* tp_traverse */
41914 0, /* tp_clear */
41915 0, /* tp_richcompare */
41916 0, /* tp_weaklistoffset */
41917 #if PY_VERSION_HEX >= 0x02020000
41918 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41919 #endif
41920 #if PY_VERSION_HEX >= 0x02030000
41921 0, /* tp_del */
41922 #endif
41923 #ifdef COUNT_ALLOCS
41924 0,0,0,0 /* tp_alloc -> tp_next */
41925 #endif
41926 };
41927 varlink_type = tmp;
41928 varlink_type.ob_type = &PyType_Type;
41929 type_init = 1;
41930 }
41931 return &varlink_type;
41932 }
41933
41934 /* Create a variable linking object for use later */
41935 SWIGINTERN PyObject *
41936 SWIG_Python_newvarlink(void) {
41937 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41938 if (result) {
41939 result->vars = 0;
41940 }
41941 return ((PyObject*) result);
41942 }
41943
41944 SWIGINTERN void
41945 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41946 swig_varlinkobject *v = (swig_varlinkobject *) p;
41947 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41948 if (gv) {
41949 size_t size = strlen(name)+1;
41950 gv->name = (char *)malloc(size);
41951 if (gv->name) {
41952 strncpy(gv->name,name,size);
41953 gv->get_attr = get_attr;
41954 gv->set_attr = set_attr;
41955 gv->next = v->vars;
41956 }
41957 }
41958 v->vars = gv;
41959 }
41960
41961 SWIGINTERN PyObject *
41962 SWIG_globals() {
41963 static PyObject *_SWIG_globals = 0;
41964 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41965 return _SWIG_globals;
41966 }
41967
41968 /* -----------------------------------------------------------------------------
41969 * constants/methods manipulation
41970 * ----------------------------------------------------------------------------- */
41971
41972 /* Install Constants */
41973 SWIGINTERN void
41974 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41975 PyObject *obj = 0;
41976 size_t i;
41977 for (i = 0; constants[i].type; ++i) {
41978 switch(constants[i].type) {
41979 case SWIG_PY_POINTER:
41980 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41981 break;
41982 case SWIG_PY_BINARY:
41983 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41984 break;
41985 default:
41986 obj = 0;
41987 break;
41988 }
41989 if (obj) {
41990 PyDict_SetItemString(d, constants[i].name, obj);
41991 Py_DECREF(obj);
41992 }
41993 }
41994 }
41995
41996 /* -----------------------------------------------------------------------------*/
41997 /* Fix SwigMethods to carry the callback ptrs when needed */
41998 /* -----------------------------------------------------------------------------*/
41999
42000 SWIGINTERN void
42001 SWIG_Python_FixMethods(PyMethodDef *methods,
42002 swig_const_info *const_table,
42003 swig_type_info **types,
42004 swig_type_info **types_initial) {
42005 size_t i;
42006 for (i = 0; methods[i].ml_name; ++i) {
42007 const char *c = methods[i].ml_doc;
42008 if (c && (c = strstr(c, "swig_ptr: "))) {
42009 int j;
42010 swig_const_info *ci = 0;
42011 const char *name = c + 10;
42012 for (j = 0; const_table[j].type; ++j) {
42013 if (strncmp(const_table[j].name, name,
42014 strlen(const_table[j].name)) == 0) {
42015 ci = &(const_table[j]);
42016 break;
42017 }
42018 }
42019 if (ci) {
42020 size_t shift = (ci->ptype) - types;
42021 swig_type_info *ty = types_initial[shift];
42022 size_t ldoc = (c - methods[i].ml_doc);
42023 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
42024 char *ndoc = (char*)malloc(ldoc + lptr + 10);
42025 if (ndoc) {
42026 char *buff = ndoc;
42027 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
42028 if (ptr) {
42029 strncpy(buff, methods[i].ml_doc, ldoc);
42030 buff += ldoc;
42031 strncpy(buff, "swig_ptr: ", 10);
42032 buff += 10;
42033 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
42034 methods[i].ml_doc = ndoc;
42035 }
42036 }
42037 }
42038 }
42039 }
42040 }
42041
42042 #ifdef __cplusplus
42043 }
42044 #endif
42045
42046 /* -----------------------------------------------------------------------------*
42047 * Partial Init method
42048 * -----------------------------------------------------------------------------*/
42049
42050 #ifdef __cplusplus
42051 extern "C"
42052 #endif
42053 SWIGEXPORT void SWIG_init(void) {
42054 PyObject *m, *d;
42055
42056 /* Fix SwigMethods to carry the callback ptrs when needed */
42057 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
42058
42059 m = Py_InitModule((char *) SWIG_name, SwigMethods);
42060 d = PyModule_GetDict(m);
42061
42062 SWIG_InitializeModule(0);
42063 SWIG_InstallConstants(d,swig_const_table);
42064
42065
42066 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
42067 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
42068 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
42069 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
42070 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
42071 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
42072 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
42073 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
42074 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
42075 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
42076 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
42077 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
42078 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
42079 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
42080 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
42081 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
42082 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
42083 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
42084 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
42085 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
42086 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
42087 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
42088 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
42089 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
42090 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
42091 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
42092 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
42093 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
42094 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
42095 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
42096 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
42097 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
42098 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
42099 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
42100 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
42101 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
42102 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
42103 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
42104 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
42105 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
42106 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
42107 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
42108 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
42109 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
42110 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
42111 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
42112 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
42113 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
42114 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
42115 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
42116 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
42117 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
42118 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
42119 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
42120 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
42121 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
42122 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
42123 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
42124 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
42125 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
42126 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
42127 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
42128 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42129 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42130 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42131 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42132 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42133 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42134 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42135 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42136 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42137 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42138 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42139 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42140 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42141 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42142 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42143 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42144 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42145 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42146 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42147 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42148 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42149 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42150 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42151 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42152 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42153 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42154 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42155 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42156 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42157 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42158 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42159 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42160 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42161 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42162 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42163 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42164 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42165 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42166 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42167 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42168 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42169 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42170 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42171 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42172 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42173 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42174 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42175 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42176 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42177 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42178 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42179 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42180 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42181 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42182 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42183 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42184 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42185 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42186 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42187 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42188 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42189 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42190 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42191 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42192 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42193 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42194 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42195 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42196 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42197 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42198 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42199 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42200 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42201 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42202 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42203 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42204 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42205 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42206 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42207 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42208 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42209 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42210 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42211 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42212 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42213 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42214
42215 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42216
42217 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42218 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42219 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42220 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42221 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42222 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42223 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42224 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42225 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42226 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42227 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42228 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42229 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42230 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42231 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42232 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42233 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42234 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42235 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42236 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42237 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42238 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42239 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42240 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42241 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42242 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42243 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42244 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42245 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42246 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42247 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42248 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42249 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42250 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42251 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42252 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42253 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42254 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42255 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42256 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42257 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42258 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42259 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42260 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42261 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42262 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42263 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42264 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42265 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42266 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42267 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42268 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42269 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42270 SWIG_Python_SetConstant(d, "EXEC_NOEVENTS",SWIG_From_int(static_cast< int >(wxEXEC_NOEVENTS)));
42271 SWIG_Python_SetConstant(d, "EXEC_BLOCK",SWIG_From_int(static_cast< int >(wxEXEC_BLOCK)));
42272
42273 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42274
42275 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42276 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42277 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42278 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42279 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42280 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42281 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42282 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42283 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42284 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42285 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42286 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42287 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42288 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42289 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42290 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42291 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42292 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42293 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42294 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42295 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42296 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42297 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42298 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42299 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42300 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42301 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42302 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST",ART_LIST_get, ART_LIST_set);
42303 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42304 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42305 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42306 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42307 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42308 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42309 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42310 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42311 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42312 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42313 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42314 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42315 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42316 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42317 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42318 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42319 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42320 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42321 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42322 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42323 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42324 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42325 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42326 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42327 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42328 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42329 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42330 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42331 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42332 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42333 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42334 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42335 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42336 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42337 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42338 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42339 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42340 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42341 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42342 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42343 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42344 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42345 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42346 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42347 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42348 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42349 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42350 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42351 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42352
42353 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42354
42355 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42356 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42357 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42358 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42359 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42360 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42361 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42362 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42363 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42364 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42365 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42366 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42367 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42368 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42369 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42370 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42371 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42372 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42373 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42374 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42375 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42376 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42377 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42378 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42379 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42380 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42381 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42382 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42383 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42384 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42385 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42386 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42387 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42388 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42389 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42390 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42391 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42392 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42393 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42394 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42395 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42396 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42397 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42398 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42399 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42400 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42401 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42402 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42403 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42404 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42405 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42406 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42407 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42408 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42409 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42410 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42411 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42412 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42413 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42414 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42415 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42416 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42417 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42418 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42419 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42420 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42421 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42422 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42423 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42424 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42425 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42426 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42427 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42428 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42429 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42430 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42431 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42432 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42433 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42434 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42435 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42436 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42437 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42438 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42439 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42440 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42441 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42442 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42443 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42444 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42445 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42446 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42447 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42448 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42449 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42450 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42451 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42452 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42453 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42454 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42455 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42456 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42457 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42458 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42459 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42460 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42461 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42462 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42463 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42464 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42465 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42466 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42467 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42468 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42469 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42470 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42471 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42472 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42473 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42474 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42475 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42476 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42477 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42478 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42479 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42480 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42481 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42482 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42483 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42484 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42485 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42486 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42487 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42488 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42489 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42490 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42491 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42492 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42493 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42494 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42495 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42496 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42497 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42498 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42499 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42500 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42501 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42502 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42503 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42504 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42505 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42506 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42507 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42508 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42509 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42510 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42511 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42512 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42513 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42514 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42515 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42516 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42517 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42518 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42519 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42520 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42521 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42522 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42523 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42524 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42525 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42526 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42527 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42528 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42529 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42530 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42531 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42532 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42533 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42534 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42535 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42536 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42537 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42538 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42539 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42540 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42541 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42542 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42543 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42544 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42545 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42546 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42547 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42548 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42549 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42550 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42551 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42552 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42553 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42554 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42555 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42556 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42557 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42558
42559 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42560 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42561 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42562 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42563
42564 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42565 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42566 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42567 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42568 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42569 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42570 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42571 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42572 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42573 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42574 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42575 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42576 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42577 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42578 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42579 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42580 }
42581
wxWidgets (Impactor)