]> 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
Add GetDateOnly
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_wxTGAHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTIFFHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTextCtrl swig_types[158]
2625 #define SWIGTYPE_p_wxTextDataObject swig_types[159]
2626 #define SWIGTYPE_p_wxTimeSpan swig_types[160]
2627 #define SWIGTYPE_p_wxTimer swig_types[161]
2628 #define SWIGTYPE_p_wxTimerEvent swig_types[162]
2629 #define SWIGTYPE_p_wxTimerRunner swig_types[163]
2630 #define SWIGTYPE_p_wxTipProvider swig_types[164]
2631 #define SWIGTYPE_p_wxToolTip swig_types[165]
2632 #define SWIGTYPE_p_wxURLDataObject swig_types[166]
2633 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[167]
2634 #define SWIGTYPE_p_wxValidator swig_types[168]
2635 #define SWIGTYPE_p_wxVideoMode swig_types[169]
2636 #define SWIGTYPE_p_wxWindow swig_types[170]
2637 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDisabler swig_types[173]
2640 #define SWIGTYPE_p_wxXPMHandler swig_types[174]
2641 static swig_type_info *swig_types[176];
2642 static swig_module_info swig_module = {swig_types, 175, 0, 0, 0, 0};
2643 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2644 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2645
2646 /* -------- TYPES TABLE (END) -------- */
2647
2648 #if (PY_VERSION_HEX <= 0x02000000)
2649 # if !defined(SWIG_PYTHON_CLASSIC)
2650 # error "This python version requires to use swig with the '-classic' option"
2651 # endif
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodern' option"
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodernargs' option"
2658 #endif
2659 #ifndef METH_O
2660 # error "This python version requires to use swig with the '-nofastunpack' option"
2661 #endif
2662
2663 /*-----------------------------------------------
2664 @(target):= _misc_.so
2665 ------------------------------------------------*/
2666 #define SWIG_init init_misc_
2667
2668 #define SWIG_name "_misc_"
2669
2670 #define SWIGVERSION 0x010329
2671
2672
2673 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2674 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2675
2676
2677 #include <stdexcept>
2678
2679
2680 namespace swig {
2681 class PyObject_ptr {
2682 protected:
2683 PyObject *_obj;
2684
2685 public:
2686 PyObject_ptr() :_obj(0)
2687 {
2688 }
2689
2690 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2691 {
2692 Py_XINCREF(_obj);
2693 }
2694
2695 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2696 {
2697 if (initial_ref) Py_XINCREF(_obj);
2698 }
2699
2700 PyObject_ptr & operator=(const PyObject_ptr& item)
2701 {
2702 Py_XINCREF(item._obj);
2703 Py_XDECREF(_obj);
2704 _obj = item._obj;
2705 return *this;
2706 }
2707
2708 ~PyObject_ptr()
2709 {
2710 Py_XDECREF(_obj);
2711 }
2712
2713 operator PyObject *() const
2714 {
2715 return _obj;
2716 }
2717
2718 PyObject *operator->() const
2719 {
2720 return _obj;
2721 }
2722 };
2723 }
2724
2725
2726 namespace swig {
2727 struct PyObject_var : PyObject_ptr {
2728 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2729
2730 PyObject_var & operator = (PyObject* obj)
2731 {
2732 Py_XDECREF(_obj);
2733 _obj = obj;
2734 return *this;
2735 }
2736 };
2737 }
2738
2739
2740 #include "wx/wxPython/wxPython.h"
2741 #include "wx/wxPython/pyclasses.h"
2742 #include "wx/wxPython/pyistream.h"
2743
2744 static const wxString wxPyEmptyString(wxEmptyString);
2745
2746
2747
2748 #define SWIG_From_long PyInt_FromLong
2749
2750
2751 SWIGINTERNINLINE PyObject *
2752 SWIG_From_int (int value)
2753 {
2754 return SWIG_From_long (value);
2755 }
2756
2757
2758 #include <limits.h>
2759 #ifndef LLONG_MIN
2760 # define LLONG_MIN LONG_LONG_MIN
2761 #endif
2762 #ifndef LLONG_MAX
2763 # define LLONG_MAX LONG_LONG_MAX
2764 #endif
2765 #ifndef ULLONG_MAX
2766 # define ULLONG_MAX ULONG_LONG_MAX
2767 #endif
2768
2769
2770 SWIGINTERN int
2771 SWIG_AsVal_long (PyObject* obj, long* val)
2772 {
2773 if (PyNumber_Check(obj)) {
2774 if (val) *val = PyInt_AsLong(obj);
2775 return SWIG_OK;
2776 }
2777 return SWIG_TypeError;
2778 }
2779
2780
2781 SWIGINTERN int
2782 SWIG_AsVal_int (PyObject * obj, int *val)
2783 {
2784 long v;
2785 int res = SWIG_AsVal_long (obj, &v);
2786 if (SWIG_IsOK(res)) {
2787 if ((v < INT_MIN || v > INT_MAX)) {
2788 return SWIG_OverflowError;
2789 } else {
2790 if (val) *val = static_cast< int >(v);
2791 }
2792 }
2793 return res;
2794 }
2795
2796 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2797
2798 #include <wx/stockitem.h>
2799
2800 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2801 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2802 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2803
2804 SWIGINTERN int
2805 SWIG_AsVal_bool (PyObject *obj, bool *val)
2806 {
2807 if (obj == Py_True) {
2808 if (val) *val = true;
2809 return SWIG_OK;
2810 } else if (obj == Py_False) {
2811 if (val) *val = false;
2812 return SWIG_OK;
2813 } else {
2814 long v = 0;
2815 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2816 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2817 return res;
2818 }
2819 }
2820
2821
2822 SWIGINTERN int
2823 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2824 {
2825 long v = 0;
2826 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2827 return SWIG_TypeError;
2828 }
2829 else if (val)
2830 *val = (unsigned long)v;
2831 return SWIG_OK;
2832 }
2833
2834
2835 SWIGINTERNINLINE PyObject*
2836 SWIG_From_unsigned_SS_long (unsigned long value)
2837 {
2838 return (value > LONG_MAX) ?
2839 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2840 }
2841
2842
2843 void* wxGetXDisplay()
2844 {
2845 #ifdef __WXGTK__
2846 return wxGetDisplay();
2847 #else
2848 return NULL;
2849 #endif
2850 }
2851
2852
2853 wxWindow* FindWindowAtPointer() {
2854 wxPoint unused;
2855 return wxFindWindowAtPointer(unused);
2856 }
2857
2858
2859 bool wxThread_IsMain() {
2860 #ifdef WXP_WITH_THREAD
2861 return wxThread::IsMain();
2862 #else
2863 return true;
2864 #endif
2865 }
2866
2867 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2868 delete self;
2869 }
2870
2871 #include <wx/snglinst.h>
2872
2873
2874 #ifdef __WXMSW__
2875 #include <wx/msw/private.h>
2876 #include <wx/dynload.h>
2877 #endif
2878
2879
2880
2881 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2882 #if 0
2883 , int method
2884 #endif
2885 )
2886 {
2887 #ifdef __WXMSW__
2888 #if 0
2889 switch (method)
2890 {
2891 case 1:
2892 // This one only partially works. Appears to be an undocumented
2893 // "standard" convention that not all widgets adhear to. For
2894 // example, for some widgets backgrounds or non-client areas may
2895 // not be painted.
2896 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2897 break;
2898
2899 case 2:
2900 #endif
2901 // This one works much better, nearly all widgets and their
2902 // children are captured correctly[**]. Prior to the big
2903 // background erase changes that Vadim did in 2004-2005 this
2904 // method failed badly on XP with Themes activated, most native
2905 // widgets draw only partially, if at all. Without themes it
2906 // worked just like on Win2k. After those changes this method
2907 // works very well.
2908 //
2909 // ** For example the radio buttons in a wxRadioBox are not its
2910 // children by default, but you can capture it via the panel
2911 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2912 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2913 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2914 PRF_ERASEBKGND | PRF_OWNED );
2915 return true;
2916 #if 0
2917 break;
2918
2919 case 3:
2920 // This one is only defined in the latest SDK and is only
2921 // available on XP. MSDN says it is similar to sending WM_PRINT
2922 // so I expect that it will work similar to the above. Since it
2923 // is avaialble only on XP, it can't be compiled like this and
2924 // will have to be loaded dynamically.
2925 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2926
2927 // fall through
2928
2929 case 4:
2930 // Use PrintWindow if available, or fallback to WM_PRINT
2931 // otherwise. Unfortunately using PrintWindow is even worse than
2932 // WM_PRINT. For most native widgets nothing is drawn to the dc
2933 // at all, with or without Themes.
2934 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2935 static bool s_triedToLoad = false;
2936 static PrintWindow_t pfnPrintWindow = NULL;
2937 if ( !s_triedToLoad )
2938 {
2939
2940 s_triedToLoad = true;
2941 wxDynamicLibrary dllUser32(_T("user32.dll"));
2942 if ( dllUser32.IsLoaded() )
2943 {
2944 wxLogNull nolog; // Don't report errors here
2945 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2946 }
2947 }
2948 if (pfnPrintWindow)
2949 {
2950 //printf("Using PrintWindow\n");
2951 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2952 }
2953 else
2954 {
2955 //printf("Using WM_PRINT\n");
2956 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2957 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2958 PRF_ERASEBKGND | PRF_OWNED );
2959 }
2960 }
2961 #endif // 0
2962 #else
2963 return false;
2964 #endif // __WXMSW__
2965 }
2966
2967
2968
2969 #include <wx/tipdlg.h>
2970
2971
2972 SWIGINTERNINLINE PyObject *
2973 SWIG_From_size_t (size_t value)
2974 {
2975 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2976 }
2977
2978
2979 class wxPyTipProvider : public wxTipProvider {
2980 public:
2981 wxPyTipProvider(size_t currentTip)
2982 : wxTipProvider(currentTip) {}
2983
2984 DEC_PYCALLBACK_STRING__pure(GetTip);
2985 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2986 PYPRIVATE;
2987 };
2988
2989 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2990 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2991
2992
2993 SWIGINTERNINLINE int
2994 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2995 {
2996 unsigned long v;
2997 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2998 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2999 return res;
3000 }
3001
3002
3003 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3004
3005 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3006
3007 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3008 : wxTimer(owner, id)
3009 {
3010 if (owner == NULL)
3011 SetOwner(this);
3012 }
3013
3014 wxPyTimer::~wxPyTimer()
3015 {
3016 // printf("-=* ~wxPyTimer\n");
3017 }
3018
3019
3020
3021 SWIGINTERN swig_type_info*
3022 SWIG_pchar_descriptor()
3023 {
3024 static int init = 0;
3025 static swig_type_info* info = 0;
3026 if (!init) {
3027 info = SWIG_TypeQuery("_p_char");
3028 init = 1;
3029 }
3030 return info;
3031 }
3032
3033
3034 SWIGINTERNINLINE PyObject *
3035 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3036 {
3037 if (carray) {
3038 if (size > INT_MAX) {
3039 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3040 return pchar_descriptor ?
3041 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3042 } else {
3043 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3044 }
3045 } else {
3046 return SWIG_Py_Void();
3047 }
3048 }
3049
3050
3051 SWIGINTERNINLINE PyObject *
3052 SWIG_FromCharPtr(const char *cptr)
3053 {
3054 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3055 }
3056
3057
3058 SWIGINTERN int
3059 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3060 {
3061 unsigned long v;
3062 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3063 if (SWIG_IsOK(res)) {
3064 if ((v > UINT_MAX)) {
3065 return SWIG_OverflowError;
3066 } else {
3067 if (val) *val = static_cast< unsigned int >(v);
3068 }
3069 }
3070 return res;
3071 }
3072
3073 SWIGINTERN wxString wxLog_TimeStamp(){
3074 wxString msg;
3075 wxLog::TimeStamp(&msg);
3076 return msg;
3077 }
3078 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3079 // Make some wrappers that double any % signs so they are 'escaped'
3080 void wxPyLogFatalError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogFatalError(m);
3085 }
3086
3087 void wxPyLogError(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogError(m);
3092 }
3093
3094 void wxPyLogWarning(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogWarning(m);
3099 }
3100
3101 void wxPyLogMessage(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogMessage(m);
3106 }
3107
3108 void wxPyLogInfo(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogInfo(m);
3113 }
3114
3115 void wxPyLogDebug(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogDebug(m);
3120 }
3121
3122 void wxPyLogVerbose(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogVerbose(m);
3127 }
3128
3129 void wxPyLogStatus(const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(m);
3134 }
3135
3136 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogStatus(pFrame, m);
3141 }
3142
3143 void wxPyLogSysError(const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogSysError(m);
3148 }
3149
3150 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogGeneric(level, m);
3155 }
3156
3157 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3165 {
3166 wxString m(msg);
3167 m.Replace(wxT("%"), wxT("%%"));
3168 wxLogTrace(mask, m);
3169 }
3170
3171
3172
3173 // A wxLog class that can be derived from in wxPython
3174 class wxPyLog : public wxLog {
3175 public:
3176 wxPyLog() : wxLog() {}
3177
3178 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3179 bool found;
3180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3181 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3182 PyObject* s = wx2PyString(szString);
3183 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3184 Py_DECREF(s);
3185 }
3186 wxPyEndBlockThreads(blocked);
3187 if (! found)
3188 wxLog::DoLog(level, szString, t);
3189 }
3190
3191 virtual void DoLogString(const wxChar *szString, time_t t) {
3192 bool found;
3193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3194 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3195 PyObject* s = wx2PyString(szString);
3196 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3197 Py_DECREF(s);
3198 }
3199 wxPyEndBlockThreads(blocked);
3200 if (! found)
3201 wxLog::DoLogString(szString, t);
3202 }
3203
3204 DEC_PYCALLBACK_VOID_(Flush);
3205 PYPRIVATE;
3206 };
3207 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3208
3209
3210
3211
3212 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3213
3214
3215 #include <wx/joystick.h>
3216
3217
3218 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3219 // A C++ stub class for wxJoystick for platforms that don't have it.
3220 class wxJoystick : public wxObject {
3221 public:
3222 wxJoystick(int joystick = wxJOYSTICK1) {
3223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3224 PyErr_SetString(PyExc_NotImplementedError,
3225 "wxJoystick is not available on this platform.");
3226 wxPyEndBlockThreads(blocked);
3227 }
3228 wxPoint GetPosition() { return wxPoint(-1,-1); }
3229 int GetZPosition() { return -1; }
3230 int GetButtonState() { return -1; }
3231 int GetPOVPosition() { return -1; }
3232 int GetPOVCTSPosition() { return -1; }
3233 int GetRudderPosition() { return -1; }
3234 int GetUPosition() { return -1; }
3235 int GetVPosition() { return -1; }
3236 int GetMovementThreshold() { return -1; }
3237 void SetMovementThreshold(int threshold) {}
3238
3239 bool IsOk(void) { return false; }
3240 int GetNumberJoysticks() { return -1; }
3241 int GetManufacturerId() { return -1; }
3242 int GetProductId() { return -1; }
3243 wxString GetProductName() { return wxEmptyString; }
3244 int GetXMin() { return -1; }
3245 int GetYMin() { return -1; }
3246 int GetZMin() { return -1; }
3247 int GetXMax() { return -1; }
3248 int GetYMax() { return -1; }
3249 int GetZMax() { return -1; }
3250 int GetNumberButtons() { return -1; }
3251 int GetNumberAxes() { return -1; }
3252 int GetMaxButtons() { return -1; }
3253 int GetMaxAxes() { return -1; }
3254 int GetPollingMin() { return -1; }
3255 int GetPollingMax() { return -1; }
3256 int GetRudderMin() { return -1; }
3257 int GetRudderMax() { return -1; }
3258 int GetUMin() { return -1; }
3259 int GetUMax() { return -1; }
3260 int GetVMin() { return -1; }
3261 int GetVMax() { return -1; }
3262
3263 bool HasRudder() { return false; }
3264 bool HasZ() { return false; }
3265 bool HasU() { return false; }
3266 bool HasV() { return false; }
3267 bool HasPOV() { return false; }
3268 bool HasPOV4Dir() { return false; }
3269 bool HasPOVCTS() { return false; }
3270
3271 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3272 bool ReleaseCapture() { return false; }
3273 };
3274 #endif
3275
3276
3277 #include <wx/sound.h>
3278
3279
3280 #if !wxUSE_SOUND
3281 // A C++ stub class for wxWave for platforms that don't have it.
3282 class wxSound : public wxObject
3283 {
3284 public:
3285 wxSound() {
3286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3287 PyErr_SetString(PyExc_NotImplementedError,
3288 "wxSound is not available on this platform.");
3289 wxPyEndBlockThreads(blocked);
3290 }
3291 wxSound(const wxString&/*, bool*/) {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297 wxSound(int, const wxByte*) {
3298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3299 PyErr_SetString(PyExc_NotImplementedError,
3300 "wxSound is not available on this platform.");
3301 wxPyEndBlockThreads(blocked);
3302 }
3303
3304 ~wxSound() {};
3305
3306 bool Create(const wxString&/*, bool*/) { return false; }
3307 bool Create(int, const wxByte*) { return false; };
3308 bool IsOk() { return false; };
3309 bool Play(unsigned) const { return false; }
3310 static bool Play(const wxString&, unsigned) { return false; }
3311 static void Stop() {}
3312 };
3313
3314 #endif
3315
3316 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3317 if (fileName.Length() == 0)
3318 return new wxSound;
3319 else
3320 return new wxSound(fileName);
3321 }
3322 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3323 unsigned char* buffer; int size;
3324 wxSound *sound = NULL;
3325
3326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3327 if (!PyArg_Parse(data, "t#", &buffer, &size))
3328 goto done;
3329 sound = new wxSound(size, buffer);
3330 done:
3331 wxPyEndBlockThreads(blocked);
3332 return sound;
3333 }
3334 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3335 #ifndef __WXMAC__
3336 unsigned char* buffer;
3337 int size;
3338 bool rv = false;
3339
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 if (!PyArg_Parse(data, "t#", &buffer, &size))
3342 goto done;
3343 rv = self->Create(size, buffer);
3344 done:
3345 wxPyEndBlockThreads(blocked);
3346 return rv;
3347 #else
3348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3349 PyErr_SetString(PyExc_NotImplementedError,
3350 "Create from data is not available on this platform.");
3351 wxPyEndBlockThreads(blocked);
3352 return false;
3353 #endif
3354 }
3355
3356 #include <wx/mimetype.h>
3357
3358 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3359 wxString str;
3360 if (self->GetMimeType(&str))
3361 return wx2PyString(str);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetMimeTypes(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3373 wxArrayString arr;
3374 if (self->GetExtensions(arr))
3375 return wxArrayString2PyList_helper(arr);
3376 else
3377 RETURN_NONE();
3378 }
3379 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc))
3382 return new wxIcon(loc);
3383 else
3384 return NULL;
3385 }
3386 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3387 wxIconLocation loc;
3388 if (self->GetIcon(&loc)) {
3389 wxString iconFile = loc.GetFileName();
3390 int iconIndex = -1;
3391
3392
3393
3394 // Make a tuple and put the values in it
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 PyObject* tuple = PyTuple_New(3);
3397 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3398 wxT("wxIcon"), true));
3399 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3400 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3401 wxPyEndBlockThreads(blocked);
3402 return tuple;
3403 }
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3408 wxString str;
3409 if (self->GetDescription(&str))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxString str;
3423 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3424 return wx2PyString(str);
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 wxArrayString verbs;
3430 wxArrayString commands;
3431 if (self->GetAllCommands(&verbs, &commands,
3432 wxFileType::MessageParameters(filename, mimetype))) {
3433 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3434 PyObject* tuple = PyTuple_New(2);
3435 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3436 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3437 wxPyEndBlockThreads(blocked);
3438 return tuple;
3439 }
3440 else
3441 RETURN_NONE();
3442 }
3443 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3444 return wxFileType::ExpandCommand(command,
3445 wxFileType::MessageParameters(filename, mimetype));
3446 }
3447 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3448 wxArrayString arr;
3449 self->EnumAllFileTypes(arr);
3450 return wxArrayString2PyList_helper(arr);
3451 }
3452
3453 #include <wx/artprov.h>
3454
3455 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3456 static const wxString wxPyART_MENU(wxART_MENU);
3457 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3458 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3459 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3460 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3461 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3462 static const wxString wxPyART_OTHER(wxART_OTHER);
3463 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3464 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3465 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3466 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3467 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3468 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3469 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3470 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3471 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3472 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3473 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3474 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3475 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3476 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3477 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3478 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3479 static const wxString wxPyART_PRINT(wxART_PRINT);
3480 static const wxString wxPyART_HELP(wxART_HELP);
3481 static const wxString wxPyART_TIP(wxART_TIP);
3482 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3483 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3484 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3485 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3486 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3487 static const wxString wxPyART_CDROM(wxART_CDROM);
3488 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3489 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3490 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3491 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3492 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3493 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3494 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3495 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3496 static const wxString wxPyART_ERROR(wxART_ERROR);
3497 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3498 static const wxString wxPyART_WARNING(wxART_WARNING);
3499 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3500 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3501 static const wxString wxPyART_COPY(wxART_COPY);
3502 static const wxString wxPyART_CUT(wxART_CUT);
3503 static const wxString wxPyART_PASTE(wxART_PASTE);
3504 static const wxString wxPyART_DELETE(wxART_DELETE);
3505 static const wxString wxPyART_NEW(wxART_NEW);
3506 static const wxString wxPyART_UNDO(wxART_UNDO);
3507 static const wxString wxPyART_REDO(wxART_REDO);
3508 static const wxString wxPyART_QUIT(wxART_QUIT);
3509 static const wxString wxPyART_FIND(wxART_FIND);
3510 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3511 // Python aware wxArtProvider
3512 class wxPyArtProvider : public wxArtProvider {
3513 public:
3514
3515 virtual wxBitmap CreateBitmap(const wxArtID& id,
3516 const wxArtClient& client,
3517 const wxSize& size) {
3518 wxBitmap rval = wxNullBitmap;
3519 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3520 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3521 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3522 PyObject* ro;
3523 wxBitmap* ptr;
3524 PyObject* s1, *s2;
3525 s1 = wx2PyString(id);
3526 s2 = wx2PyString(client);
3527 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3528 Py_DECREF(so);
3529 Py_DECREF(s1);
3530 Py_DECREF(s2);
3531 if (ro) {
3532 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3533 rval = *ptr;
3534 Py_DECREF(ro);
3535 }
3536 }
3537 wxPyEndBlockThreads(blocked);
3538 return rval;
3539 }
3540
3541 PYPRIVATE;
3542 };
3543
3544 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3545
3546
3547
3548 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3549 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3550 PyObject* ret = PyTuple_New(3);
3551 if (ret) {
3552 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3553 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3554 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3555 }
3556 wxPyEndBlockThreads(blocked);
3557 return ret;
3558 }
3559
3560 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3561 bool cont;
3562 long index = 0;
3563 wxString value;
3564
3565 cont = self->GetFirstGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3569 bool cont;
3570 wxString value;
3571
3572 cont = self->GetNextGroup(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3576 bool cont;
3577 long index = 0;
3578 wxString value;
3579
3580 cont = self->GetFirstEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3584 bool cont;
3585 wxString value;
3586
3587 cont = self->GetNextEntry(value, index);
3588 return __EnumerationHelper(cont, value, index);
3589 }
3590 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3591 long rv;
3592 self->Read(key, &rv, defaultVal);
3593 return rv;
3594 }
3595
3596 SWIGINTERN int
3597 SWIG_AsVal_double (PyObject *obj, double* val)
3598 {
3599 if (PyNumber_Check(obj)) {
3600 if (val) *val = PyFloat_AsDouble(obj);
3601 return SWIG_OK;
3602 }
3603 return SWIG_TypeError;
3604 }
3605
3606 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3607 double rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #define SWIG_From_double PyFloat_FromDouble
3613
3614 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3615 bool rv;
3616 self->Read(key, &rv, defaultVal);
3617 return rv;
3618 }
3619
3620 #include <wx/datetime.h>
3621
3622 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3623 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3624
3625 #define LOCAL_TZ wxDateTime::Local
3626
3627 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3628 wxString am;
3629 wxString pm;
3630 wxDateTime::GetAmPmStrings(&am, &pm);
3631 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3632 PyObject* tup = PyTuple_New(2);
3633 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3634 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3635 wxPyEndBlockThreads(blocked);
3636 return tup;
3637 }
3638
3639 SWIGINTERNINLINE PyObject *
3640 SWIG_From_unsigned_SS_int (unsigned int value)
3641 {
3642 return SWIG_From_unsigned_SS_long (value);
3643 }
3644
3645 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3646 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3647 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3648 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3649 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3650 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3652 return (*self < *other);
3653 }
3654 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3656 return (*self <= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3660 return (*self > *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3664 return (*self >= *other);
3665 }
3666 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3667 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3668 return (*self == *other);
3669 }
3670 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3671 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3672 return (*self != *other);
3673 }
3674 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseRfc822Date(_date);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3682 const wxChar* rv;
3683 const wxChar* _date = date;
3684 rv = self->ParseFormat(_date, format, dateDef);
3685 if (rv == NULL) return -1;
3686 return rv - _date;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3689 const wxChar* rv;
3690 const wxChar* _datetime = datetime;
3691 rv = self->ParseDateTime(_datetime);
3692 if (rv == NULL) return -1;
3693 return rv - _datetime;
3694 }
3695 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3696 const wxChar* rv;
3697 const wxChar* _date = date;
3698 rv = self->ParseDate(_date);
3699 if (rv == NULL) return -1;
3700 return rv - _date;
3701 }
3702 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3703 const wxChar* rv;
3704 const wxChar* _time = time;
3705 rv = self->ParseTime(_time);
3706 if (rv == NULL) return -1;
3707 return rv - _time;
3708 }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3712 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3713 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3714 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3716 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3717 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3718 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3719 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3720 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3721 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3722 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3723 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3724 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3725
3726 #include <wx/dataobj.h>
3727
3728 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3729 size_t count = self->GetFormatCount(dir);
3730 wxDataFormat* formats = new wxDataFormat[count];
3731 self->GetAllFormats(formats, dir);
3732
3733 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3734 PyObject* list = PyList_New(count);
3735 for (size_t i=0; i<count; i++) {
3736 wxDataFormat* format = new wxDataFormat(formats[i]);
3737 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3738 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 delete [] formats;
3742 return list;
3743 }
3744 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3745 PyObject* rval = NULL;
3746 size_t size = self->GetDataSize(format);
3747 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3748 if (size) {
3749 char* buf = new char[size];
3750 if (self->GetDataHere(format, buf))
3751 rval = PyString_FromStringAndSize(buf, size);
3752 delete [] buf;
3753 }
3754 if (! rval) {
3755 rval = Py_None;
3756 Py_INCREF(rval);
3757 }
3758 wxPyEndBlockThreads(blocked);
3759 return rval;
3760 }
3761 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3762 bool rval;
3763 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3764 if (PyString_Check(data)) {
3765 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3766 }
3767 else {
3768 // raise a TypeError if not a string
3769 PyErr_SetString(PyExc_TypeError, "String expected.");
3770 rval = false;
3771 }
3772 wxPyEndBlockThreads(blocked);
3773 return rval;
3774 }
3775 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3776 PyObject* rval = NULL;
3777 size_t size = self->GetDataSize();
3778 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3779 if (size) {
3780 char* buf = new char[size];
3781 if (self->GetDataHere(buf))
3782 rval = PyString_FromStringAndSize(buf, size);
3783 delete [] buf;
3784 }
3785 if (! rval) {
3786 rval = Py_None;
3787 Py_INCREF(rval);
3788 }
3789 wxPyEndBlockThreads(blocked);
3790 return rval;
3791 }
3792 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3793 bool rval;
3794 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3795 if (PyString_Check(data)) {
3796 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3797 }
3798 else {
3799 // raise a TypeError if not a string
3800 PyErr_SetString(PyExc_TypeError, "String expected.");
3801 rval = false;
3802 }
3803 wxPyEndBlockThreads(blocked);
3804 return rval;
3805 }
3806 // Create a new class for wxPython to use
3807 class wxPyDataObjectSimple : public wxDataObjectSimple {
3808 public:
3809 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3810 : wxDataObjectSimple(format) {}
3811
3812 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3813 bool GetDataHere(void *buf) const;
3814 bool SetData(size_t len, const void *buf);
3815 PYPRIVATE;
3816 };
3817
3818 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3819
3820 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3821 // We need to get the data for this object and write it to buf. I think
3822 // the best way to do this for wxPython is to have the Python method
3823 // return either a string or None and then act appropriately with the
3824 // C++ version.
3825
3826 bool rval = false;
3827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3828 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3829 PyObject* ro;
3830 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3831 if (ro) {
3832 rval = (ro != Py_None && PyString_Check(ro));
3833 if (rval)
3834 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3835 Py_DECREF(ro);
3836 }
3837 }
3838 wxPyEndBlockThreads(blocked);
3839 return rval;
3840 }
3841
3842 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3843 // For this one we simply need to make a string from buf and len
3844 // and send it to the Python method.
3845 bool rval = false;
3846 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3847 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3848 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3849 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3850 Py_DECREF(data);
3851 }
3852 wxPyEndBlockThreads(blocked);
3853 return rval;
3854 }
3855
3856 // Create a new class for wxPython to use
3857 class wxPyTextDataObject : public wxTextDataObject {
3858 public:
3859 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3860 : wxTextDataObject(text) {}
3861
3862 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3863 DEC_PYCALLBACK_STRING__const(GetText);
3864 DEC_PYCALLBACK__STRING(SetText);
3865 PYPRIVATE;
3866 };
3867
3868 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3869 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3870 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3871
3872
3873 // Create a new class for wxPython to use
3874 class wxPyBitmapDataObject : public wxBitmapDataObject {
3875 public:
3876 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3877 : wxBitmapDataObject(bitmap) {}
3878
3879 wxBitmap GetBitmap() const;
3880 void SetBitmap(const wxBitmap& bitmap);
3881 PYPRIVATE;
3882 };
3883
3884 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3885 wxBitmap* rval = &wxNullBitmap;
3886 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3887 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3888 PyObject* ro;
3889 wxBitmap* ptr;
3890 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3891 if (ro) {
3892 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3893 rval = ptr;
3894 Py_DECREF(ro);
3895 }
3896 }
3897 wxPyEndBlockThreads(blocked);
3898 return *rval;
3899 }
3900
3901 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3902 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3903 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3904 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3905 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3906 Py_DECREF(bo);
3907 }
3908 wxPyEndBlockThreads(blocked);
3909 }
3910
3911 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3912 return new wxCustomDataObject(wxDataFormat(formatName));
3913 }
3914 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3915 bool rval;
3916 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3917 if (PyString_Check(data)) {
3918 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3919 }
3920 else {
3921 // raise a TypeError if not a string
3922 PyErr_SetString(PyExc_TypeError, "String expected.");
3923 rval = false;
3924 }
3925 wxPyEndBlockThreads(blocked);
3926 return rval;
3927 }
3928 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3929 PyObject* obj;
3930 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3931 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3932 wxPyEndBlockThreads(blocked);
3933 return obj;
3934 }
3935
3936 #include <wx/metafile.h>
3937
3938
3939 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3940
3941
3942 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3943 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3945 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3946 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3947
3948
3949 class wxPyTextDropTarget : public wxTextDropTarget {
3950 public:
3951 wxPyTextDropTarget() {}
3952
3953 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3954
3955 DEC_PYCALLBACK__(OnLeave);
3956 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3959 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3960
3961 PYPRIVATE;
3962 };
3963
3964 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3965 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3966 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3969 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3970
3971
3972
3973 class wxPyFileDropTarget : public wxFileDropTarget {
3974 public:
3975 wxPyFileDropTarget() {}
3976
3977 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3978
3979 DEC_PYCALLBACK__(OnLeave);
3980 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3983 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3984
3985 PYPRIVATE;
3986 };
3987
3988 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3989 const wxArrayString& filenames) {
3990 bool rval = false;
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3993 PyObject* list = wxArrayString2PyList_helper(filenames);
3994 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3995 Py_DECREF(list);
3996 }
3997 wxPyEndBlockThreads(blocked);
3998 return rval;
3999 }
4000
4001
4002
4003 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4004 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4007 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4008
4009
4010
4011
4012 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4013
4014 #include <wx/display.h>
4015 #include <wx/vidmode.h>
4016
4017 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4018 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4019
4020 #if !wxUSE_DISPLAY
4021 const wxVideoMode wxDefaultVideoMode;
4022 #endif
4023
4024 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4025 #if wxUSE_DISPLAY
4026 PyObject* pyList = NULL;
4027 wxArrayVideoModes arr = self->GetModes(mode);
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 pyList = PyList_New(0);
4030 for (size_t i=0; i < arr.GetCount(); i++)
4031 {
4032 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4033 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4034 PyList_Append(pyList, pyObj);
4035 Py_DECREF(pyObj);
4036 }
4037 wxPyEndBlockThreads(blocked);
4038 return pyList;
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return NULL;
4042 #endif
4043 }
4044 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4045 #if wxUSE_DISPLAY
4046 return self->GetCurrentMode();
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return wxDefaultVideoMode;
4050 #endif
4051 }
4052 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4053 #if wxUSE_DISPLAY
4054 return self->ChangeMode(mode);
4055 #else
4056 wxPyRaiseNotImplemented();
4057 return false;
4058 #endif
4059 }
4060 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4061 #if wxUSE_DISPLAY
4062 self->ResetMode();
4063 #else
4064 wxPyRaiseNotImplemented();
4065 #endif
4066 }
4067
4068 #include <wx/stdpaths.h>
4069
4070 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4071 return (wxStandardPaths*) &wxStandardPaths::Get();
4072 }
4073 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4074 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4075
4076 #ifndef wxHAS_POWER_EVENTS
4077 // Dummy class and other definitions for platforms that don't have them
4078
4079 // See wxPython_int.h for wxPowerEvent
4080
4081 enum {
4082 wxEVT_POWER_SUSPENDING,
4083 wxEVT_POWER_SUSPENDED,
4084 wxEVT_POWER_SUSPEND_CANCEL,
4085 wxEVT_POWER_RESUME,
4086 };
4087
4088 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4089 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4090
4091 #endif
4092
4093
4094 #include <wx/aboutdlg.h>
4095
4096 #ifdef __cplusplus
4097 extern "C" {
4098 #endif
4099 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj = 0;
4101 wxSystemColour arg1 ;
4102 wxColour result;
4103 int val1 ;
4104 int ecode1 = 0 ;
4105 PyObject * obj0 = 0 ;
4106 char * kwnames[] = {
4107 (char *) "index", NULL
4108 };
4109
4110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4111 ecode1 = SWIG_AsVal_int(obj0, &val1);
4112 if (!SWIG_IsOK(ecode1)) {
4113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4114 }
4115 arg1 = static_cast< wxSystemColour >(val1);
4116 {
4117 if (!wxPyCheckForApp()) SWIG_fail;
4118 PyThreadState* __tstate = wxPyBeginAllowThreads();
4119 result = wxSystemSettings::GetColour(arg1);
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4124 return resultobj;
4125 fail:
4126 return NULL;
4127 }
4128
4129
4130 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4131 PyObject *resultobj = 0;
4132 wxSystemFont arg1 ;
4133 wxFont result;
4134 int val1 ;
4135 int ecode1 = 0 ;
4136 PyObject * obj0 = 0 ;
4137 char * kwnames[] = {
4138 (char *) "index", NULL
4139 };
4140
4141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4142 ecode1 = SWIG_AsVal_int(obj0, &val1);
4143 if (!SWIG_IsOK(ecode1)) {
4144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4145 }
4146 arg1 = static_cast< wxSystemFont >(val1);
4147 {
4148 if (!wxPyCheckForApp()) SWIG_fail;
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 result = wxSystemSettings::GetFont(arg1);
4151 wxPyEndAllowThreads(__tstate);
4152 if (PyErr_Occurred()) SWIG_fail;
4153 }
4154 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4155 return resultobj;
4156 fail:
4157 return NULL;
4158 }
4159
4160
4161 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4162 PyObject *resultobj = 0;
4163 wxSystemMetric arg1 ;
4164 wxWindow *arg2 = (wxWindow *) NULL ;
4165 int result;
4166 int val1 ;
4167 int ecode1 = 0 ;
4168 void *argp2 = 0 ;
4169 int res2 = 0 ;
4170 PyObject * obj0 = 0 ;
4171 PyObject * obj1 = 0 ;
4172 char * kwnames[] = {
4173 (char *) "index",(char *) "win", NULL
4174 };
4175
4176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4177 ecode1 = SWIG_AsVal_int(obj0, &val1);
4178 if (!SWIG_IsOK(ecode1)) {
4179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4180 }
4181 arg1 = static_cast< wxSystemMetric >(val1);
4182 if (obj1) {
4183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4184 if (!SWIG_IsOK(res2)) {
4185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4186 }
4187 arg2 = reinterpret_cast< wxWindow * >(argp2);
4188 }
4189 {
4190 if (!wxPyCheckForApp()) SWIG_fail;
4191 PyThreadState* __tstate = wxPyBeginAllowThreads();
4192 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4193 wxPyEndAllowThreads(__tstate);
4194 if (PyErr_Occurred()) SWIG_fail;
4195 }
4196 resultobj = SWIG_From_int(static_cast< int >(result));
4197 return resultobj;
4198 fail:
4199 return NULL;
4200 }
4201
4202
4203 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4204 PyObject *resultobj = 0;
4205 wxSystemFeature arg1 ;
4206 bool result;
4207 int val1 ;
4208 int ecode1 = 0 ;
4209 PyObject * obj0 = 0 ;
4210 char * kwnames[] = {
4211 (char *) "index", NULL
4212 };
4213
4214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4215 ecode1 = SWIG_AsVal_int(obj0, &val1);
4216 if (!SWIG_IsOK(ecode1)) {
4217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4218 }
4219 arg1 = static_cast< wxSystemFeature >(val1);
4220 {
4221 if (!wxPyCheckForApp()) SWIG_fail;
4222 PyThreadState* __tstate = wxPyBeginAllowThreads();
4223 result = (bool)wxSystemSettings::HasFeature(arg1);
4224 wxPyEndAllowThreads(__tstate);
4225 if (PyErr_Occurred()) SWIG_fail;
4226 }
4227 {
4228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4229 }
4230 return resultobj;
4231 fail:
4232 return NULL;
4233 }
4234
4235
4236 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4237 PyObject *resultobj = 0;
4238 wxSystemScreenType result;
4239
4240 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4241 {
4242 if (!wxPyCheckForApp()) SWIG_fail;
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4245 wxPyEndAllowThreads(__tstate);
4246 if (PyErr_Occurred()) SWIG_fail;
4247 }
4248 resultobj = SWIG_From_int(static_cast< int >(result));
4249 return resultobj;
4250 fail:
4251 return NULL;
4252 }
4253
4254
4255 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4256 PyObject *resultobj = 0;
4257 wxSystemScreenType arg1 ;
4258 int val1 ;
4259 int ecode1 = 0 ;
4260 PyObject * obj0 = 0 ;
4261 char * kwnames[] = {
4262 (char *) "screen", NULL
4263 };
4264
4265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4266 ecode1 = SWIG_AsVal_int(obj0, &val1);
4267 if (!SWIG_IsOK(ecode1)) {
4268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4269 }
4270 arg1 = static_cast< wxSystemScreenType >(val1);
4271 {
4272 if (!wxPyCheckForApp()) SWIG_fail;
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 wxSystemSettings::SetScreenType(arg1);
4275 wxPyEndAllowThreads(__tstate);
4276 if (PyErr_Occurred()) SWIG_fail;
4277 }
4278 resultobj = SWIG_Py_Void();
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4286 PyObject *obj;
4287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4288 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4289 return SWIG_Py_Void();
4290 }
4291
4292 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4293 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4294 return 1;
4295 }
4296
4297
4298 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4299 PyObject *pyobj = 0;
4300
4301 {
4302 #if wxUSE_UNICODE
4303 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4304 #else
4305 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4306 #endif
4307 }
4308 return pyobj;
4309 }
4310
4311
4312 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4313 PyObject *resultobj = 0;
4314 wxSystemOptions *result = 0 ;
4315
4316 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = (wxSystemOptions *)new wxSystemOptions();
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4331 PyObject *resultobj = 0;
4332 wxString *arg1 = 0 ;
4333 wxString *arg2 = 0 ;
4334 bool temp1 = false ;
4335 bool temp2 = false ;
4336 PyObject * obj0 = 0 ;
4337 PyObject * obj1 = 0 ;
4338 char * kwnames[] = {
4339 (char *) "name",(char *) "value", NULL
4340 };
4341
4342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4343 {
4344 arg1 = wxString_in_helper(obj0);
4345 if (arg1 == NULL) SWIG_fail;
4346 temp1 = true;
4347 }
4348 {
4349 arg2 = wxString_in_helper(obj1);
4350 if (arg2 == NULL) SWIG_fail;
4351 temp2 = true;
4352 }
4353 {
4354 PyThreadState* __tstate = wxPyBeginAllowThreads();
4355 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4356 wxPyEndAllowThreads(__tstate);
4357 if (PyErr_Occurred()) SWIG_fail;
4358 }
4359 resultobj = SWIG_Py_Void();
4360 {
4361 if (temp1)
4362 delete arg1;
4363 }
4364 {
4365 if (temp2)
4366 delete arg2;
4367 }
4368 return resultobj;
4369 fail:
4370 {
4371 if (temp1)
4372 delete arg1;
4373 }
4374 {
4375 if (temp2)
4376 delete arg2;
4377 }
4378 return NULL;
4379 }
4380
4381
4382 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj = 0;
4384 wxString *arg1 = 0 ;
4385 int arg2 ;
4386 bool temp1 = false ;
4387 int val2 ;
4388 int ecode2 = 0 ;
4389 PyObject * obj0 = 0 ;
4390 PyObject * obj1 = 0 ;
4391 char * kwnames[] = {
4392 (char *) "name",(char *) "value", NULL
4393 };
4394
4395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4396 {
4397 arg1 = wxString_in_helper(obj0);
4398 if (arg1 == NULL) SWIG_fail;
4399 temp1 = true;
4400 }
4401 ecode2 = SWIG_AsVal_int(obj1, &val2);
4402 if (!SWIG_IsOK(ecode2)) {
4403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4404 }
4405 arg2 = static_cast< int >(val2);
4406 {
4407 PyThreadState* __tstate = wxPyBeginAllowThreads();
4408 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 resultobj = SWIG_Py_Void();
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return resultobj;
4418 fail:
4419 {
4420 if (temp1)
4421 delete arg1;
4422 }
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = 0;
4429 wxString *arg1 = 0 ;
4430 wxString result;
4431 bool temp1 = false ;
4432 PyObject * obj0 = 0 ;
4433 char * kwnames[] = {
4434 (char *) "name", NULL
4435 };
4436
4437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4438 {
4439 arg1 = wxString_in_helper(obj0);
4440 if (arg1 == NULL) SWIG_fail;
4441 temp1 = true;
4442 }
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 {
4450 #if wxUSE_UNICODE
4451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4452 #else
4453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4454 #endif
4455 }
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return resultobj;
4461 fail:
4462 {
4463 if (temp1)
4464 delete arg1;
4465 }
4466 return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj = 0;
4472 wxString *arg1 = 0 ;
4473 int result;
4474 bool temp1 = false ;
4475 PyObject * obj0 = 0 ;
4476 char * kwnames[] = {
4477 (char *) "name", NULL
4478 };
4479
4480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4481 {
4482 arg1 = wxString_in_helper(obj0);
4483 if (arg1 == NULL) SWIG_fail;
4484 temp1 = true;
4485 }
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4489 wxPyEndAllowThreads(__tstate);
4490 if (PyErr_Occurred()) SWIG_fail;
4491 }
4492 resultobj = SWIG_From_int(static_cast< int >(result));
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return resultobj;
4498 fail:
4499 {
4500 if (temp1)
4501 delete arg1;
4502 }
4503 return NULL;
4504 }
4505
4506
4507 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj = 0;
4509 wxString *arg1 = 0 ;
4510 bool result;
4511 bool temp1 = false ;
4512 PyObject * obj0 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "name", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4518 {
4519 arg1 = wxString_in_helper(obj0);
4520 if (arg1 == NULL) SWIG_fail;
4521 temp1 = true;
4522 }
4523 {
4524 PyThreadState* __tstate = wxPyBeginAllowThreads();
4525 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4526 wxPyEndAllowThreads(__tstate);
4527 if (PyErr_Occurred()) SWIG_fail;
4528 }
4529 {
4530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4531 }
4532 {
4533 if (temp1)
4534 delete arg1;
4535 }
4536 return resultobj;
4537 fail:
4538 {
4539 if (temp1)
4540 delete arg1;
4541 }
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4547 PyObject *resultobj = 0;
4548 wxString *arg1 = 0 ;
4549 bool result;
4550 bool temp1 = false ;
4551 PyObject * obj0 = 0 ;
4552 char * kwnames[] = {
4553 (char *) "name", NULL
4554 };
4555
4556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4557 {
4558 arg1 = wxString_in_helper(obj0);
4559 if (arg1 == NULL) SWIG_fail;
4560 temp1 = true;
4561 }
4562 {
4563 PyThreadState* __tstate = wxPyBeginAllowThreads();
4564 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 {
4569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4570 }
4571 {
4572 if (temp1)
4573 delete arg1;
4574 }
4575 return resultobj;
4576 fail:
4577 {
4578 if (temp1)
4579 delete arg1;
4580 }
4581 return NULL;
4582 }
4583
4584
4585 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4586 PyObject *obj;
4587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4588 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4589 return SWIG_Py_Void();
4590 }
4591
4592 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4593 return SWIG_Python_InitShadowInstance(args);
4594 }
4595
4596 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4597 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4598 return 1;
4599 }
4600
4601
4602 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4603 PyObject *pyobj = 0;
4604
4605 {
4606 #if wxUSE_UNICODE
4607 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4608 #else
4609 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4610 #endif
4611 }
4612 return pyobj;
4613 }
4614
4615
4616 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4617 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4618 return 1;
4619 }
4620
4621
4622 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4623 PyObject *pyobj = 0;
4624
4625 {
4626 #if wxUSE_UNICODE
4627 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4628 #else
4629 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4630 #endif
4631 }
4632 return pyobj;
4633 }
4634
4635
4636 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4637 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4638 return 1;
4639 }
4640
4641
4642 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4643 PyObject *pyobj = 0;
4644
4645 {
4646 #if wxUSE_UNICODE
4647 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4648 #else
4649 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4650 #endif
4651 }
4652 return pyobj;
4653 }
4654
4655
4656 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4657 PyObject *resultobj = 0;
4658 long result;
4659
4660 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 result = (long)wxNewId();
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 resultobj = SWIG_From_long(static_cast< long >(result));
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj = 0;
4676 long arg1 ;
4677 long val1 ;
4678 int ecode1 = 0 ;
4679 PyObject * obj0 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "id", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4685 ecode1 = SWIG_AsVal_long(obj0, &val1);
4686 if (!SWIG_IsOK(ecode1)) {
4687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4688 }
4689 arg1 = static_cast< long >(val1);
4690 {
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 wxRegisterId(arg1);
4693 wxPyEndAllowThreads(__tstate);
4694 if (PyErr_Occurred()) SWIG_fail;
4695 }
4696 resultobj = SWIG_Py_Void();
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4704 PyObject *resultobj = 0;
4705 long result;
4706
4707 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = (long)wxGetCurrentId();
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = SWIG_From_long(static_cast< long >(result));
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4722 PyObject *resultobj = 0;
4723 int arg1 ;
4724 bool result;
4725 int val1 ;
4726 int ecode1 = 0 ;
4727 PyObject * obj0 = 0 ;
4728 char * kwnames[] = {
4729 (char *) "id", NULL
4730 };
4731
4732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4733 ecode1 = SWIG_AsVal_int(obj0, &val1);
4734 if (!SWIG_IsOK(ecode1)) {
4735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4736 }
4737 arg1 = static_cast< int >(val1);
4738 {
4739 PyThreadState* __tstate = wxPyBeginAllowThreads();
4740 result = (bool)wxIsStockID(arg1);
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 {
4745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4746 }
4747 return resultobj;
4748 fail:
4749 return NULL;
4750 }
4751
4752
4753 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj = 0;
4755 int arg1 ;
4756 wxString *arg2 = 0 ;
4757 bool result;
4758 int val1 ;
4759 int ecode1 = 0 ;
4760 bool temp2 = false ;
4761 PyObject * obj0 = 0 ;
4762 PyObject * obj1 = 0 ;
4763 char * kwnames[] = {
4764 (char *) "id",(char *) "label", NULL
4765 };
4766
4767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4768 ecode1 = SWIG_AsVal_int(obj0, &val1);
4769 if (!SWIG_IsOK(ecode1)) {
4770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4771 }
4772 arg1 = static_cast< int >(val1);
4773 {
4774 arg2 = wxString_in_helper(obj1);
4775 if (arg2 == NULL) SWIG_fail;
4776 temp2 = true;
4777 }
4778 {
4779 PyThreadState* __tstate = wxPyBeginAllowThreads();
4780 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4781 wxPyEndAllowThreads(__tstate);
4782 if (PyErr_Occurred()) SWIG_fail;
4783 }
4784 {
4785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4786 }
4787 {
4788 if (temp2)
4789 delete arg2;
4790 }
4791 return resultobj;
4792 fail:
4793 {
4794 if (temp2)
4795 delete arg2;
4796 }
4797 return NULL;
4798 }
4799
4800
4801 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4802 PyObject *resultobj = 0;
4803 int arg1 ;
4804 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4805 wxString result;
4806 int val1 ;
4807 int ecode1 = 0 ;
4808 long val2 ;
4809 int ecode2 = 0 ;
4810 PyObject * obj0 = 0 ;
4811 PyObject * obj1 = 0 ;
4812 char * kwnames[] = {
4813 (char *) "id",(char *) "flags", NULL
4814 };
4815
4816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4817 ecode1 = SWIG_AsVal_int(obj0, &val1);
4818 if (!SWIG_IsOK(ecode1)) {
4819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4820 }
4821 arg1 = static_cast< int >(val1);
4822 if (obj1) {
4823 ecode2 = SWIG_AsVal_long(obj1, &val2);
4824 if (!SWIG_IsOK(ecode2)) {
4825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4826 }
4827 arg2 = static_cast< long >(val2);
4828 }
4829 {
4830 PyThreadState* __tstate = wxPyBeginAllowThreads();
4831 result = wxGetStockLabel(arg1,arg2);
4832 wxPyEndAllowThreads(__tstate);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 {
4836 #if wxUSE_UNICODE
4837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4838 #else
4839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4840 #endif
4841 }
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 int arg1 ;
4851 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4852 wxString result;
4853 int val1 ;
4854 int ecode1 = 0 ;
4855 int val2 ;
4856 int ecode2 = 0 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 char * kwnames[] = {
4860 (char *) "id",(char *) "client", NULL
4861 };
4862
4863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4864 ecode1 = SWIG_AsVal_int(obj0, &val1);
4865 if (!SWIG_IsOK(ecode1)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4867 }
4868 arg1 = static_cast< int >(val1);
4869 if (obj1) {
4870 ecode2 = SWIG_AsVal_int(obj1, &val2);
4871 if (!SWIG_IsOK(ecode2)) {
4872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4873 }
4874 arg2 = static_cast< wxStockHelpStringClient >(val2);
4875 }
4876 {
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 result = wxGetStockHelpString(arg1,arg2);
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 {
4883 #if wxUSE_UNICODE
4884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4885 #else
4886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4887 #endif
4888 }
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4896 PyObject *resultobj = 0;
4897
4898 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4899 {
4900 if (!wxPyCheckForApp()) SWIG_fail;
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 wxBell();
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_Py_Void();
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4914 PyObject *resultobj = 0;
4915
4916 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4917 {
4918 if (!wxPyCheckForApp()) SWIG_fail;
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 wxEndBusyCursor();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 resultobj = SWIG_Py_Void();
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 bool arg1 = (bool) true ;
4934 long result;
4935 bool val1 ;
4936 int ecode1 = 0 ;
4937 PyObject * obj0 = 0 ;
4938 char * kwnames[] = {
4939 (char *) "resetTimer", NULL
4940 };
4941
4942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4943 if (obj0) {
4944 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4945 if (!SWIG_IsOK(ecode1)) {
4946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4947 }
4948 arg1 = static_cast< bool >(val1);
4949 }
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = (long)wxGetElapsedTime(arg1);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_From_long(static_cast< long >(result));
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4964 PyObject *resultobj = 0;
4965 bool result;
4966
4967 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 result = (bool)wxIsBusy();
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 {
4975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4976 }
4977 return resultobj;
4978 fail:
4979 return NULL;
4980 }
4981
4982
4983 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4984 PyObject *resultobj = 0;
4985 wxString result;
4986
4987 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 result = wxNow();
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 {
4995 #if wxUSE_UNICODE
4996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4997 #else
4998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4999 #endif
5000 }
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
5007 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5008 PyObject *resultobj = 0;
5009 wxString const &arg1_defvalue = wxPyEmptyString ;
5010 wxString *arg1 = (wxString *) &arg1_defvalue ;
5011 bool result;
5012 bool temp1 = false ;
5013 PyObject * obj0 = 0 ;
5014 char * kwnames[] = {
5015 (char *) "command", NULL
5016 };
5017
5018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5019 if (obj0) {
5020 {
5021 arg1 = wxString_in_helper(obj0);
5022 if (arg1 == NULL) SWIG_fail;
5023 temp1 = true;
5024 }
5025 }
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 result = (bool)wxShell((wxString const &)*arg1);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5034 }
5035 {
5036 if (temp1)
5037 delete arg1;
5038 }
5039 return resultobj;
5040 fail:
5041 {
5042 if (temp1)
5043 delete arg1;
5044 }
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5050 PyObject *resultobj = 0;
5051
5052 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5053 {
5054 PyThreadState* __tstate = wxPyBeginAllowThreads();
5055 wxStartTimer();
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 resultobj = SWIG_Py_Void();
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5067 PyObject *resultobj = 0;
5068 int *arg1 = (int *) 0 ;
5069 int *arg2 = (int *) 0 ;
5070 int result;
5071 int temp1 ;
5072 int res1 = SWIG_TMPOBJ ;
5073 int temp2 ;
5074 int res2 = SWIG_TMPOBJ ;
5075
5076 arg1 = &temp1;
5077 arg2 = &temp2;
5078 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5079 {
5080 PyThreadState* __tstate = wxPyBeginAllowThreads();
5081 result = (int)wxGetOsVersion(arg1,arg2);
5082 wxPyEndAllowThreads(__tstate);
5083 if (PyErr_Occurred()) SWIG_fail;
5084 }
5085 resultobj = SWIG_From_int(static_cast< int >(result));
5086 if (SWIG_IsTmpObj(res1)) {
5087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5088 } else {
5089 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5091 }
5092 if (SWIG_IsTmpObj(res2)) {
5093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5094 } else {
5095 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5097 }
5098 return resultobj;
5099 fail:
5100 return NULL;
5101 }
5102
5103
5104 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5105 PyObject *resultobj = 0;
5106 wxString result;
5107
5108 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = wxGetOsDescription();
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 {
5116 #if wxUSE_UNICODE
5117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5118 #else
5119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5120 #endif
5121 }
5122 return resultobj;
5123 fail:
5124 return NULL;
5125 }
5126
5127
5128 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5129 PyObject *resultobj = 0;
5130 bool result;
5131
5132 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (bool)wxIsPlatformLittleEndian();
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 {
5140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5141 }
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 bool result;
5151
5152 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (bool)wxIsPlatform64Bit();
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 {
5160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5161 }
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
5168 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5169 PyObject *resultobj = 0;
5170 wxMemorySize result;
5171
5172 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5173 {
5174 PyThreadState* __tstate = wxPyBeginAllowThreads();
5175 result = wxGetFreeMemory();
5176 wxPyEndAllowThreads(__tstate);
5177 if (PyErr_Occurred()) SWIG_fail;
5178 }
5179 {
5180 #if wxUSE_LONGLONG
5181 resultobj = PyLong_FromLongLong((&result)->GetValue());
5182 #else
5183 resultobj = PyInt_FromLong(result);
5184 #endif
5185 }
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj = 0;
5194 wxShutdownFlags arg1 ;
5195 bool result;
5196 int val1 ;
5197 int ecode1 = 0 ;
5198 PyObject * obj0 = 0 ;
5199 char * kwnames[] = {
5200 (char *) "wFlags", NULL
5201 };
5202
5203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5204 ecode1 = SWIG_AsVal_int(obj0, &val1);
5205 if (!SWIG_IsOK(ecode1)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5207 }
5208 arg1 = static_cast< wxShutdownFlags >(val1);
5209 {
5210 if (!wxPyCheckForApp()) SWIG_fail;
5211 PyThreadState* __tstate = wxPyBeginAllowThreads();
5212 result = (bool)wxShutdown(arg1);
5213 wxPyEndAllowThreads(__tstate);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 {
5217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5218 }
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5226 PyObject *resultobj = 0;
5227 int arg1 ;
5228 int val1 ;
5229 int ecode1 = 0 ;
5230 PyObject * obj0 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "secs", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5236 ecode1 = SWIG_AsVal_int(obj0, &val1);
5237 if (!SWIG_IsOK(ecode1)) {
5238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5239 }
5240 arg1 = static_cast< int >(val1);
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 wxSleep(arg1);
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 resultobj = SWIG_Py_Void();
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj = 0;
5256 unsigned long arg1 ;
5257 unsigned long val1 ;
5258 int ecode1 = 0 ;
5259 PyObject * obj0 = 0 ;
5260 char * kwnames[] = {
5261 (char *) "milliseconds", NULL
5262 };
5263
5264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5265 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5266 if (!SWIG_IsOK(ecode1)) {
5267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5268 }
5269 arg1 = static_cast< unsigned long >(val1);
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 wxMilliSleep(arg1);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj = 0;
5285 unsigned long arg1 ;
5286 unsigned long val1 ;
5287 int ecode1 = 0 ;
5288 PyObject * obj0 = 0 ;
5289 char * kwnames[] = {
5290 (char *) "microseconds", NULL
5291 };
5292
5293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5294 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5295 if (!SWIG_IsOK(ecode1)) {
5296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5297 }
5298 arg1 = static_cast< unsigned long >(val1);
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 wxMicroSleep(arg1);
5302 wxPyEndAllowThreads(__tstate);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5313 PyObject *resultobj = 0;
5314 bool arg1 ;
5315 bool val1 ;
5316 int ecode1 = 0 ;
5317 PyObject * obj0 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "enable", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5323 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5324 if (!SWIG_IsOK(ecode1)) {
5325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5326 }
5327 arg1 = static_cast< bool >(val1);
5328 {
5329 PyThreadState* __tstate = wxPyBeginAllowThreads();
5330 wxEnableTopLevelWindows(arg1);
5331 wxPyEndAllowThreads(__tstate);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 resultobj = SWIG_Py_Void();
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5342 PyObject *resultobj = 0;
5343 wxString *arg1 = 0 ;
5344 wxString result;
5345 bool temp1 = false ;
5346 PyObject * obj0 = 0 ;
5347 char * kwnames[] = {
5348 (char *) "in", NULL
5349 };
5350
5351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5352 {
5353 arg1 = wxString_in_helper(obj0);
5354 if (arg1 == NULL) SWIG_fail;
5355 temp1 = true;
5356 }
5357 {
5358 PyThreadState* __tstate = wxPyBeginAllowThreads();
5359 result = wxStripMenuCodes((wxString const &)*arg1);
5360 wxPyEndAllowThreads(__tstate);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 #if wxUSE_UNICODE
5365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5366 #else
5367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5368 #endif
5369 }
5370 {
5371 if (temp1)
5372 delete arg1;
5373 }
5374 return resultobj;
5375 fail:
5376 {
5377 if (temp1)
5378 delete arg1;
5379 }
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxString result;
5387
5388 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = wxGetEmailAddress();
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 {
5396 #if wxUSE_UNICODE
5397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5398 #else
5399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5400 #endif
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5409 PyObject *resultobj = 0;
5410 wxString result;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5413 {
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 result = wxGetHostName();
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 #if wxUSE_UNICODE
5421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5422 #else
5423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5424 #endif
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxString result;
5435
5436 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = wxGetFullHostName();
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 {
5444 #if wxUSE_UNICODE
5445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5446 #else
5447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5448 #endif
5449 }
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5457 PyObject *resultobj = 0;
5458 wxString result;
5459
5460 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5461 {
5462 PyThreadState* __tstate = wxPyBeginAllowThreads();
5463 result = wxGetUserId();
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 {
5468 #if wxUSE_UNICODE
5469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5470 #else
5471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5472 #endif
5473 }
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482 wxString result;
5483
5484 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = wxGetUserName();
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 #if wxUSE_UNICODE
5493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5494 #else
5495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5496 #endif
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxString result;
5507
5508 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5509 {
5510 PyThreadState* __tstate = wxPyBeginAllowThreads();
5511 result = wxGetHomeDir();
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 #if wxUSE_UNICODE
5517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5518 #else
5519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5520 #endif
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj = 0;
5530 wxString const &arg1_defvalue = wxPyEmptyString ;
5531 wxString *arg1 = (wxString *) &arg1_defvalue ;
5532 wxString result;
5533 bool temp1 = false ;
5534 PyObject * obj0 = 0 ;
5535 char * kwnames[] = {
5536 (char *) "user", NULL
5537 };
5538
5539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5540 if (obj0) {
5541 {
5542 arg1 = wxString_in_helper(obj0);
5543 if (arg1 == NULL) SWIG_fail;
5544 temp1 = true;
5545 }
5546 }
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 result = wxGetUserHome((wxString const &)*arg1);
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 #if wxUSE_UNICODE
5555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5556 #else
5557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5558 #endif
5559 }
5560 {
5561 if (temp1)
5562 delete arg1;
5563 }
5564 return resultobj;
5565 fail:
5566 {
5567 if (temp1)
5568 delete arg1;
5569 }
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *resultobj = 0;
5576 unsigned long result;
5577
5578 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (unsigned long)wxGetProcessId();
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *resultobj = 0;
5594
5595 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5596 {
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 wxTrap();
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 resultobj = SWIG_Py_Void();
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj = 0;
5611 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5612 wxString *arg1 = (wxString *) &arg1_defvalue ;
5613 wxString const &arg2_defvalue = wxPyEmptyString ;
5614 wxString *arg2 = (wxString *) &arg2_defvalue ;
5615 wxString const &arg3_defvalue = wxPyEmptyString ;
5616 wxString *arg3 = (wxString *) &arg3_defvalue ;
5617 wxString const &arg4_defvalue = wxPyEmptyString ;
5618 wxString *arg4 = (wxString *) &arg4_defvalue ;
5619 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5620 wxString *arg5 = (wxString *) &arg5_defvalue ;
5621 int arg6 = (int) 0 ;
5622 wxWindow *arg7 = (wxWindow *) NULL ;
5623 int arg8 = (int) -1 ;
5624 int arg9 = (int) -1 ;
5625 wxString result;
5626 bool temp1 = false ;
5627 bool temp2 = false ;
5628 bool temp3 = false ;
5629 bool temp4 = false ;
5630 bool temp5 = false ;
5631 int val6 ;
5632 int ecode6 = 0 ;
5633 void *argp7 = 0 ;
5634 int res7 = 0 ;
5635 int val8 ;
5636 int ecode8 = 0 ;
5637 int val9 ;
5638 int ecode9 = 0 ;
5639 PyObject * obj0 = 0 ;
5640 PyObject * obj1 = 0 ;
5641 PyObject * obj2 = 0 ;
5642 PyObject * obj3 = 0 ;
5643 PyObject * obj4 = 0 ;
5644 PyObject * obj5 = 0 ;
5645 PyObject * obj6 = 0 ;
5646 PyObject * obj7 = 0 ;
5647 PyObject * obj8 = 0 ;
5648 char * kwnames[] = {
5649 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5650 };
5651
5652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5653 if (obj0) {
5654 {
5655 arg1 = wxString_in_helper(obj0);
5656 if (arg1 == NULL) SWIG_fail;
5657 temp1 = true;
5658 }
5659 }
5660 if (obj1) {
5661 {
5662 arg2 = wxString_in_helper(obj1);
5663 if (arg2 == NULL) SWIG_fail;
5664 temp2 = true;
5665 }
5666 }
5667 if (obj2) {
5668 {
5669 arg3 = wxString_in_helper(obj2);
5670 if (arg3 == NULL) SWIG_fail;
5671 temp3 = true;
5672 }
5673 }
5674 if (obj3) {
5675 {
5676 arg4 = wxString_in_helper(obj3);
5677 if (arg4 == NULL) SWIG_fail;
5678 temp4 = true;
5679 }
5680 }
5681 if (obj4) {
5682 {
5683 arg5 = wxString_in_helper(obj4);
5684 if (arg5 == NULL) SWIG_fail;
5685 temp5 = true;
5686 }
5687 }
5688 if (obj5) {
5689 ecode6 = SWIG_AsVal_int(obj5, &val6);
5690 if (!SWIG_IsOK(ecode6)) {
5691 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5692 }
5693 arg6 = static_cast< int >(val6);
5694 }
5695 if (obj6) {
5696 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5697 if (!SWIG_IsOK(res7)) {
5698 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5699 }
5700 arg7 = reinterpret_cast< wxWindow * >(argp7);
5701 }
5702 if (obj7) {
5703 ecode8 = SWIG_AsVal_int(obj7, &val8);
5704 if (!SWIG_IsOK(ecode8)) {
5705 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5706 }
5707 arg8 = static_cast< int >(val8);
5708 }
5709 if (obj8) {
5710 ecode9 = SWIG_AsVal_int(obj8, &val9);
5711 if (!SWIG_IsOK(ecode9)) {
5712 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5713 }
5714 arg9 = static_cast< int >(val9);
5715 }
5716 {
5717 if (!wxPyCheckForApp()) SWIG_fail;
5718 PyThreadState* __tstate = wxPyBeginAllowThreads();
5719 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5720 wxPyEndAllowThreads(__tstate);
5721 if (PyErr_Occurred()) SWIG_fail;
5722 }
5723 {
5724 #if wxUSE_UNICODE
5725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5726 #else
5727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5728 #endif
5729 }
5730 {
5731 if (temp1)
5732 delete arg1;
5733 }
5734 {
5735 if (temp2)
5736 delete arg2;
5737 }
5738 {
5739 if (temp3)
5740 delete arg3;
5741 }
5742 {
5743 if (temp4)
5744 delete arg4;
5745 }
5746 {
5747 if (temp5)
5748 delete arg5;
5749 }
5750 return resultobj;
5751 fail:
5752 {
5753 if (temp1)
5754 delete arg1;
5755 }
5756 {
5757 if (temp2)
5758 delete arg2;
5759 }
5760 {
5761 if (temp3)
5762 delete arg3;
5763 }
5764 {
5765 if (temp4)
5766 delete arg4;
5767 }
5768 {
5769 if (temp5)
5770 delete arg5;
5771 }
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 wxString *arg1 = 0 ;
5779 wxString *arg2 = 0 ;
5780 wxString const &arg3_defvalue = wxPyEmptyString ;
5781 wxString *arg3 = (wxString *) &arg3_defvalue ;
5782 wxWindow *arg4 = (wxWindow *) NULL ;
5783 wxString result;
5784 bool temp1 = false ;
5785 bool temp2 = false ;
5786 bool temp3 = false ;
5787 void *argp4 = 0 ;
5788 int res4 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 PyObject * obj3 = 0 ;
5793 char * kwnames[] = {
5794 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5795 };
5796
5797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5798 {
5799 arg1 = wxString_in_helper(obj0);
5800 if (arg1 == NULL) SWIG_fail;
5801 temp1 = true;
5802 }
5803 {
5804 arg2 = wxString_in_helper(obj1);
5805 if (arg2 == NULL) SWIG_fail;
5806 temp2 = true;
5807 }
5808 if (obj2) {
5809 {
5810 arg3 = wxString_in_helper(obj2);
5811 if (arg3 == NULL) SWIG_fail;
5812 temp3 = true;
5813 }
5814 }
5815 if (obj3) {
5816 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5817 if (!SWIG_IsOK(res4)) {
5818 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5819 }
5820 arg4 = reinterpret_cast< wxWindow * >(argp4);
5821 }
5822 {
5823 if (!wxPyCheckForApp()) SWIG_fail;
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5826 wxPyEndAllowThreads(__tstate);
5827 if (PyErr_Occurred()) SWIG_fail;
5828 }
5829 {
5830 #if wxUSE_UNICODE
5831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5832 #else
5833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5834 #endif
5835 }
5836 {
5837 if (temp1)
5838 delete arg1;
5839 }
5840 {
5841 if (temp2)
5842 delete arg2;
5843 }
5844 {
5845 if (temp3)
5846 delete arg3;
5847 }
5848 return resultobj;
5849 fail:
5850 {
5851 if (temp1)
5852 delete arg1;
5853 }
5854 {
5855 if (temp2)
5856 delete arg2;
5857 }
5858 {
5859 if (temp3)
5860 delete arg3;
5861 }
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj = 0;
5868 wxString *arg1 = 0 ;
5869 wxString *arg2 = 0 ;
5870 wxString const &arg3_defvalue = wxPyEmptyString ;
5871 wxString *arg3 = (wxString *) &arg3_defvalue ;
5872 wxWindow *arg4 = (wxWindow *) NULL ;
5873 wxString result;
5874 bool temp1 = false ;
5875 bool temp2 = false ;
5876 bool temp3 = false ;
5877 void *argp4 = 0 ;
5878 int res4 = 0 ;
5879 PyObject * obj0 = 0 ;
5880 PyObject * obj1 = 0 ;
5881 PyObject * obj2 = 0 ;
5882 PyObject * obj3 = 0 ;
5883 char * kwnames[] = {
5884 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5885 };
5886
5887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5888 {
5889 arg1 = wxString_in_helper(obj0);
5890 if (arg1 == NULL) SWIG_fail;
5891 temp1 = true;
5892 }
5893 {
5894 arg2 = wxString_in_helper(obj1);
5895 if (arg2 == NULL) SWIG_fail;
5896 temp2 = true;
5897 }
5898 if (obj2) {
5899 {
5900 arg3 = wxString_in_helper(obj2);
5901 if (arg3 == NULL) SWIG_fail;
5902 temp3 = true;
5903 }
5904 }
5905 if (obj3) {
5906 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5907 if (!SWIG_IsOK(res4)) {
5908 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5909 }
5910 arg4 = reinterpret_cast< wxWindow * >(argp4);
5911 }
5912 {
5913 if (!wxPyCheckForApp()) SWIG_fail;
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 {
5920 #if wxUSE_UNICODE
5921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5922 #else
5923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5924 #endif
5925 }
5926 {
5927 if (temp1)
5928 delete arg1;
5929 }
5930 {
5931 if (temp2)
5932 delete arg2;
5933 }
5934 {
5935 if (temp3)
5936 delete arg3;
5937 }
5938 return resultobj;
5939 fail:
5940 {
5941 if (temp1)
5942 delete arg1;
5943 }
5944 {
5945 if (temp2)
5946 delete arg2;
5947 }
5948 {
5949 if (temp3)
5950 delete arg3;
5951 }
5952 return NULL;
5953 }
5954
5955
5956 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5957 PyObject *resultobj = 0;
5958 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5959 wxString *arg1 = (wxString *) &arg1_defvalue ;
5960 wxString const &arg2_defvalue = wxPyEmptyString ;
5961 wxString *arg2 = (wxString *) &arg2_defvalue ;
5962 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5963 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5964 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5965 wxWindow *arg5 = (wxWindow *) NULL ;
5966 wxString result;
5967 bool temp1 = false ;
5968 bool temp2 = false ;
5969 long val3 ;
5970 int ecode3 = 0 ;
5971 wxPoint temp4 ;
5972 void *argp5 = 0 ;
5973 int res5 = 0 ;
5974 PyObject * obj0 = 0 ;
5975 PyObject * obj1 = 0 ;
5976 PyObject * obj2 = 0 ;
5977 PyObject * obj3 = 0 ;
5978 PyObject * obj4 = 0 ;
5979 char * kwnames[] = {
5980 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5981 };
5982
5983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5984 if (obj0) {
5985 {
5986 arg1 = wxString_in_helper(obj0);
5987 if (arg1 == NULL) SWIG_fail;
5988 temp1 = true;
5989 }
5990 }
5991 if (obj1) {
5992 {
5993 arg2 = wxString_in_helper(obj1);
5994 if (arg2 == NULL) SWIG_fail;
5995 temp2 = true;
5996 }
5997 }
5998 if (obj2) {
5999 ecode3 = SWIG_AsVal_long(obj2, &val3);
6000 if (!SWIG_IsOK(ecode3)) {
6001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6002 }
6003 arg3 = static_cast< long >(val3);
6004 }
6005 if (obj3) {
6006 {
6007 arg4 = &temp4;
6008 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6009 }
6010 }
6011 if (obj4) {
6012 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6013 if (!SWIG_IsOK(res5)) {
6014 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6015 }
6016 arg5 = reinterpret_cast< wxWindow * >(argp5);
6017 }
6018 {
6019 if (!wxPyCheckForApp()) SWIG_fail;
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 {
6026 #if wxUSE_UNICODE
6027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6028 #else
6029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6030 #endif
6031 }
6032 {
6033 if (temp1)
6034 delete arg1;
6035 }
6036 {
6037 if (temp2)
6038 delete arg2;
6039 }
6040 return resultobj;
6041 fail:
6042 {
6043 if (temp1)
6044 delete arg1;
6045 }
6046 {
6047 if (temp2)
6048 delete arg2;
6049 }
6050 return NULL;
6051 }
6052
6053
6054 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj = 0;
6056 wxString *arg1 = 0 ;
6057 wxString const &arg2_defvalue = wxPyEmptyString ;
6058 wxString *arg2 = (wxString *) &arg2_defvalue ;
6059 wxString const &arg3_defvalue = wxPyEmptyString ;
6060 wxString *arg3 = (wxString *) &arg3_defvalue ;
6061 wxWindow *arg4 = (wxWindow *) NULL ;
6062 int arg5 = (int) -1 ;
6063 int arg6 = (int) -1 ;
6064 bool arg7 = (bool) true ;
6065 wxString result;
6066 bool temp1 = false ;
6067 bool temp2 = false ;
6068 bool temp3 = false ;
6069 void *argp4 = 0 ;
6070 int res4 = 0 ;
6071 int val5 ;
6072 int ecode5 = 0 ;
6073 int val6 ;
6074 int ecode6 = 0 ;
6075 bool val7 ;
6076 int ecode7 = 0 ;
6077 PyObject * obj0 = 0 ;
6078 PyObject * obj1 = 0 ;
6079 PyObject * obj2 = 0 ;
6080 PyObject * obj3 = 0 ;
6081 PyObject * obj4 = 0 ;
6082 PyObject * obj5 = 0 ;
6083 PyObject * obj6 = 0 ;
6084 char * kwnames[] = {
6085 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6086 };
6087
6088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6089 {
6090 arg1 = wxString_in_helper(obj0);
6091 if (arg1 == NULL) SWIG_fail;
6092 temp1 = true;
6093 }
6094 if (obj1) {
6095 {
6096 arg2 = wxString_in_helper(obj1);
6097 if (arg2 == NULL) SWIG_fail;
6098 temp2 = true;
6099 }
6100 }
6101 if (obj2) {
6102 {
6103 arg3 = wxString_in_helper(obj2);
6104 if (arg3 == NULL) SWIG_fail;
6105 temp3 = true;
6106 }
6107 }
6108 if (obj3) {
6109 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6110 if (!SWIG_IsOK(res4)) {
6111 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6112 }
6113 arg4 = reinterpret_cast< wxWindow * >(argp4);
6114 }
6115 if (obj4) {
6116 ecode5 = SWIG_AsVal_int(obj4, &val5);
6117 if (!SWIG_IsOK(ecode5)) {
6118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6119 }
6120 arg5 = static_cast< int >(val5);
6121 }
6122 if (obj5) {
6123 ecode6 = SWIG_AsVal_int(obj5, &val6);
6124 if (!SWIG_IsOK(ecode6)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6126 }
6127 arg6 = static_cast< int >(val6);
6128 }
6129 if (obj6) {
6130 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6131 if (!SWIG_IsOK(ecode7)) {
6132 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6133 }
6134 arg7 = static_cast< bool >(val7);
6135 }
6136 {
6137 if (!wxPyCheckForApp()) SWIG_fail;
6138 PyThreadState* __tstate = wxPyBeginAllowThreads();
6139 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6140 wxPyEndAllowThreads(__tstate);
6141 if (PyErr_Occurred()) SWIG_fail;
6142 }
6143 {
6144 #if wxUSE_UNICODE
6145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6146 #else
6147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6148 #endif
6149 }
6150 {
6151 if (temp1)
6152 delete arg1;
6153 }
6154 {
6155 if (temp2)
6156 delete arg2;
6157 }
6158 {
6159 if (temp3)
6160 delete arg3;
6161 }
6162 return resultobj;
6163 fail:
6164 {
6165 if (temp1)
6166 delete arg1;
6167 }
6168 {
6169 if (temp2)
6170 delete arg2;
6171 }
6172 {
6173 if (temp3)
6174 delete arg3;
6175 }
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj = 0;
6182 wxString *arg1 = 0 ;
6183 wxString const &arg2_defvalue = wxPyEmptyString ;
6184 wxString *arg2 = (wxString *) &arg2_defvalue ;
6185 wxString const &arg3_defvalue = wxPyEmptyString ;
6186 wxString *arg3 = (wxString *) &arg3_defvalue ;
6187 wxWindow *arg4 = (wxWindow *) NULL ;
6188 wxString result;
6189 bool temp1 = false ;
6190 bool temp2 = false ;
6191 bool temp3 = false ;
6192 void *argp4 = 0 ;
6193 int res4 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 PyObject * obj2 = 0 ;
6197 PyObject * obj3 = 0 ;
6198 char * kwnames[] = {
6199 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6200 };
6201
6202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6203 {
6204 arg1 = wxString_in_helper(obj0);
6205 if (arg1 == NULL) SWIG_fail;
6206 temp1 = true;
6207 }
6208 if (obj1) {
6209 {
6210 arg2 = wxString_in_helper(obj1);
6211 if (arg2 == NULL) SWIG_fail;
6212 temp2 = true;
6213 }
6214 }
6215 if (obj2) {
6216 {
6217 arg3 = wxString_in_helper(obj2);
6218 if (arg3 == NULL) SWIG_fail;
6219 temp3 = true;
6220 }
6221 }
6222 if (obj3) {
6223 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6224 if (!SWIG_IsOK(res4)) {
6225 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6226 }
6227 arg4 = reinterpret_cast< wxWindow * >(argp4);
6228 }
6229 {
6230 if (!wxPyCheckForApp()) SWIG_fail;
6231 PyThreadState* __tstate = wxPyBeginAllowThreads();
6232 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 {
6237 #if wxUSE_UNICODE
6238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6239 #else
6240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6241 #endif
6242 }
6243 {
6244 if (temp1)
6245 delete arg1;
6246 }
6247 {
6248 if (temp2)
6249 delete arg2;
6250 }
6251 {
6252 if (temp3)
6253 delete arg3;
6254 }
6255 return resultobj;
6256 fail:
6257 {
6258 if (temp1)
6259 delete arg1;
6260 }
6261 {
6262 if (temp2)
6263 delete arg2;
6264 }
6265 {
6266 if (temp3)
6267 delete arg3;
6268 }
6269 return NULL;
6270 }
6271
6272
6273 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj = 0;
6275 wxString *arg1 = 0 ;
6276 wxString *arg2 = 0 ;
6277 int arg3 ;
6278 wxString *arg4 = (wxString *) 0 ;
6279 wxWindow *arg5 = (wxWindow *) NULL ;
6280 int arg6 = (int) -1 ;
6281 int arg7 = (int) -1 ;
6282 bool arg8 = (bool) true ;
6283 int arg9 = (int) 150 ;
6284 int arg10 = (int) 200 ;
6285 wxString result;
6286 bool temp1 = false ;
6287 bool temp2 = false ;
6288 void *argp5 = 0 ;
6289 int res5 = 0 ;
6290 int val6 ;
6291 int ecode6 = 0 ;
6292 int val7 ;
6293 int ecode7 = 0 ;
6294 bool val8 ;
6295 int ecode8 = 0 ;
6296 int val9 ;
6297 int ecode9 = 0 ;
6298 int val10 ;
6299 int ecode10 = 0 ;
6300 PyObject * obj0 = 0 ;
6301 PyObject * obj1 = 0 ;
6302 PyObject * obj2 = 0 ;
6303 PyObject * obj3 = 0 ;
6304 PyObject * obj4 = 0 ;
6305 PyObject * obj5 = 0 ;
6306 PyObject * obj6 = 0 ;
6307 PyObject * obj7 = 0 ;
6308 PyObject * obj8 = 0 ;
6309 char * kwnames[] = {
6310 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6311 };
6312
6313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6314 {
6315 arg1 = wxString_in_helper(obj0);
6316 if (arg1 == NULL) SWIG_fail;
6317 temp1 = true;
6318 }
6319 {
6320 arg2 = wxString_in_helper(obj1);
6321 if (arg2 == NULL) SWIG_fail;
6322 temp2 = true;
6323 }
6324 {
6325 arg3 = PyList_Size(obj2);
6326 arg4 = wxString_LIST_helper(obj2);
6327 if (arg4 == NULL) SWIG_fail;
6328 }
6329 if (obj3) {
6330 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6331 if (!SWIG_IsOK(res5)) {
6332 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6333 }
6334 arg5 = reinterpret_cast< wxWindow * >(argp5);
6335 }
6336 if (obj4) {
6337 ecode6 = SWIG_AsVal_int(obj4, &val6);
6338 if (!SWIG_IsOK(ecode6)) {
6339 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6340 }
6341 arg6 = static_cast< int >(val6);
6342 }
6343 if (obj5) {
6344 ecode7 = SWIG_AsVal_int(obj5, &val7);
6345 if (!SWIG_IsOK(ecode7)) {
6346 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6347 }
6348 arg7 = static_cast< int >(val7);
6349 }
6350 if (obj6) {
6351 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6352 if (!SWIG_IsOK(ecode8)) {
6353 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6354 }
6355 arg8 = static_cast< bool >(val8);
6356 }
6357 if (obj7) {
6358 ecode9 = SWIG_AsVal_int(obj7, &val9);
6359 if (!SWIG_IsOK(ecode9)) {
6360 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6361 }
6362 arg9 = static_cast< int >(val9);
6363 }
6364 if (obj8) {
6365 ecode10 = SWIG_AsVal_int(obj8, &val10);
6366 if (!SWIG_IsOK(ecode10)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6368 }
6369 arg10 = static_cast< int >(val10);
6370 }
6371 {
6372 if (!wxPyCheckForApp()) SWIG_fail;
6373 PyThreadState* __tstate = wxPyBeginAllowThreads();
6374 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 {
6379 #if wxUSE_UNICODE
6380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6381 #else
6382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6383 #endif
6384 }
6385 {
6386 if (temp1)
6387 delete arg1;
6388 }
6389 {
6390 if (temp2)
6391 delete arg2;
6392 }
6393 {
6394 if (arg4) delete [] arg4;
6395 }
6396 return resultobj;
6397 fail:
6398 {
6399 if (temp1)
6400 delete arg1;
6401 }
6402 {
6403 if (temp2)
6404 delete arg2;
6405 }
6406 {
6407 if (arg4) delete [] arg4;
6408 }
6409 return NULL;
6410 }
6411
6412
6413 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj = 0;
6415 wxString *arg1 = 0 ;
6416 wxString *arg2 = 0 ;
6417 int arg3 ;
6418 wxString *arg4 = (wxString *) 0 ;
6419 wxWindow *arg5 = (wxWindow *) NULL ;
6420 int arg6 = (int) -1 ;
6421 int arg7 = (int) -1 ;
6422 bool arg8 = (bool) true ;
6423 int arg9 = (int) 150 ;
6424 int arg10 = (int) 200 ;
6425 int result;
6426 bool temp1 = false ;
6427 bool temp2 = false ;
6428 void *argp5 = 0 ;
6429 int res5 = 0 ;
6430 int val6 ;
6431 int ecode6 = 0 ;
6432 int val7 ;
6433 int ecode7 = 0 ;
6434 bool val8 ;
6435 int ecode8 = 0 ;
6436 int val9 ;
6437 int ecode9 = 0 ;
6438 int val10 ;
6439 int ecode10 = 0 ;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 PyObject * obj2 = 0 ;
6443 PyObject * obj3 = 0 ;
6444 PyObject * obj4 = 0 ;
6445 PyObject * obj5 = 0 ;
6446 PyObject * obj6 = 0 ;
6447 PyObject * obj7 = 0 ;
6448 PyObject * obj8 = 0 ;
6449 char * kwnames[] = {
6450 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6451 };
6452
6453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6454 {
6455 arg1 = wxString_in_helper(obj0);
6456 if (arg1 == NULL) SWIG_fail;
6457 temp1 = true;
6458 }
6459 {
6460 arg2 = wxString_in_helper(obj1);
6461 if (arg2 == NULL) SWIG_fail;
6462 temp2 = true;
6463 }
6464 {
6465 arg3 = PyList_Size(obj2);
6466 arg4 = wxString_LIST_helper(obj2);
6467 if (arg4 == NULL) SWIG_fail;
6468 }
6469 if (obj3) {
6470 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6471 if (!SWIG_IsOK(res5)) {
6472 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6473 }
6474 arg5 = reinterpret_cast< wxWindow * >(argp5);
6475 }
6476 if (obj4) {
6477 ecode6 = SWIG_AsVal_int(obj4, &val6);
6478 if (!SWIG_IsOK(ecode6)) {
6479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6480 }
6481 arg6 = static_cast< int >(val6);
6482 }
6483 if (obj5) {
6484 ecode7 = SWIG_AsVal_int(obj5, &val7);
6485 if (!SWIG_IsOK(ecode7)) {
6486 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6487 }
6488 arg7 = static_cast< int >(val7);
6489 }
6490 if (obj6) {
6491 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6492 if (!SWIG_IsOK(ecode8)) {
6493 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6494 }
6495 arg8 = static_cast< bool >(val8);
6496 }
6497 if (obj7) {
6498 ecode9 = SWIG_AsVal_int(obj7, &val9);
6499 if (!SWIG_IsOK(ecode9)) {
6500 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6501 }
6502 arg9 = static_cast< int >(val9);
6503 }
6504 if (obj8) {
6505 ecode10 = SWIG_AsVal_int(obj8, &val10);
6506 if (!SWIG_IsOK(ecode10)) {
6507 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6508 }
6509 arg10 = static_cast< int >(val10);
6510 }
6511 {
6512 if (!wxPyCheckForApp()) SWIG_fail;
6513 PyThreadState* __tstate = wxPyBeginAllowThreads();
6514 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 resultobj = SWIG_From_int(static_cast< int >(result));
6519 {
6520 if (temp1)
6521 delete arg1;
6522 }
6523 {
6524 if (temp2)
6525 delete arg2;
6526 }
6527 {
6528 if (arg4) delete [] arg4;
6529 }
6530 return resultobj;
6531 fail:
6532 {
6533 if (temp1)
6534 delete arg1;
6535 }
6536 {
6537 if (temp2)
6538 delete arg2;
6539 }
6540 {
6541 if (arg4) delete [] arg4;
6542 }
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj = 0;
6549 wxString *arg1 = 0 ;
6550 wxString const &arg2_defvalue = wxPyEmptyString ;
6551 wxString *arg2 = (wxString *) &arg2_defvalue ;
6552 int arg3 = (int) wxOK|wxCENTRE ;
6553 wxWindow *arg4 = (wxWindow *) NULL ;
6554 int arg5 = (int) -1 ;
6555 int arg6 = (int) -1 ;
6556 int result;
6557 bool temp1 = false ;
6558 bool temp2 = false ;
6559 int val3 ;
6560 int ecode3 = 0 ;
6561 void *argp4 = 0 ;
6562 int res4 = 0 ;
6563 int val5 ;
6564 int ecode5 = 0 ;
6565 int val6 ;
6566 int ecode6 = 0 ;
6567 PyObject * obj0 = 0 ;
6568 PyObject * obj1 = 0 ;
6569 PyObject * obj2 = 0 ;
6570 PyObject * obj3 = 0 ;
6571 PyObject * obj4 = 0 ;
6572 PyObject * obj5 = 0 ;
6573 char * kwnames[] = {
6574 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6575 };
6576
6577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6578 {
6579 arg1 = wxString_in_helper(obj0);
6580 if (arg1 == NULL) SWIG_fail;
6581 temp1 = true;
6582 }
6583 if (obj1) {
6584 {
6585 arg2 = wxString_in_helper(obj1);
6586 if (arg2 == NULL) SWIG_fail;
6587 temp2 = true;
6588 }
6589 }
6590 if (obj2) {
6591 ecode3 = SWIG_AsVal_int(obj2, &val3);
6592 if (!SWIG_IsOK(ecode3)) {
6593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6594 }
6595 arg3 = static_cast< int >(val3);
6596 }
6597 if (obj3) {
6598 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6599 if (!SWIG_IsOK(res4)) {
6600 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6601 }
6602 arg4 = reinterpret_cast< wxWindow * >(argp4);
6603 }
6604 if (obj4) {
6605 ecode5 = SWIG_AsVal_int(obj4, &val5);
6606 if (!SWIG_IsOK(ecode5)) {
6607 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6608 }
6609 arg5 = static_cast< int >(val5);
6610 }
6611 if (obj5) {
6612 ecode6 = SWIG_AsVal_int(obj5, &val6);
6613 if (!SWIG_IsOK(ecode6)) {
6614 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6615 }
6616 arg6 = static_cast< int >(val6);
6617 }
6618 {
6619 if (!wxPyCheckForApp()) SWIG_fail;
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_From_int(static_cast< int >(result));
6626 {
6627 if (temp1)
6628 delete arg1;
6629 }
6630 {
6631 if (temp2)
6632 delete arg2;
6633 }
6634 return resultobj;
6635 fail:
6636 {
6637 if (temp1)
6638 delete arg1;
6639 }
6640 {
6641 if (temp2)
6642 delete arg2;
6643 }
6644 return NULL;
6645 }
6646
6647
6648 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj = 0;
6650 wxString *arg1 = 0 ;
6651 wxString *arg2 = 0 ;
6652 wxString *arg3 = 0 ;
6653 long arg4 ;
6654 long arg5 = (long) 0 ;
6655 long arg6 = (long) 100 ;
6656 wxWindow *arg7 = (wxWindow *) NULL ;
6657 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6658 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6659 long result;
6660 bool temp1 = false ;
6661 bool temp2 = false ;
6662 bool temp3 = false ;
6663 long val4 ;
6664 int ecode4 = 0 ;
6665 long val5 ;
6666 int ecode5 = 0 ;
6667 long val6 ;
6668 int ecode6 = 0 ;
6669 void *argp7 = 0 ;
6670 int res7 = 0 ;
6671 wxPoint temp8 ;
6672 PyObject * obj0 = 0 ;
6673 PyObject * obj1 = 0 ;
6674 PyObject * obj2 = 0 ;
6675 PyObject * obj3 = 0 ;
6676 PyObject * obj4 = 0 ;
6677 PyObject * obj5 = 0 ;
6678 PyObject * obj6 = 0 ;
6679 PyObject * obj7 = 0 ;
6680 char * kwnames[] = {
6681 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6682 };
6683
6684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6685 {
6686 arg1 = wxString_in_helper(obj0);
6687 if (arg1 == NULL) SWIG_fail;
6688 temp1 = true;
6689 }
6690 {
6691 arg2 = wxString_in_helper(obj1);
6692 if (arg2 == NULL) SWIG_fail;
6693 temp2 = true;
6694 }
6695 {
6696 arg3 = wxString_in_helper(obj2);
6697 if (arg3 == NULL) SWIG_fail;
6698 temp3 = true;
6699 }
6700 ecode4 = SWIG_AsVal_long(obj3, &val4);
6701 if (!SWIG_IsOK(ecode4)) {
6702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6703 }
6704 arg4 = static_cast< long >(val4);
6705 if (obj4) {
6706 ecode5 = SWIG_AsVal_long(obj4, &val5);
6707 if (!SWIG_IsOK(ecode5)) {
6708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6709 }
6710 arg5 = static_cast< long >(val5);
6711 }
6712 if (obj5) {
6713 ecode6 = SWIG_AsVal_long(obj5, &val6);
6714 if (!SWIG_IsOK(ecode6)) {
6715 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6716 }
6717 arg6 = static_cast< long >(val6);
6718 }
6719 if (obj6) {
6720 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6721 if (!SWIG_IsOK(res7)) {
6722 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6723 }
6724 arg7 = reinterpret_cast< wxWindow * >(argp7);
6725 }
6726 if (obj7) {
6727 {
6728 arg8 = &temp8;
6729 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6730 }
6731 }
6732 {
6733 if (!wxPyCheckForApp()) SWIG_fail;
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 resultobj = SWIG_From_long(static_cast< long >(result));
6740 {
6741 if (temp1)
6742 delete arg1;
6743 }
6744 {
6745 if (temp2)
6746 delete arg2;
6747 }
6748 {
6749 if (temp3)
6750 delete arg3;
6751 }
6752 return resultobj;
6753 fail:
6754 {
6755 if (temp1)
6756 delete arg1;
6757 }
6758 {
6759 if (temp2)
6760 delete arg2;
6761 }
6762 {
6763 if (temp3)
6764 delete arg3;
6765 }
6766 return NULL;
6767 }
6768
6769
6770 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 PyObject *resultobj = 0;
6772 bool result;
6773
6774 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6775 {
6776 if (!wxPyCheckForApp()) SWIG_fail;
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (bool)wxColourDisplay();
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 {
6783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6784 }
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6792 PyObject *resultobj = 0;
6793 int result;
6794
6795 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6796 {
6797 if (!wxPyCheckForApp()) SWIG_fail;
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 result = (int)wxDisplayDepth();
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_From_int(static_cast< int >(result));
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6811 PyObject *resultobj = 0;
6812 int result;
6813
6814 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6815 {
6816 if (!wxPyCheckForApp()) SWIG_fail;
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 result = (int)wxGetDisplayDepth();
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_From_int(static_cast< int >(result));
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 int *arg1 = (int *) 0 ;
6832 int *arg2 = (int *) 0 ;
6833 int temp1 ;
6834 int res1 = SWIG_TMPOBJ ;
6835 int temp2 ;
6836 int res2 = SWIG_TMPOBJ ;
6837
6838 arg1 = &temp1;
6839 arg2 = &temp2;
6840 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6841 {
6842 if (!wxPyCheckForApp()) SWIG_fail;
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 wxDisplaySize(arg1,arg2);
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_Py_Void();
6849 if (SWIG_IsTmpObj(res1)) {
6850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6851 } else {
6852 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6854 }
6855 if (SWIG_IsTmpObj(res2)) {
6856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6857 } else {
6858 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6868 PyObject *resultobj = 0;
6869 wxSize result;
6870
6871 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6872 {
6873 if (!wxPyCheckForApp()) SWIG_fail;
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 result = wxGetDisplaySize();
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6887 PyObject *resultobj = 0;
6888 int *arg1 = (int *) 0 ;
6889 int *arg2 = (int *) 0 ;
6890 int temp1 ;
6891 int res1 = SWIG_TMPOBJ ;
6892 int temp2 ;
6893 int res2 = SWIG_TMPOBJ ;
6894
6895 arg1 = &temp1;
6896 arg2 = &temp2;
6897 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6898 {
6899 if (!wxPyCheckForApp()) SWIG_fail;
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 wxDisplaySizeMM(arg1,arg2);
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_Py_Void();
6906 if (SWIG_IsTmpObj(res1)) {
6907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6908 } else {
6909 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6911 }
6912 if (SWIG_IsTmpObj(res2)) {
6913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6914 } else {
6915 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6917 }
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6925 PyObject *resultobj = 0;
6926 wxSize result;
6927
6928 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6929 {
6930 if (!wxPyCheckForApp()) SWIG_fail;
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 result = wxGetDisplaySizeMM();
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6944 PyObject *resultobj = 0;
6945 int *arg1 = (int *) 0 ;
6946 int *arg2 = (int *) 0 ;
6947 int *arg3 = (int *) 0 ;
6948 int *arg4 = (int *) 0 ;
6949 int temp1 ;
6950 int res1 = SWIG_TMPOBJ ;
6951 int temp2 ;
6952 int res2 = SWIG_TMPOBJ ;
6953 int temp3 ;
6954 int res3 = SWIG_TMPOBJ ;
6955 int temp4 ;
6956 int res4 = SWIG_TMPOBJ ;
6957
6958 arg1 = &temp1;
6959 arg2 = &temp2;
6960 arg3 = &temp3;
6961 arg4 = &temp4;
6962 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6963 {
6964 if (!wxPyCheckForApp()) SWIG_fail;
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 if (SWIG_IsTmpObj(res1)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6976 }
6977 if (SWIG_IsTmpObj(res2)) {
6978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6979 } else {
6980 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6982 }
6983 if (SWIG_IsTmpObj(res3)) {
6984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6985 } else {
6986 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6988 }
6989 if (SWIG_IsTmpObj(res4)) {
6990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6991 } else {
6992 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6994 }
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7002 PyObject *resultobj = 0;
7003 wxRect result;
7004
7005 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7006 {
7007 if (!wxPyCheckForApp()) SWIG_fail;
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 result = wxGetClientDisplayRect();
7010 wxPyEndAllowThreads(__tstate);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7021 PyObject *resultobj = 0;
7022 wxCursor *arg1 = 0 ;
7023 void *argp1 = 0 ;
7024 int res1 = 0 ;
7025 PyObject * obj0 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "cursor", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7034 }
7035 if (!argp1) {
7036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7037 }
7038 arg1 = reinterpret_cast< wxCursor * >(argp1);
7039 {
7040 if (!wxPyCheckForApp()) SWIG_fail;
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 wxSetCursor(*arg1);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_Py_Void();
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7054 PyObject *resultobj = 0;
7055 void *result = 0 ;
7056
7057 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7058 {
7059 if (!wxPyCheckForApp()) SWIG_fail;
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 result = (void *)wxGetXDisplay();
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7075 void *argp1 = 0 ;
7076 int res1 = 0 ;
7077 PyObject * obj0 = 0 ;
7078 char * kwnames[] = {
7079 (char *) "cursor", NULL
7080 };
7081
7082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7083 if (obj0) {
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7087 }
7088 arg1 = reinterpret_cast< wxCursor * >(argp1);
7089 }
7090 {
7091 if (!wxPyCheckForApp()) SWIG_fail;
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 wxBeginBusyCursor(arg1);
7094 wxPyEndAllowThreads(__tstate);
7095 if (PyErr_Occurred()) SWIG_fail;
7096 }
7097 resultobj = SWIG_Py_Void();
7098 return resultobj;
7099 fail:
7100 return NULL;
7101 }
7102
7103
7104 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7105 PyObject *resultobj = 0;
7106 wxPoint result;
7107
7108 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7109 {
7110 if (!wxPyCheckForApp()) SWIG_fail;
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = wxGetMousePosition();
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7124 PyObject *resultobj = 0;
7125 wxWindow *result = 0 ;
7126
7127 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7128 {
7129 if (!wxPyCheckForApp()) SWIG_fail;
7130 PyThreadState* __tstate = wxPyBeginAllowThreads();
7131 result = (wxWindow *)FindWindowAtPointer();
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = wxPyMake_wxObject(result, 0);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7145 PyObject *resultobj = 0;
7146 wxWindow *result = 0 ;
7147
7148 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7149 {
7150 if (!wxPyCheckForApp()) SWIG_fail;
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 result = (wxWindow *)wxGetActiveWindow();
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 {
7157 resultobj = wxPyMake_wxObject(result, 0);
7158 }
7159 return resultobj;
7160 fail:
7161 return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7166 PyObject *resultobj = 0;
7167 wxPoint *arg1 = 0 ;
7168 wxWindow *result = 0 ;
7169 wxPoint temp1 ;
7170 PyObject * obj0 = 0 ;
7171 char * kwnames[] = {
7172 (char *) "pt", NULL
7173 };
7174
7175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7176 {
7177 arg1 = &temp1;
7178 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7179 }
7180 {
7181 if (!wxPyCheckForApp()) SWIG_fail;
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 {
7188 resultobj = wxPyMake_wxObject(result, 0);
7189 }
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj = 0;
7198 wxPoint *arg1 = 0 ;
7199 wxWindow *result = 0 ;
7200 wxPoint temp1 ;
7201 PyObject * obj0 = 0 ;
7202 char * kwnames[] = {
7203 (char *) "pt", NULL
7204 };
7205
7206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7207 {
7208 arg1 = &temp1;
7209 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7210 }
7211 {
7212 if (!wxPyCheckForApp()) SWIG_fail;
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7215 wxPyEndAllowThreads(__tstate);
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 {
7219 resultobj = wxPyMake_wxObject(result, 0);
7220 }
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj = 0;
7229 wxWindow *arg1 = (wxWindow *) 0 ;
7230 wxWindow *result = 0 ;
7231 void *argp1 = 0 ;
7232 int res1 = 0 ;
7233 PyObject * obj0 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "win", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7242 }
7243 arg1 = reinterpret_cast< wxWindow * >(argp1);
7244 {
7245 if (!wxPyCheckForApp()) SWIG_fail;
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (wxWindow *)wxGetTopLevelParent(arg1);
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 {
7252 resultobj = wxPyMake_wxObject(result, 0);
7253 }
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj = 0;
7262 wxString *arg1 = 0 ;
7263 bool result;
7264 bool temp1 = false ;
7265 PyObject * obj0 = 0 ;
7266 char * kwnames[] = {
7267 (char *) "url", NULL
7268 };
7269
7270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7271 {
7272 arg1 = wxString_in_helper(obj0);
7273 if (arg1 == NULL) SWIG_fail;
7274 temp1 = true;
7275 }
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 {
7283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7284 }
7285 {
7286 if (temp1)
7287 delete arg1;
7288 }
7289 return resultobj;
7290 fail:
7291 {
7292 if (temp1)
7293 delete arg1;
7294 }
7295 return NULL;
7296 }
7297
7298
7299 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj = 0;
7301 wxKeyCode arg1 ;
7302 bool result;
7303 int val1 ;
7304 int ecode1 = 0 ;
7305 PyObject * obj0 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "key", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7311 ecode1 = SWIG_AsVal_int(obj0, &val1);
7312 if (!SWIG_IsOK(ecode1)) {
7313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7314 }
7315 arg1 = static_cast< wxKeyCode >(val1);
7316 {
7317 if (!wxPyCheckForApp()) SWIG_fail;
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (bool)wxGetKeyState(arg1);
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 {
7324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7325 }
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7333 PyObject *resultobj = 0;
7334 wxMouseState *result = 0 ;
7335
7336 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 result = (wxMouseState *)new wxMouseState();
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7351 PyObject *resultobj = 0;
7352 wxMouseState *arg1 = (wxMouseState *) 0 ;
7353 void *argp1 = 0 ;
7354 int res1 = 0 ;
7355 PyObject *swig_obj[1] ;
7356
7357 if (!args) SWIG_fail;
7358 swig_obj[0] = args;
7359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7362 }
7363 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 delete arg1;
7367
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 resultobj = SWIG_Py_Void();
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7379 PyObject *resultobj = 0;
7380 wxMouseState *arg1 = (wxMouseState *) 0 ;
7381 int result;
7382 void *argp1 = 0 ;
7383 int res1 = 0 ;
7384 PyObject *swig_obj[1] ;
7385
7386 if (!args) SWIG_fail;
7387 swig_obj[0] = args;
7388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7391 }
7392 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 result = (int)(arg1)->GetX();
7396 wxPyEndAllowThreads(__tstate);
7397 if (PyErr_Occurred()) SWIG_fail;
7398 }
7399 resultobj = SWIG_From_int(static_cast< int >(result));
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7407 PyObject *resultobj = 0;
7408 wxMouseState *arg1 = (wxMouseState *) 0 ;
7409 int result;
7410 void *argp1 = 0 ;
7411 int res1 = 0 ;
7412 PyObject *swig_obj[1] ;
7413
7414 if (!args) SWIG_fail;
7415 swig_obj[0] = args;
7416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7417 if (!SWIG_IsOK(res1)) {
7418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7419 }
7420 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7421 {
7422 PyThreadState* __tstate = wxPyBeginAllowThreads();
7423 result = (int)(arg1)->GetY();
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 resultobj = SWIG_From_int(static_cast< int >(result));
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7435 PyObject *resultobj = 0;
7436 wxMouseState *arg1 = (wxMouseState *) 0 ;
7437 bool result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 PyObject *swig_obj[1] ;
7441
7442 if (!args) SWIG_fail;
7443 swig_obj[0] = args;
7444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7447 }
7448 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->LeftDown();
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 {
7456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7457 }
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7465 PyObject *resultobj = 0;
7466 wxMouseState *arg1 = (wxMouseState *) 0 ;
7467 bool result;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 PyObject *swig_obj[1] ;
7471
7472 if (!args) SWIG_fail;
7473 swig_obj[0] = args;
7474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7477 }
7478 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7479 {
7480 PyThreadState* __tstate = wxPyBeginAllowThreads();
7481 result = (bool)(arg1)->MiddleDown();
7482 wxPyEndAllowThreads(__tstate);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7495 PyObject *resultobj = 0;
7496 wxMouseState *arg1 = (wxMouseState *) 0 ;
7497 bool result;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 PyObject *swig_obj[1] ;
7501
7502 if (!args) SWIG_fail;
7503 swig_obj[0] = args;
7504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7505 if (!SWIG_IsOK(res1)) {
7506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7507 }
7508 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)(arg1)->RightDown();
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7525 PyObject *resultobj = 0;
7526 wxMouseState *arg1 = (wxMouseState *) 0 ;
7527 bool result;
7528 void *argp1 = 0 ;
7529 int res1 = 0 ;
7530 PyObject *swig_obj[1] ;
7531
7532 if (!args) SWIG_fail;
7533 swig_obj[0] = args;
7534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7537 }
7538 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)(arg1)->ControlDown();
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 {
7546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7547 }
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7555 PyObject *resultobj = 0;
7556 wxMouseState *arg1 = (wxMouseState *) 0 ;
7557 bool result;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 PyObject *swig_obj[1] ;
7561
7562 if (!args) SWIG_fail;
7563 swig_obj[0] = args;
7564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7567 }
7568 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (bool)(arg1)->ShiftDown();
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 {
7576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7577 }
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7585 PyObject *resultobj = 0;
7586 wxMouseState *arg1 = (wxMouseState *) 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 PyObject *swig_obj[1] ;
7591
7592 if (!args) SWIG_fail;
7593 swig_obj[0] = args;
7594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7595 if (!SWIG_IsOK(res1)) {
7596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7597 }
7598 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 result = (bool)(arg1)->AltDown();
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 {
7606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7607 }
7608 return resultobj;
7609 fail:
7610 return NULL;
7611 }
7612
7613
7614 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7615 PyObject *resultobj = 0;
7616 wxMouseState *arg1 = (wxMouseState *) 0 ;
7617 bool result;
7618 void *argp1 = 0 ;
7619 int res1 = 0 ;
7620 PyObject *swig_obj[1] ;
7621
7622 if (!args) SWIG_fail;
7623 swig_obj[0] = args;
7624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7625 if (!SWIG_IsOK(res1)) {
7626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7627 }
7628 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 result = (bool)(arg1)->MetaDown();
7632 wxPyEndAllowThreads(__tstate);
7633 if (PyErr_Occurred()) SWIG_fail;
7634 }
7635 {
7636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7637 }
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7645 PyObject *resultobj = 0;
7646 wxMouseState *arg1 = (wxMouseState *) 0 ;
7647 bool result;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 PyObject *swig_obj[1] ;
7651
7652 if (!args) SWIG_fail;
7653 swig_obj[0] = args;
7654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7655 if (!SWIG_IsOK(res1)) {
7656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7657 }
7658 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7659 {
7660 PyThreadState* __tstate = wxPyBeginAllowThreads();
7661 result = (bool)(arg1)->CmdDown();
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 {
7666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7667 }
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj = 0;
7676 wxMouseState *arg1 = (wxMouseState *) 0 ;
7677 int arg2 ;
7678 void *argp1 = 0 ;
7679 int res1 = 0 ;
7680 int val2 ;
7681 int ecode2 = 0 ;
7682 PyObject * obj0 = 0 ;
7683 PyObject * obj1 = 0 ;
7684 char * kwnames[] = {
7685 (char *) "self",(char *) "x", NULL
7686 };
7687
7688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7690 if (!SWIG_IsOK(res1)) {
7691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7692 }
7693 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7694 ecode2 = SWIG_AsVal_int(obj1, &val2);
7695 if (!SWIG_IsOK(ecode2)) {
7696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7697 }
7698 arg2 = static_cast< int >(val2);
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 (arg1)->SetX(arg2);
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 resultobj = SWIG_Py_Void();
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj = 0;
7714 wxMouseState *arg1 = (wxMouseState *) 0 ;
7715 int arg2 ;
7716 void *argp1 = 0 ;
7717 int res1 = 0 ;
7718 int val2 ;
7719 int ecode2 = 0 ;
7720 PyObject * obj0 = 0 ;
7721 PyObject * obj1 = 0 ;
7722 char * kwnames[] = {
7723 (char *) "self",(char *) "y", NULL
7724 };
7725
7726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7728 if (!SWIG_IsOK(res1)) {
7729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7730 }
7731 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7732 ecode2 = SWIG_AsVal_int(obj1, &val2);
7733 if (!SWIG_IsOK(ecode2)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7735 }
7736 arg2 = static_cast< int >(val2);
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 (arg1)->SetY(arg2);
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 resultobj = SWIG_Py_Void();
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj = 0;
7752 wxMouseState *arg1 = (wxMouseState *) 0 ;
7753 bool arg2 ;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 bool val2 ;
7757 int ecode2 = 0 ;
7758 PyObject * obj0 = 0 ;
7759 PyObject * obj1 = 0 ;
7760 char * kwnames[] = {
7761 (char *) "self",(char *) "down", NULL
7762 };
7763
7764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7766 if (!SWIG_IsOK(res1)) {
7767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7768 }
7769 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7771 if (!SWIG_IsOK(ecode2)) {
7772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7773 }
7774 arg2 = static_cast< bool >(val2);
7775 {
7776 PyThreadState* __tstate = wxPyBeginAllowThreads();
7777 (arg1)->SetLeftDown(arg2);
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 resultobj = SWIG_Py_Void();
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj = 0;
7790 wxMouseState *arg1 = (wxMouseState *) 0 ;
7791 bool arg2 ;
7792 void *argp1 = 0 ;
7793 int res1 = 0 ;
7794 bool val2 ;
7795 int ecode2 = 0 ;
7796 PyObject * obj0 = 0 ;
7797 PyObject * obj1 = 0 ;
7798 char * kwnames[] = {
7799 (char *) "self",(char *) "down", NULL
7800 };
7801
7802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7804 if (!SWIG_IsOK(res1)) {
7805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7806 }
7807 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7809 if (!SWIG_IsOK(ecode2)) {
7810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7811 }
7812 arg2 = static_cast< bool >(val2);
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 (arg1)->SetMiddleDown(arg2);
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = SWIG_Py_Void();
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7827 PyObject *resultobj = 0;
7828 wxMouseState *arg1 = (wxMouseState *) 0 ;
7829 bool arg2 ;
7830 void *argp1 = 0 ;
7831 int res1 = 0 ;
7832 bool val2 ;
7833 int ecode2 = 0 ;
7834 PyObject * obj0 = 0 ;
7835 PyObject * obj1 = 0 ;
7836 char * kwnames[] = {
7837 (char *) "self",(char *) "down", NULL
7838 };
7839
7840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7842 if (!SWIG_IsOK(res1)) {
7843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7844 }
7845 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7847 if (!SWIG_IsOK(ecode2)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7849 }
7850 arg2 = static_cast< bool >(val2);
7851 {
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 (arg1)->SetRightDown(arg2);
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 resultobj = SWIG_Py_Void();
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj = 0;
7866 wxMouseState *arg1 = (wxMouseState *) 0 ;
7867 bool arg2 ;
7868 void *argp1 = 0 ;
7869 int res1 = 0 ;
7870 bool val2 ;
7871 int ecode2 = 0 ;
7872 PyObject * obj0 = 0 ;
7873 PyObject * obj1 = 0 ;
7874 char * kwnames[] = {
7875 (char *) "self",(char *) "down", NULL
7876 };
7877
7878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7882 }
7883 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7884 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7887 }
7888 arg2 = static_cast< bool >(val2);
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 (arg1)->SetControlDown(arg2);
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 resultobj = SWIG_Py_Void();
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7903 PyObject *resultobj = 0;
7904 wxMouseState *arg1 = (wxMouseState *) 0 ;
7905 bool arg2 ;
7906 void *argp1 = 0 ;
7907 int res1 = 0 ;
7908 bool val2 ;
7909 int ecode2 = 0 ;
7910 PyObject * obj0 = 0 ;
7911 PyObject * obj1 = 0 ;
7912 char * kwnames[] = {
7913 (char *) "self",(char *) "down", NULL
7914 };
7915
7916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7918 if (!SWIG_IsOK(res1)) {
7919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7920 }
7921 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7922 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7923 if (!SWIG_IsOK(ecode2)) {
7924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7925 }
7926 arg2 = static_cast< bool >(val2);
7927 {
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 (arg1)->SetShiftDown(arg2);
7930 wxPyEndAllowThreads(__tstate);
7931 if (PyErr_Occurred()) SWIG_fail;
7932 }
7933 resultobj = SWIG_Py_Void();
7934 return resultobj;
7935 fail:
7936 return NULL;
7937 }
7938
7939
7940 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7941 PyObject *resultobj = 0;
7942 wxMouseState *arg1 = (wxMouseState *) 0 ;
7943 bool arg2 ;
7944 void *argp1 = 0 ;
7945 int res1 = 0 ;
7946 bool val2 ;
7947 int ecode2 = 0 ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 char * kwnames[] = {
7951 (char *) "self",(char *) "down", NULL
7952 };
7953
7954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7958 }
7959 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7961 if (!SWIG_IsOK(ecode2)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7963 }
7964 arg2 = static_cast< bool >(val2);
7965 {
7966 PyThreadState* __tstate = wxPyBeginAllowThreads();
7967 (arg1)->SetAltDown(arg2);
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7979 PyObject *resultobj = 0;
7980 wxMouseState *arg1 = (wxMouseState *) 0 ;
7981 bool arg2 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 bool val2 ;
7985 int ecode2 = 0 ;
7986 PyObject * obj0 = 0 ;
7987 PyObject * obj1 = 0 ;
7988 char * kwnames[] = {
7989 (char *) "self",(char *) "down", NULL
7990 };
7991
7992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7996 }
7997 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7999 if (!SWIG_IsOK(ecode2)) {
8000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8001 }
8002 arg2 = static_cast< bool >(val2);
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 (arg1)->SetMetaDown(arg2);
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *obj;
8018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8019 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8020 return SWIG_Py_Void();
8021 }
8022
8023 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 return SWIG_Python_InitShadowInstance(args);
8025 }
8026
8027 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8028 PyObject *resultobj = 0;
8029 wxMouseState result;
8030
8031 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8032 {
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 result = wxGetMouseState();
8035 wxPyEndAllowThreads(__tstate);
8036 if (PyErr_Occurred()) SWIG_fail;
8037 }
8038 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8039 return resultobj;
8040 fail:
8041 return NULL;
8042 }
8043
8044
8045 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8046 PyObject *resultobj = 0;
8047
8048 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8049 {
8050 if (!wxPyCheckForApp()) SWIG_fail;
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 wxWakeUpMainThread();
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 resultobj = SWIG_Py_Void();
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8064 PyObject *resultobj = 0;
8065
8066 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8067 {
8068 if (!wxPyCheckForApp()) SWIG_fail;
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 wxMutexGuiEnter();
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_Py_Void();
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8082 PyObject *resultobj = 0;
8083
8084 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8085 {
8086 if (!wxPyCheckForApp()) SWIG_fail;
8087 PyThreadState* __tstate = wxPyBeginAllowThreads();
8088 wxMutexGuiLeave();
8089 wxPyEndAllowThreads(__tstate);
8090 if (PyErr_Occurred()) SWIG_fail;
8091 }
8092 resultobj = SWIG_Py_Void();
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8100 PyObject *resultobj = 0;
8101 wxMutexGuiLocker *result = 0 ;
8102
8103 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8104 {
8105 if (!wxPyCheckForApp()) SWIG_fail;
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8119 PyObject *resultobj = 0;
8120 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8121 void *argp1 = 0 ;
8122 int res1 = 0 ;
8123 PyObject *swig_obj[1] ;
8124
8125 if (!args) SWIG_fail;
8126 swig_obj[0] = args;
8127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8128 if (!SWIG_IsOK(res1)) {
8129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8130 }
8131 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 delete arg1;
8135
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *obj;
8148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8149 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8150 return SWIG_Py_Void();
8151 }
8152
8153 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8154 return SWIG_Python_InitShadowInstance(args);
8155 }
8156
8157 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8158 PyObject *resultobj = 0;
8159 bool result;
8160
8161 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 result = (bool)wxThread_IsMain();
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 {
8169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8170 }
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8178 PyObject *resultobj = 0;
8179 wxString *arg1 = 0 ;
8180 wxToolTip *result = 0 ;
8181 bool temp1 = false ;
8182 PyObject * obj0 = 0 ;
8183 char * kwnames[] = {
8184 (char *) "tip", NULL
8185 };
8186
8187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8188 {
8189 arg1 = wxString_in_helper(obj0);
8190 if (arg1 == NULL) SWIG_fail;
8191 temp1 = true;
8192 }
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8201 {
8202 if (temp1)
8203 delete arg1;
8204 }
8205 return resultobj;
8206 fail:
8207 {
8208 if (temp1)
8209 delete arg1;
8210 }
8211 return NULL;
8212 }
8213
8214
8215 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8216 PyObject *resultobj = 0;
8217 wxToolTip *arg1 = (wxToolTip *) 0 ;
8218 void *argp1 = 0 ;
8219 int res1 = 0 ;
8220 PyObject *swig_obj[1] ;
8221
8222 if (!args) SWIG_fail;
8223 swig_obj[0] = args;
8224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8225 if (!SWIG_IsOK(res1)) {
8226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8227 }
8228 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 delete arg1;
8232
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_Py_Void();
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj = 0;
8245 wxToolTip *arg1 = (wxToolTip *) 0 ;
8246 wxString *arg2 = 0 ;
8247 void *argp1 = 0 ;
8248 int res1 = 0 ;
8249 bool temp2 = false ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "self",(char *) "tip", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8260 }
8261 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8262 {
8263 arg2 = wxString_in_helper(obj1);
8264 if (arg2 == NULL) SWIG_fail;
8265 temp2 = true;
8266 }
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 (arg1)->SetTip((wxString const &)*arg2);
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_Py_Void();
8274 {
8275 if (temp2)
8276 delete arg2;
8277 }
8278 return resultobj;
8279 fail:
8280 {
8281 if (temp2)
8282 delete arg2;
8283 }
8284 return NULL;
8285 }
8286
8287
8288 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8289 PyObject *resultobj = 0;
8290 wxToolTip *arg1 = (wxToolTip *) 0 ;
8291 wxString result;
8292 void *argp1 = 0 ;
8293 int res1 = 0 ;
8294 PyObject *swig_obj[1] ;
8295
8296 if (!args) SWIG_fail;
8297 swig_obj[0] = args;
8298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8299 if (!SWIG_IsOK(res1)) {
8300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8301 }
8302 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8303 {
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 result = (arg1)->GetTip();
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 {
8310 #if wxUSE_UNICODE
8311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8312 #else
8313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8314 #endif
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8323 PyObject *resultobj = 0;
8324 wxToolTip *arg1 = (wxToolTip *) 0 ;
8325 wxWindow *result = 0 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 PyObject *swig_obj[1] ;
8329
8330 if (!args) SWIG_fail;
8331 swig_obj[0] = args;
8332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8333 if (!SWIG_IsOK(res1)) {
8334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8335 }
8336 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (wxWindow *)(arg1)->GetWindow();
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 {
8344 resultobj = wxPyMake_wxObject(result, 0);
8345 }
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 bool arg1 ;
8355 bool val1 ;
8356 int ecode1 = 0 ;
8357 PyObject * obj0 = 0 ;
8358 char * kwnames[] = {
8359 (char *) "flag", NULL
8360 };
8361
8362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8363 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8364 if (!SWIG_IsOK(ecode1)) {
8365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8366 }
8367 arg1 = static_cast< bool >(val1);
8368 {
8369 PyThreadState* __tstate = wxPyBeginAllowThreads();
8370 wxToolTip::Enable(arg1);
8371 wxPyEndAllowThreads(__tstate);
8372 if (PyErr_Occurred()) SWIG_fail;
8373 }
8374 resultobj = SWIG_Py_Void();
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj = 0;
8383 long arg1 ;
8384 long val1 ;
8385 int ecode1 = 0 ;
8386 PyObject * obj0 = 0 ;
8387 char * kwnames[] = {
8388 (char *) "milliseconds", NULL
8389 };
8390
8391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8392 ecode1 = SWIG_AsVal_long(obj0, &val1);
8393 if (!SWIG_IsOK(ecode1)) {
8394 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8395 }
8396 arg1 = static_cast< long >(val1);
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 wxToolTip::SetDelay(arg1);
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_Py_Void();
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *obj;
8412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8413 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8414 return SWIG_Py_Void();
8415 }
8416
8417 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8418 return SWIG_Python_InitShadowInstance(args);
8419 }
8420
8421 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj = 0;
8423 wxWindow *arg1 = (wxWindow *) 0 ;
8424 wxSize *arg2 = 0 ;
8425 wxCaret *result = 0 ;
8426 void *argp1 = 0 ;
8427 int res1 = 0 ;
8428 wxSize temp2 ;
8429 PyObject * obj0 = 0 ;
8430 PyObject * obj1 = 0 ;
8431 char * kwnames[] = {
8432 (char *) "window",(char *) "size", NULL
8433 };
8434
8435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8437 if (!SWIG_IsOK(res1)) {
8438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8439 }
8440 arg1 = reinterpret_cast< wxWindow * >(argp1);
8441 {
8442 arg2 = &temp2;
8443 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8444 }
8445 {
8446 if (!wxPyCheckForApp()) SWIG_fail;
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8453 return resultobj;
8454 fail:
8455 return NULL;
8456 }
8457
8458
8459 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8460 PyObject *resultobj = 0;
8461 wxCaret *arg1 = (wxCaret *) 0 ;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 PyObject *swig_obj[1] ;
8465
8466 if (!args) SWIG_fail;
8467 swig_obj[0] = args;
8468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8469 if (!SWIG_IsOK(res1)) {
8470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8471 }
8472 arg1 = reinterpret_cast< wxCaret * >(argp1);
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 delete arg1;
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_Py_Void();
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxCaret *arg1 = (wxCaret *) 0 ;
8490 void *argp1 = 0 ;
8491 int res1 = 0 ;
8492 PyObject *swig_obj[1] ;
8493
8494 if (!args) SWIG_fail;
8495 swig_obj[0] = args;
8496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8499 }
8500 arg1 = reinterpret_cast< wxCaret * >(argp1);
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 wxCaret_Destroy(arg1);
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_Py_Void();
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8515 PyObject *resultobj = 0;
8516 wxCaret *arg1 = (wxCaret *) 0 ;
8517 bool result;
8518 void *argp1 = 0 ;
8519 int res1 = 0 ;
8520 PyObject *swig_obj[1] ;
8521
8522 if (!args) SWIG_fail;
8523 swig_obj[0] = args;
8524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8527 }
8528 arg1 = reinterpret_cast< wxCaret * >(argp1);
8529 {
8530 PyThreadState* __tstate = wxPyBeginAllowThreads();
8531 result = (bool)(arg1)->IsOk();
8532 wxPyEndAllowThreads(__tstate);
8533 if (PyErr_Occurred()) SWIG_fail;
8534 }
8535 {
8536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8537 }
8538 return resultobj;
8539 fail:
8540 return NULL;
8541 }
8542
8543
8544 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8545 PyObject *resultobj = 0;
8546 wxCaret *arg1 = (wxCaret *) 0 ;
8547 bool result;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 PyObject *swig_obj[1] ;
8551
8552 if (!args) SWIG_fail;
8553 swig_obj[0] = args;
8554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8557 }
8558 arg1 = reinterpret_cast< wxCaret * >(argp1);
8559 {
8560 PyThreadState* __tstate = wxPyBeginAllowThreads();
8561 result = (bool)(arg1)->IsVisible();
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8567 }
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8575 PyObject *resultobj = 0;
8576 wxCaret *arg1 = (wxCaret *) 0 ;
8577 wxPoint result;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 PyObject *swig_obj[1] ;
8581
8582 if (!args) SWIG_fail;
8583 swig_obj[0] = args;
8584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8585 if (!SWIG_IsOK(res1)) {
8586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8587 }
8588 arg1 = reinterpret_cast< wxCaret * >(argp1);
8589 {
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 result = (arg1)->GetPosition();
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8596 return resultobj;
8597 fail:
8598 return NULL;
8599 }
8600
8601
8602 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8603 PyObject *resultobj = 0;
8604 wxCaret *arg1 = (wxCaret *) 0 ;
8605 int *arg2 = (int *) 0 ;
8606 int *arg3 = (int *) 0 ;
8607 void *argp1 = 0 ;
8608 int res1 = 0 ;
8609 int temp2 ;
8610 int res2 = SWIG_TMPOBJ ;
8611 int temp3 ;
8612 int res3 = SWIG_TMPOBJ ;
8613 PyObject *swig_obj[1] ;
8614
8615 arg2 = &temp2;
8616 arg3 = &temp3;
8617 if (!args) SWIG_fail;
8618 swig_obj[0] = args;
8619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8620 if (!SWIG_IsOK(res1)) {
8621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8622 }
8623 arg1 = reinterpret_cast< wxCaret * >(argp1);
8624 {
8625 PyThreadState* __tstate = wxPyBeginAllowThreads();
8626 (arg1)->GetPosition(arg2,arg3);
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 resultobj = SWIG_Py_Void();
8631 if (SWIG_IsTmpObj(res2)) {
8632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8633 } else {
8634 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8636 }
8637 if (SWIG_IsTmpObj(res3)) {
8638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8639 } else {
8640 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8642 }
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8650 PyObject *resultobj = 0;
8651 wxCaret *arg1 = (wxCaret *) 0 ;
8652 wxSize result;
8653 void *argp1 = 0 ;
8654 int res1 = 0 ;
8655 PyObject *swig_obj[1] ;
8656
8657 if (!args) SWIG_fail;
8658 swig_obj[0] = args;
8659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8660 if (!SWIG_IsOK(res1)) {
8661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8662 }
8663 arg1 = reinterpret_cast< wxCaret * >(argp1);
8664 {
8665 PyThreadState* __tstate = wxPyBeginAllowThreads();
8666 result = (arg1)->GetSize();
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8671 return resultobj;
8672 fail:
8673 return NULL;
8674 }
8675
8676
8677 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678 PyObject *resultobj = 0;
8679 wxCaret *arg1 = (wxCaret *) 0 ;
8680 int *arg2 = (int *) 0 ;
8681 int *arg3 = (int *) 0 ;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 int temp2 ;
8685 int res2 = SWIG_TMPOBJ ;
8686 int temp3 ;
8687 int res3 = SWIG_TMPOBJ ;
8688 PyObject *swig_obj[1] ;
8689
8690 arg2 = &temp2;
8691 arg3 = &temp3;
8692 if (!args) SWIG_fail;
8693 swig_obj[0] = args;
8694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8697 }
8698 arg1 = reinterpret_cast< wxCaret * >(argp1);
8699 {
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 (arg1)->GetSize(arg2,arg3);
8702 wxPyEndAllowThreads(__tstate);
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 resultobj = SWIG_Py_Void();
8706 if (SWIG_IsTmpObj(res2)) {
8707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8708 } else {
8709 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8711 }
8712 if (SWIG_IsTmpObj(res3)) {
8713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8714 } else {
8715 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8717 }
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8725 PyObject *resultobj = 0;
8726 wxCaret *arg1 = (wxCaret *) 0 ;
8727 wxWindow *result = 0 ;
8728 void *argp1 = 0 ;
8729 int res1 = 0 ;
8730 PyObject *swig_obj[1] ;
8731
8732 if (!args) SWIG_fail;
8733 swig_obj[0] = args;
8734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8735 if (!SWIG_IsOK(res1)) {
8736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8737 }
8738 arg1 = reinterpret_cast< wxCaret * >(argp1);
8739 {
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 result = (wxWindow *)(arg1)->GetWindow();
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 {
8746 resultobj = wxPyMake_wxObject(result, 0);
8747 }
8748 return resultobj;
8749 fail:
8750 return NULL;
8751 }
8752
8753
8754 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj = 0;
8756 wxCaret *arg1 = (wxCaret *) 0 ;
8757 int arg2 ;
8758 int arg3 ;
8759 void *argp1 = 0 ;
8760 int res1 = 0 ;
8761 int val2 ;
8762 int ecode2 = 0 ;
8763 int val3 ;
8764 int ecode3 = 0 ;
8765 PyObject * obj0 = 0 ;
8766 PyObject * obj1 = 0 ;
8767 PyObject * obj2 = 0 ;
8768 char * kwnames[] = {
8769 (char *) "self",(char *) "x",(char *) "y", NULL
8770 };
8771
8772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8776 }
8777 arg1 = reinterpret_cast< wxCaret * >(argp1);
8778 ecode2 = SWIG_AsVal_int(obj1, &val2);
8779 if (!SWIG_IsOK(ecode2)) {
8780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8781 }
8782 arg2 = static_cast< int >(val2);
8783 ecode3 = SWIG_AsVal_int(obj2, &val3);
8784 if (!SWIG_IsOK(ecode3)) {
8785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8786 }
8787 arg3 = static_cast< int >(val3);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 (arg1)->Move(arg2,arg3);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 resultobj = SWIG_Py_Void();
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8802 PyObject *resultobj = 0;
8803 wxCaret *arg1 = (wxCaret *) 0 ;
8804 wxPoint *arg2 = 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 wxPoint temp2 ;
8808 PyObject * obj0 = 0 ;
8809 PyObject * obj1 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "pt", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8818 }
8819 arg1 = reinterpret_cast< wxCaret * >(argp1);
8820 {
8821 arg2 = &temp2;
8822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8823 }
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 (arg1)->Move((wxPoint const &)*arg2);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_Py_Void();
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj = 0;
8839 wxCaret *arg1 = (wxCaret *) 0 ;
8840 int arg2 ;
8841 int arg3 ;
8842 void *argp1 = 0 ;
8843 int res1 = 0 ;
8844 int val2 ;
8845 int ecode2 = 0 ;
8846 int val3 ;
8847 int ecode3 = 0 ;
8848 PyObject * obj0 = 0 ;
8849 PyObject * obj1 = 0 ;
8850 PyObject * obj2 = 0 ;
8851 char * kwnames[] = {
8852 (char *) "self",(char *) "width",(char *) "height", NULL
8853 };
8854
8855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8857 if (!SWIG_IsOK(res1)) {
8858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8859 }
8860 arg1 = reinterpret_cast< wxCaret * >(argp1);
8861 ecode2 = SWIG_AsVal_int(obj1, &val2);
8862 if (!SWIG_IsOK(ecode2)) {
8863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8864 }
8865 arg2 = static_cast< int >(val2);
8866 ecode3 = SWIG_AsVal_int(obj2, &val3);
8867 if (!SWIG_IsOK(ecode3)) {
8868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8869 }
8870 arg3 = static_cast< int >(val3);
8871 {
8872 PyThreadState* __tstate = wxPyBeginAllowThreads();
8873 (arg1)->SetSize(arg2,arg3);
8874 wxPyEndAllowThreads(__tstate);
8875 if (PyErr_Occurred()) SWIG_fail;
8876 }
8877 resultobj = SWIG_Py_Void();
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj = 0;
8886 wxCaret *arg1 = (wxCaret *) 0 ;
8887 wxSize *arg2 = 0 ;
8888 void *argp1 = 0 ;
8889 int res1 = 0 ;
8890 wxSize temp2 ;
8891 PyObject * obj0 = 0 ;
8892 PyObject * obj1 = 0 ;
8893 char * kwnames[] = {
8894 (char *) "self",(char *) "size", NULL
8895 };
8896
8897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8899 if (!SWIG_IsOK(res1)) {
8900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8901 }
8902 arg1 = reinterpret_cast< wxCaret * >(argp1);
8903 {
8904 arg2 = &temp2;
8905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 (arg1)->SetSize((wxSize const &)*arg2);
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 resultobj = SWIG_Py_Void();
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8921 PyObject *resultobj = 0;
8922 wxCaret *arg1 = (wxCaret *) 0 ;
8923 int arg2 = (int) true ;
8924 void *argp1 = 0 ;
8925 int res1 = 0 ;
8926 int val2 ;
8927 int ecode2 = 0 ;
8928 PyObject * obj0 = 0 ;
8929 PyObject * obj1 = 0 ;
8930 char * kwnames[] = {
8931 (char *) "self",(char *) "show", NULL
8932 };
8933
8934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8938 }
8939 arg1 = reinterpret_cast< wxCaret * >(argp1);
8940 if (obj1) {
8941 ecode2 = SWIG_AsVal_int(obj1, &val2);
8942 if (!SWIG_IsOK(ecode2)) {
8943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8944 }
8945 arg2 = static_cast< int >(val2);
8946 }
8947 {
8948 PyThreadState* __tstate = wxPyBeginAllowThreads();
8949 (arg1)->Show(arg2);
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 resultobj = SWIG_Py_Void();
8954 return resultobj;
8955 fail:
8956 return NULL;
8957 }
8958
8959
8960 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8961 PyObject *resultobj = 0;
8962 wxCaret *arg1 = (wxCaret *) 0 ;
8963 void *argp1 = 0 ;
8964 int res1 = 0 ;
8965 PyObject *swig_obj[1] ;
8966
8967 if (!args) SWIG_fail;
8968 swig_obj[0] = args;
8969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8970 if (!SWIG_IsOK(res1)) {
8971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8972 }
8973 arg1 = reinterpret_cast< wxCaret * >(argp1);
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 (arg1)->Hide();
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 resultobj = SWIG_Py_Void();
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8988 PyObject *resultobj = 0;
8989 int result;
8990
8991 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8992 {
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (int)wxCaret::GetBlinkTime();
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 resultobj = SWIG_From_int(static_cast< int >(result));
8999 return resultobj;
9000 fail:
9001 return NULL;
9002 }
9003
9004
9005 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9006 PyObject *resultobj = 0;
9007 int arg1 ;
9008 int val1 ;
9009 int ecode1 = 0 ;
9010 PyObject * obj0 = 0 ;
9011 char * kwnames[] = {
9012 (char *) "milliseconds", NULL
9013 };
9014
9015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9016 ecode1 = SWIG_AsVal_int(obj0, &val1);
9017 if (!SWIG_IsOK(ecode1)) {
9018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9019 }
9020 arg1 = static_cast< int >(val1);
9021 {
9022 PyThreadState* __tstate = wxPyBeginAllowThreads();
9023 wxCaret::SetBlinkTime(arg1);
9024 wxPyEndAllowThreads(__tstate);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 resultobj = SWIG_Py_Void();
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9035 PyObject *obj;
9036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9037 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9038 return SWIG_Py_Void();
9039 }
9040
9041 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9042 return SWIG_Python_InitShadowInstance(args);
9043 }
9044
9045 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj = 0;
9047 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9048 wxBusyCursor *result = 0 ;
9049 void *argp1 = 0 ;
9050 int res1 = 0 ;
9051 PyObject * obj0 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "cursor", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9057 if (obj0) {
9058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9061 }
9062 arg1 = reinterpret_cast< wxCursor * >(argp1);
9063 }
9064 {
9065 if (!wxPyCheckForApp()) SWIG_fail;
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9068 wxPyEndAllowThreads(__tstate);
9069 if (PyErr_Occurred()) SWIG_fail;
9070 }
9071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9072 return resultobj;
9073 fail:
9074 return NULL;
9075 }
9076
9077
9078 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9079 PyObject *resultobj = 0;
9080 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9081 void *argp1 = 0 ;
9082 int res1 = 0 ;
9083 PyObject *swig_obj[1] ;
9084
9085 if (!args) SWIG_fail;
9086 swig_obj[0] = args;
9087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9088 if (!SWIG_IsOK(res1)) {
9089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9090 }
9091 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9092 {
9093 PyThreadState* __tstate = wxPyBeginAllowThreads();
9094 delete arg1;
9095
9096 wxPyEndAllowThreads(__tstate);
9097 if (PyErr_Occurred()) SWIG_fail;
9098 }
9099 resultobj = SWIG_Py_Void();
9100 return resultobj;
9101 fail:
9102 return NULL;
9103 }
9104
9105
9106 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9107 PyObject *obj;
9108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9109 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9110 return SWIG_Py_Void();
9111 }
9112
9113 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9114 return SWIG_Python_InitShadowInstance(args);
9115 }
9116
9117 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj = 0;
9119 wxWindow *arg1 = (wxWindow *) NULL ;
9120 wxWindowDisabler *result = 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 PyObject * obj0 = 0 ;
9124 char * kwnames[] = {
9125 (char *) "winToSkip", NULL
9126 };
9127
9128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9129 if (obj0) {
9130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9131 if (!SWIG_IsOK(res1)) {
9132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9133 }
9134 arg1 = reinterpret_cast< wxWindow * >(argp1);
9135 }
9136 {
9137 if (!wxPyCheckForApp()) SWIG_fail;
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9151 PyObject *resultobj = 0;
9152 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9153 void *argp1 = 0 ;
9154 int res1 = 0 ;
9155 PyObject *swig_obj[1] ;
9156
9157 if (!args) SWIG_fail;
9158 swig_obj[0] = args;
9159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9162 }
9163 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9164 {
9165 PyThreadState* __tstate = wxPyBeginAllowThreads();
9166 delete arg1;
9167
9168 wxPyEndAllowThreads(__tstate);
9169 if (PyErr_Occurred()) SWIG_fail;
9170 }
9171 resultobj = SWIG_Py_Void();
9172 return resultobj;
9173 fail:
9174 return NULL;
9175 }
9176
9177
9178 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 PyObject *obj;
9180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9181 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9182 return SWIG_Py_Void();
9183 }
9184
9185 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9186 return SWIG_Python_InitShadowInstance(args);
9187 }
9188
9189 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9190 PyObject *resultobj = 0;
9191 wxString *arg1 = 0 ;
9192 wxWindow *arg2 = (wxWindow *) NULL ;
9193 wxBusyInfo *result = 0 ;
9194 bool temp1 = false ;
9195 void *argp2 = 0 ;
9196 int res2 = 0 ;
9197 PyObject * obj0 = 0 ;
9198 PyObject * obj1 = 0 ;
9199 char * kwnames[] = {
9200 (char *) "message",(char *) "parent", NULL
9201 };
9202
9203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9204 {
9205 arg1 = wxString_in_helper(obj0);
9206 if (arg1 == NULL) SWIG_fail;
9207 temp1 = true;
9208 }
9209 if (obj1) {
9210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9211 if (!SWIG_IsOK(res2)) {
9212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9213 }
9214 arg2 = reinterpret_cast< wxWindow * >(argp2);
9215 }
9216 {
9217 if (!wxPyCheckForApp()) SWIG_fail;
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9220 wxPyEndAllowThreads(__tstate);
9221 if (PyErr_Occurred()) SWIG_fail;
9222 }
9223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9224 {
9225 if (temp1)
9226 delete arg1;
9227 }
9228 return resultobj;
9229 fail:
9230 {
9231 if (temp1)
9232 delete arg1;
9233 }
9234 return NULL;
9235 }
9236
9237
9238 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9239 PyObject *resultobj = 0;
9240 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9241 void *argp1 = 0 ;
9242 int res1 = 0 ;
9243 PyObject *swig_obj[1] ;
9244
9245 if (!args) SWIG_fail;
9246 swig_obj[0] = args;
9247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9248 if (!SWIG_IsOK(res1)) {
9249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9250 }
9251 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9252 {
9253 PyThreadState* __tstate = wxPyBeginAllowThreads();
9254 delete arg1;
9255
9256 wxPyEndAllowThreads(__tstate);
9257 if (PyErr_Occurred()) SWIG_fail;
9258 }
9259 resultobj = SWIG_Py_Void();
9260 return resultobj;
9261 fail:
9262 return NULL;
9263 }
9264
9265
9266 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 PyObject *obj;
9268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9269 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9270 return SWIG_Py_Void();
9271 }
9272
9273 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274 return SWIG_Python_InitShadowInstance(args);
9275 }
9276
9277 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9278 PyObject *resultobj = 0;
9279 wxStopWatch *result = 0 ;
9280
9281 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (wxStopWatch *)new wxStopWatch();
9285 wxPyEndAllowThreads(__tstate);
9286 if (PyErr_Occurred()) SWIG_fail;
9287 }
9288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9289 return resultobj;
9290 fail:
9291 return NULL;
9292 }
9293
9294
9295 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9296 PyObject *resultobj = 0;
9297 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9298 void *argp1 = 0 ;
9299 int res1 = 0 ;
9300 PyObject *swig_obj[1] ;
9301
9302 if (!args) SWIG_fail;
9303 swig_obj[0] = args;
9304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9305 if (!SWIG_IsOK(res1)) {
9306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9307 }
9308 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 delete arg1;
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 resultobj = SWIG_Py_Void();
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9324 PyObject *resultobj = 0;
9325 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9326 long arg2 = (long) 0 ;
9327 void *argp1 = 0 ;
9328 int res1 = 0 ;
9329 long val2 ;
9330 int ecode2 = 0 ;
9331 PyObject * obj0 = 0 ;
9332 PyObject * obj1 = 0 ;
9333 char * kwnames[] = {
9334 (char *) "self",(char *) "t0", NULL
9335 };
9336
9337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9339 if (!SWIG_IsOK(res1)) {
9340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9341 }
9342 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9343 if (obj1) {
9344 ecode2 = SWIG_AsVal_long(obj1, &val2);
9345 if (!SWIG_IsOK(ecode2)) {
9346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9347 }
9348 arg2 = static_cast< long >(val2);
9349 }
9350 {
9351 PyThreadState* __tstate = wxPyBeginAllowThreads();
9352 (arg1)->Start(arg2);
9353 wxPyEndAllowThreads(__tstate);
9354 if (PyErr_Occurred()) SWIG_fail;
9355 }
9356 resultobj = SWIG_Py_Void();
9357 return resultobj;
9358 fail:
9359 return NULL;
9360 }
9361
9362
9363 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9364 PyObject *resultobj = 0;
9365 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9366 void *argp1 = 0 ;
9367 int res1 = 0 ;
9368 PyObject *swig_obj[1] ;
9369
9370 if (!args) SWIG_fail;
9371 swig_obj[0] = args;
9372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9373 if (!SWIG_IsOK(res1)) {
9374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9375 }
9376 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9377 {
9378 PyThreadState* __tstate = wxPyBeginAllowThreads();
9379 (arg1)->Pause();
9380 wxPyEndAllowThreads(__tstate);
9381 if (PyErr_Occurred()) SWIG_fail;
9382 }
9383 resultobj = SWIG_Py_Void();
9384 return resultobj;
9385 fail:
9386 return NULL;
9387 }
9388
9389
9390 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9391 PyObject *resultobj = 0;
9392 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9393 void *argp1 = 0 ;
9394 int res1 = 0 ;
9395 PyObject *swig_obj[1] ;
9396
9397 if (!args) SWIG_fail;
9398 swig_obj[0] = args;
9399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9400 if (!SWIG_IsOK(res1)) {
9401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9402 }
9403 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 (arg1)->Resume();
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 resultobj = SWIG_Py_Void();
9411 return resultobj;
9412 fail:
9413 return NULL;
9414 }
9415
9416
9417 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9418 PyObject *resultobj = 0;
9419 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9420 long result;
9421 void *argp1 = 0 ;
9422 int res1 = 0 ;
9423 PyObject *swig_obj[1] ;
9424
9425 if (!args) SWIG_fail;
9426 swig_obj[0] = args;
9427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9428 if (!SWIG_IsOK(res1)) {
9429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9430 }
9431 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (long)((wxStopWatch const *)arg1)->Time();
9435 wxPyEndAllowThreads(__tstate);
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 resultobj = SWIG_From_long(static_cast< long >(result));
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9446 PyObject *obj;
9447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9448 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9449 return SWIG_Py_Void();
9450 }
9451
9452 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9453 return SWIG_Python_InitShadowInstance(args);
9454 }
9455
9456 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj = 0;
9458 int arg1 = (int) 9 ;
9459 int arg2 = (int) wxID_FILE1 ;
9460 wxFileHistory *result = 0 ;
9461 int val1 ;
9462 int ecode1 = 0 ;
9463 int val2 ;
9464 int ecode2 = 0 ;
9465 PyObject * obj0 = 0 ;
9466 PyObject * obj1 = 0 ;
9467 char * kwnames[] = {
9468 (char *) "maxFiles",(char *) "idBase", NULL
9469 };
9470
9471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9472 if (obj0) {
9473 ecode1 = SWIG_AsVal_int(obj0, &val1);
9474 if (!SWIG_IsOK(ecode1)) {
9475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9476 }
9477 arg1 = static_cast< int >(val1);
9478 }
9479 if (obj1) {
9480 ecode2 = SWIG_AsVal_int(obj1, &val2);
9481 if (!SWIG_IsOK(ecode2)) {
9482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9483 }
9484 arg2 = static_cast< int >(val2);
9485 }
9486 {
9487 PyThreadState* __tstate = wxPyBeginAllowThreads();
9488 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9489 wxPyEndAllowThreads(__tstate);
9490 if (PyErr_Occurred()) SWIG_fail;
9491 }
9492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9493 return resultobj;
9494 fail:
9495 return NULL;
9496 }
9497
9498
9499 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9500 PyObject *resultobj = 0;
9501 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9502 void *argp1 = 0 ;
9503 int res1 = 0 ;
9504 PyObject *swig_obj[1] ;
9505
9506 if (!args) SWIG_fail;
9507 swig_obj[0] = args;
9508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9509 if (!SWIG_IsOK(res1)) {
9510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9511 }
9512 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9513 {
9514 PyThreadState* __tstate = wxPyBeginAllowThreads();
9515 delete arg1;
9516
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 resultobj = SWIG_Py_Void();
9521 return resultobj;
9522 fail:
9523 return NULL;
9524 }
9525
9526
9527 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9528 PyObject *resultobj = 0;
9529 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9530 wxString *arg2 = 0 ;
9531 void *argp1 = 0 ;
9532 int res1 = 0 ;
9533 bool temp2 = false ;
9534 PyObject * obj0 = 0 ;
9535 PyObject * obj1 = 0 ;
9536 char * kwnames[] = {
9537 (char *) "self",(char *) "file", NULL
9538 };
9539
9540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9542 if (!SWIG_IsOK(res1)) {
9543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9544 }
9545 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9546 {
9547 arg2 = wxString_in_helper(obj1);
9548 if (arg2 == NULL) SWIG_fail;
9549 temp2 = true;
9550 }
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 (arg1)->AddFileToHistory((wxString const &)*arg2);
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 resultobj = SWIG_Py_Void();
9558 {
9559 if (temp2)
9560 delete arg2;
9561 }
9562 return resultobj;
9563 fail:
9564 {
9565 if (temp2)
9566 delete arg2;
9567 }
9568 return NULL;
9569 }
9570
9571
9572 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9573 PyObject *resultobj = 0;
9574 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9575 int arg2 ;
9576 void *argp1 = 0 ;
9577 int res1 = 0 ;
9578 int val2 ;
9579 int ecode2 = 0 ;
9580 PyObject * obj0 = 0 ;
9581 PyObject * obj1 = 0 ;
9582 char * kwnames[] = {
9583 (char *) "self",(char *) "i", NULL
9584 };
9585
9586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9588 if (!SWIG_IsOK(res1)) {
9589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9590 }
9591 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9592 ecode2 = SWIG_AsVal_int(obj1, &val2);
9593 if (!SWIG_IsOK(ecode2)) {
9594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9595 }
9596 arg2 = static_cast< int >(val2);
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 (arg1)->RemoveFileFromHistory(arg2);
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 resultobj = SWIG_Py_Void();
9604 return resultobj;
9605 fail:
9606 return NULL;
9607 }
9608
9609
9610 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9611 PyObject *resultobj = 0;
9612 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9613 int result;
9614 void *argp1 = 0 ;
9615 int res1 = 0 ;
9616 PyObject *swig_obj[1] ;
9617
9618 if (!args) SWIG_fail;
9619 swig_obj[0] = args;
9620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9621 if (!SWIG_IsOK(res1)) {
9622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9623 }
9624 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9628 wxPyEndAllowThreads(__tstate);
9629 if (PyErr_Occurred()) SWIG_fail;
9630 }
9631 resultobj = SWIG_From_int(static_cast< int >(result));
9632 return resultobj;
9633 fail:
9634 return NULL;
9635 }
9636
9637
9638 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9639 PyObject *resultobj = 0;
9640 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9641 wxMenu *arg2 = (wxMenu *) 0 ;
9642 void *argp1 = 0 ;
9643 int res1 = 0 ;
9644 void *argp2 = 0 ;
9645 int res2 = 0 ;
9646 PyObject * obj0 = 0 ;
9647 PyObject * obj1 = 0 ;
9648 char * kwnames[] = {
9649 (char *) "self",(char *) "menu", NULL
9650 };
9651
9652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9654 if (!SWIG_IsOK(res1)) {
9655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9656 }
9657 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9659 if (!SWIG_IsOK(res2)) {
9660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9661 }
9662 arg2 = reinterpret_cast< wxMenu * >(argp2);
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 (arg1)->UseMenu(arg2);
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 resultobj = SWIG_Py_Void();
9670 return resultobj;
9671 fail:
9672 return NULL;
9673 }
9674
9675
9676 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9677 PyObject *resultobj = 0;
9678 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9679 wxMenu *arg2 = (wxMenu *) 0 ;
9680 void *argp1 = 0 ;
9681 int res1 = 0 ;
9682 void *argp2 = 0 ;
9683 int res2 = 0 ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 char * kwnames[] = {
9687 (char *) "self",(char *) "menu", NULL
9688 };
9689
9690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9692 if (!SWIG_IsOK(res1)) {
9693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9694 }
9695 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9697 if (!SWIG_IsOK(res2)) {
9698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9699 }
9700 arg2 = reinterpret_cast< wxMenu * >(argp2);
9701 {
9702 PyThreadState* __tstate = wxPyBeginAllowThreads();
9703 (arg1)->RemoveMenu(arg2);
9704 wxPyEndAllowThreads(__tstate);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 resultobj = SWIG_Py_Void();
9708 return resultobj;
9709 fail:
9710 return NULL;
9711 }
9712
9713
9714 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9715 PyObject *resultobj = 0;
9716 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9717 wxConfigBase *arg2 = 0 ;
9718 void *argp1 = 0 ;
9719 int res1 = 0 ;
9720 void *argp2 = 0 ;
9721 int res2 = 0 ;
9722 PyObject * obj0 = 0 ;
9723 PyObject * obj1 = 0 ;
9724 char * kwnames[] = {
9725 (char *) "self",(char *) "config", NULL
9726 };
9727
9728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9730 if (!SWIG_IsOK(res1)) {
9731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9732 }
9733 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9735 if (!SWIG_IsOK(res2)) {
9736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9737 }
9738 if (!argp2) {
9739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9740 }
9741 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9742 {
9743 PyThreadState* __tstate = wxPyBeginAllowThreads();
9744 (arg1)->Load(*arg2);
9745 wxPyEndAllowThreads(__tstate);
9746 if (PyErr_Occurred()) SWIG_fail;
9747 }
9748 resultobj = SWIG_Py_Void();
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9756 PyObject *resultobj = 0;
9757 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9758 wxConfigBase *arg2 = 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 void *argp2 = 0 ;
9762 int res2 = 0 ;
9763 PyObject * obj0 = 0 ;
9764 PyObject * obj1 = 0 ;
9765 char * kwnames[] = {
9766 (char *) "self",(char *) "config", NULL
9767 };
9768
9769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9771 if (!SWIG_IsOK(res1)) {
9772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9773 }
9774 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9775 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9776 if (!SWIG_IsOK(res2)) {
9777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9778 }
9779 if (!argp2) {
9780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9781 }
9782 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9783 {
9784 PyThreadState* __tstate = wxPyBeginAllowThreads();
9785 (arg1)->Save(*arg2);
9786 wxPyEndAllowThreads(__tstate);
9787 if (PyErr_Occurred()) SWIG_fail;
9788 }
9789 resultobj = SWIG_Py_Void();
9790 return resultobj;
9791 fail:
9792 return NULL;
9793 }
9794
9795
9796 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9797 PyObject *resultobj = 0;
9798 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9799 void *argp1 = 0 ;
9800 int res1 = 0 ;
9801 PyObject *swig_obj[1] ;
9802
9803 if (!args) SWIG_fail;
9804 swig_obj[0] = args;
9805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9806 if (!SWIG_IsOK(res1)) {
9807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9808 }
9809 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 (arg1)->AddFilesToMenu();
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 resultobj = SWIG_Py_Void();
9817 return resultobj;
9818 fail:
9819 return NULL;
9820 }
9821
9822
9823 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9824 PyObject *resultobj = 0;
9825 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9826 wxMenu *arg2 = (wxMenu *) 0 ;
9827 void *argp1 = 0 ;
9828 int res1 = 0 ;
9829 void *argp2 = 0 ;
9830 int res2 = 0 ;
9831 PyObject * obj0 = 0 ;
9832 PyObject * obj1 = 0 ;
9833 char * kwnames[] = {
9834 (char *) "self",(char *) "menu", NULL
9835 };
9836
9837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9839 if (!SWIG_IsOK(res1)) {
9840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9841 }
9842 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9843 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9844 if (!SWIG_IsOK(res2)) {
9845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9846 }
9847 arg2 = reinterpret_cast< wxMenu * >(argp2);
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 (arg1)->AddFilesToMenu(arg2);
9851 wxPyEndAllowThreads(__tstate);
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 resultobj = SWIG_Py_Void();
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9862 PyObject *resultobj = 0;
9863 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9864 int arg2 ;
9865 wxString result;
9866 void *argp1 = 0 ;
9867 int res1 = 0 ;
9868 int val2 ;
9869 int ecode2 = 0 ;
9870 PyObject * obj0 = 0 ;
9871 PyObject * obj1 = 0 ;
9872 char * kwnames[] = {
9873 (char *) "self",(char *) "i", NULL
9874 };
9875
9876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9878 if (!SWIG_IsOK(res1)) {
9879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9880 }
9881 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9882 ecode2 = SWIG_AsVal_int(obj1, &val2);
9883 if (!SWIG_IsOK(ecode2)) {
9884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9885 }
9886 arg2 = static_cast< int >(val2);
9887 {
9888 PyThreadState* __tstate = wxPyBeginAllowThreads();
9889 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9890 wxPyEndAllowThreads(__tstate);
9891 if (PyErr_Occurred()) SWIG_fail;
9892 }
9893 {
9894 #if wxUSE_UNICODE
9895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9896 #else
9897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9898 #endif
9899 }
9900 return resultobj;
9901 fail:
9902 return NULL;
9903 }
9904
9905
9906 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9907 PyObject *resultobj = 0;
9908 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9909 int result;
9910 void *argp1 = 0 ;
9911 int res1 = 0 ;
9912 PyObject *swig_obj[1] ;
9913
9914 if (!args) SWIG_fail;
9915 swig_obj[0] = args;
9916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9917 if (!SWIG_IsOK(res1)) {
9918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9919 }
9920 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (int)((wxFileHistory const *)arg1)->GetCount();
9924 wxPyEndAllowThreads(__tstate);
9925 if (PyErr_Occurred()) SWIG_fail;
9926 }
9927 resultobj = SWIG_From_int(static_cast< int >(result));
9928 return resultobj;
9929 fail:
9930 return NULL;
9931 }
9932
9933
9934 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9935 PyObject *obj;
9936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9937 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9938 return SWIG_Py_Void();
9939 }
9940
9941 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9942 return SWIG_Python_InitShadowInstance(args);
9943 }
9944
9945 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9946 PyObject *resultobj = 0;
9947 wxString *arg1 = 0 ;
9948 wxString const &arg2_defvalue = wxPyEmptyString ;
9949 wxString *arg2 = (wxString *) &arg2_defvalue ;
9950 wxSingleInstanceChecker *result = 0 ;
9951 bool temp1 = false ;
9952 bool temp2 = false ;
9953 PyObject * obj0 = 0 ;
9954 PyObject * obj1 = 0 ;
9955 char * kwnames[] = {
9956 (char *) "name",(char *) "path", NULL
9957 };
9958
9959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9960 {
9961 arg1 = wxString_in_helper(obj0);
9962 if (arg1 == NULL) SWIG_fail;
9963 temp1 = true;
9964 }
9965 if (obj1) {
9966 {
9967 arg2 = wxString_in_helper(obj1);
9968 if (arg2 == NULL) SWIG_fail;
9969 temp2 = true;
9970 }
9971 }
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9979 {
9980 if (temp1)
9981 delete arg1;
9982 }
9983 {
9984 if (temp2)
9985 delete arg2;
9986 }
9987 return resultobj;
9988 fail:
9989 {
9990 if (temp1)
9991 delete arg1;
9992 }
9993 {
9994 if (temp2)
9995 delete arg2;
9996 }
9997 return NULL;
9998 }
9999
10000
10001 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10002 PyObject *resultobj = 0;
10003 wxSingleInstanceChecker *result = 0 ;
10004
10005 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10020 PyObject *resultobj = 0;
10021 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10022 void *argp1 = 0 ;
10023 int res1 = 0 ;
10024 PyObject *swig_obj[1] ;
10025
10026 if (!args) SWIG_fail;
10027 swig_obj[0] = args;
10028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10029 if (!SWIG_IsOK(res1)) {
10030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10031 }
10032 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10033 {
10034 PyThreadState* __tstate = wxPyBeginAllowThreads();
10035 delete arg1;
10036
10037 wxPyEndAllowThreads(__tstate);
10038 if (PyErr_Occurred()) SWIG_fail;
10039 }
10040 resultobj = SWIG_Py_Void();
10041 return resultobj;
10042 fail:
10043 return NULL;
10044 }
10045
10046
10047 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj = 0;
10049 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10050 wxString *arg2 = 0 ;
10051 wxString const &arg3_defvalue = wxPyEmptyString ;
10052 wxString *arg3 = (wxString *) &arg3_defvalue ;
10053 bool result;
10054 void *argp1 = 0 ;
10055 int res1 = 0 ;
10056 bool temp2 = false ;
10057 bool temp3 = false ;
10058 PyObject * obj0 = 0 ;
10059 PyObject * obj1 = 0 ;
10060 PyObject * obj2 = 0 ;
10061 char * kwnames[] = {
10062 (char *) "self",(char *) "name",(char *) "path", NULL
10063 };
10064
10065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10067 if (!SWIG_IsOK(res1)) {
10068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10069 }
10070 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10071 {
10072 arg2 = wxString_in_helper(obj1);
10073 if (arg2 == NULL) SWIG_fail;
10074 temp2 = true;
10075 }
10076 if (obj2) {
10077 {
10078 arg3 = wxString_in_helper(obj2);
10079 if (arg3 == NULL) SWIG_fail;
10080 temp3 = true;
10081 }
10082 }
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10086 wxPyEndAllowThreads(__tstate);
10087 if (PyErr_Occurred()) SWIG_fail;
10088 }
10089 {
10090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10091 }
10092 {
10093 if (temp2)
10094 delete arg2;
10095 }
10096 {
10097 if (temp3)
10098 delete arg3;
10099 }
10100 return resultobj;
10101 fail:
10102 {
10103 if (temp2)
10104 delete arg2;
10105 }
10106 {
10107 if (temp3)
10108 delete arg3;
10109 }
10110 return NULL;
10111 }
10112
10113
10114 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10115 PyObject *resultobj = 0;
10116 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10117 bool result;
10118 void *argp1 = 0 ;
10119 int res1 = 0 ;
10120 PyObject *swig_obj[1] ;
10121
10122 if (!args) SWIG_fail;
10123 swig_obj[0] = args;
10124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10125 if (!SWIG_IsOK(res1)) {
10126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10127 }
10128 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 {
10136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10137 }
10138 return resultobj;
10139 fail:
10140 return NULL;
10141 }
10142
10143
10144 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145 PyObject *obj;
10146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10147 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10148 return SWIG_Py_Void();
10149 }
10150
10151 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10152 return SWIG_Python_InitShadowInstance(args);
10153 }
10154
10155 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10156 PyObject *resultobj = 0;
10157 wxPlatformInfo *result = 0 ;
10158
10159 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10160 {
10161 PyThreadState* __tstate = wxPyBeginAllowThreads();
10162 result = (wxPlatformInfo *)new wxPlatformInfo();
10163 wxPyEndAllowThreads(__tstate);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj = 0;
10175 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10176 wxPlatformInfo *arg2 = 0 ;
10177 bool result;
10178 void *argp1 = 0 ;
10179 int res1 = 0 ;
10180 void *argp2 = 0 ;
10181 int res2 = 0 ;
10182 PyObject * obj0 = 0 ;
10183 PyObject * obj1 = 0 ;
10184 char * kwnames[] = {
10185 (char *) "self",(char *) "t", NULL
10186 };
10187
10188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10190 if (!SWIG_IsOK(res1)) {
10191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10192 }
10193 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10194 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10195 if (!SWIG_IsOK(res2)) {
10196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10197 }
10198 if (!argp2) {
10199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10200 }
10201 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10202 {
10203 PyThreadState* __tstate = wxPyBeginAllowThreads();
10204 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10205 wxPyEndAllowThreads(__tstate);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 {
10209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10210 }
10211 return resultobj;
10212 fail:
10213 return NULL;
10214 }
10215
10216
10217 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10218 PyObject *resultobj = 0;
10219 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10220 wxPlatformInfo *arg2 = 0 ;
10221 bool result;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 void *argp2 = 0 ;
10225 int res2 = 0 ;
10226 PyObject * obj0 = 0 ;
10227 PyObject * obj1 = 0 ;
10228 char * kwnames[] = {
10229 (char *) "self",(char *) "t", NULL
10230 };
10231
10232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10234 if (!SWIG_IsOK(res1)) {
10235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10236 }
10237 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10238 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10239 if (!SWIG_IsOK(res2)) {
10240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10241 }
10242 if (!argp2) {
10243 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10244 }
10245 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10246 {
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10249 wxPyEndAllowThreads(__tstate);
10250 if (PyErr_Occurred()) SWIG_fail;
10251 }
10252 {
10253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10254 }
10255 return resultobj;
10256 fail:
10257 return NULL;
10258 }
10259
10260
10261 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10262 PyObject *resultobj = 0;
10263 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10264 int result;
10265 void *argp1 = 0 ;
10266 int res1 = 0 ;
10267 PyObject *swig_obj[1] ;
10268
10269 if (!args) SWIG_fail;
10270 swig_obj[0] = args;
10271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10272 if (!SWIG_IsOK(res1)) {
10273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10274 }
10275 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10276 {
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 resultobj = SWIG_From_int(static_cast< int >(result));
10283 return resultobj;
10284 fail:
10285 return NULL;
10286 }
10287
10288
10289 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10290 PyObject *resultobj = 0;
10291 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10292 int result;
10293 void *argp1 = 0 ;
10294 int res1 = 0 ;
10295 PyObject *swig_obj[1] ;
10296
10297 if (!args) SWIG_fail;
10298 swig_obj[0] = args;
10299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10300 if (!SWIG_IsOK(res1)) {
10301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10302 }
10303 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10304 {
10305 PyThreadState* __tstate = wxPyBeginAllowThreads();
10306 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10307 wxPyEndAllowThreads(__tstate);
10308 if (PyErr_Occurred()) SWIG_fail;
10309 }
10310 resultobj = SWIG_From_int(static_cast< int >(result));
10311 return resultobj;
10312 fail:
10313 return NULL;
10314 }
10315
10316
10317 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10318 PyObject *resultobj = 0;
10319 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10320 int arg2 ;
10321 int arg3 ;
10322 bool result;
10323 void *argp1 = 0 ;
10324 int res1 = 0 ;
10325 int val2 ;
10326 int ecode2 = 0 ;
10327 int val3 ;
10328 int ecode3 = 0 ;
10329 PyObject * obj0 = 0 ;
10330 PyObject * obj1 = 0 ;
10331 PyObject * obj2 = 0 ;
10332 char * kwnames[] = {
10333 (char *) "self",(char *) "major",(char *) "minor", NULL
10334 };
10335
10336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10338 if (!SWIG_IsOK(res1)) {
10339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10340 }
10341 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10342 ecode2 = SWIG_AsVal_int(obj1, &val2);
10343 if (!SWIG_IsOK(ecode2)) {
10344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10345 }
10346 arg2 = static_cast< int >(val2);
10347 ecode3 = SWIG_AsVal_int(obj2, &val3);
10348 if (!SWIG_IsOK(ecode3)) {
10349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10350 }
10351 arg3 = static_cast< int >(val3);
10352 {
10353 PyThreadState* __tstate = wxPyBeginAllowThreads();
10354 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10355 wxPyEndAllowThreads(__tstate);
10356 if (PyErr_Occurred()) SWIG_fail;
10357 }
10358 {
10359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10360 }
10361 return resultobj;
10362 fail:
10363 return NULL;
10364 }
10365
10366
10367 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10368 PyObject *resultobj = 0;
10369 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10370 int result;
10371 void *argp1 = 0 ;
10372 int res1 = 0 ;
10373 PyObject *swig_obj[1] ;
10374
10375 if (!args) SWIG_fail;
10376 swig_obj[0] = args;
10377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10378 if (!SWIG_IsOK(res1)) {
10379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10380 }
10381 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10385 wxPyEndAllowThreads(__tstate);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 resultobj = SWIG_From_int(static_cast< int >(result));
10389 return resultobj;
10390 fail:
10391 return NULL;
10392 }
10393
10394
10395 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10396 PyObject *resultobj = 0;
10397 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10398 int result;
10399 void *argp1 = 0 ;
10400 int res1 = 0 ;
10401 PyObject *swig_obj[1] ;
10402
10403 if (!args) SWIG_fail;
10404 swig_obj[0] = args;
10405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10406 if (!SWIG_IsOK(res1)) {
10407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10408 }
10409 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10413 wxPyEndAllowThreads(__tstate);
10414 if (PyErr_Occurred()) SWIG_fail;
10415 }
10416 resultobj = SWIG_From_int(static_cast< int >(result));
10417 return resultobj;
10418 fail:
10419 return NULL;
10420 }
10421
10422
10423 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj = 0;
10425 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10426 int arg2 ;
10427 int arg3 ;
10428 bool result;
10429 void *argp1 = 0 ;
10430 int res1 = 0 ;
10431 int val2 ;
10432 int ecode2 = 0 ;
10433 int val3 ;
10434 int ecode3 = 0 ;
10435 PyObject * obj0 = 0 ;
10436 PyObject * obj1 = 0 ;
10437 PyObject * obj2 = 0 ;
10438 char * kwnames[] = {
10439 (char *) "self",(char *) "major",(char *) "minor", NULL
10440 };
10441
10442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10444 if (!SWIG_IsOK(res1)) {
10445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10446 }
10447 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10448 ecode2 = SWIG_AsVal_int(obj1, &val2);
10449 if (!SWIG_IsOK(ecode2)) {
10450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10451 }
10452 arg2 = static_cast< int >(val2);
10453 ecode3 = SWIG_AsVal_int(obj2, &val3);
10454 if (!SWIG_IsOK(ecode3)) {
10455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10456 }
10457 arg3 = static_cast< int >(val3);
10458 {
10459 PyThreadState* __tstate = wxPyBeginAllowThreads();
10460 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10461 wxPyEndAllowThreads(__tstate);
10462 if (PyErr_Occurred()) SWIG_fail;
10463 }
10464 {
10465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10466 }
10467 return resultobj;
10468 fail:
10469 return NULL;
10470 }
10471
10472
10473 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10474 PyObject *resultobj = 0;
10475 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10476 bool result;
10477 void *argp1 = 0 ;
10478 int res1 = 0 ;
10479 PyObject *swig_obj[1] ;
10480
10481 if (!args) SWIG_fail;
10482 swig_obj[0] = args;
10483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10484 if (!SWIG_IsOK(res1)) {
10485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10486 }
10487 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 {
10495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10496 }
10497 return resultobj;
10498 fail:
10499 return NULL;
10500 }
10501
10502
10503 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10504 PyObject *resultobj = 0;
10505 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10506 wxOperatingSystemId result;
10507 void *argp1 = 0 ;
10508 int res1 = 0 ;
10509 PyObject *swig_obj[1] ;
10510
10511 if (!args) SWIG_fail;
10512 swig_obj[0] = args;
10513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10514 if (!SWIG_IsOK(res1)) {
10515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10516 }
10517 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10518 {
10519 PyThreadState* __tstate = wxPyBeginAllowThreads();
10520 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10521 wxPyEndAllowThreads(__tstate);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 resultobj = SWIG_From_int(static_cast< int >(result));
10525 return resultobj;
10526 fail:
10527 return NULL;
10528 }
10529
10530
10531 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10532 PyObject *resultobj = 0;
10533 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10534 wxPortId result;
10535 void *argp1 = 0 ;
10536 int res1 = 0 ;
10537 PyObject *swig_obj[1] ;
10538
10539 if (!args) SWIG_fail;
10540 swig_obj[0] = args;
10541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10542 if (!SWIG_IsOK(res1)) {
10543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10544 }
10545 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10549 wxPyEndAllowThreads(__tstate);
10550 if (PyErr_Occurred()) SWIG_fail;
10551 }
10552 resultobj = SWIG_From_int(static_cast< int >(result));
10553 return resultobj;
10554 fail:
10555 return NULL;
10556 }
10557
10558
10559 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10560 PyObject *resultobj = 0;
10561 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10562 wxArchitecture result;
10563 void *argp1 = 0 ;
10564 int res1 = 0 ;
10565 PyObject *swig_obj[1] ;
10566
10567 if (!args) SWIG_fail;
10568 swig_obj[0] = args;
10569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10570 if (!SWIG_IsOK(res1)) {
10571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10572 }
10573 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 resultobj = SWIG_From_int(static_cast< int >(result));
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10588 PyObject *resultobj = 0;
10589 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10590 wxEndianness result;
10591 void *argp1 = 0 ;
10592 int res1 = 0 ;
10593 PyObject *swig_obj[1] ;
10594
10595 if (!args) SWIG_fail;
10596 swig_obj[0] = args;
10597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10598 if (!SWIG_IsOK(res1)) {
10599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10600 }
10601 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10602 {
10603 PyThreadState* __tstate = wxPyBeginAllowThreads();
10604 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 resultobj = SWIG_From_int(static_cast< int >(result));
10609 return resultobj;
10610 fail:
10611 return NULL;
10612 }
10613
10614
10615 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10616 PyObject *resultobj = 0;
10617 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10618 wxString result;
10619 void *argp1 = 0 ;
10620 int res1 = 0 ;
10621 PyObject *swig_obj[1] ;
10622
10623 if (!args) SWIG_fail;
10624 swig_obj[0] = args;
10625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10626 if (!SWIG_IsOK(res1)) {
10627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10628 }
10629 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 {
10637 #if wxUSE_UNICODE
10638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10639 #else
10640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10641 #endif
10642 }
10643 return resultobj;
10644 fail:
10645 return NULL;
10646 }
10647
10648
10649 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10650 PyObject *resultobj = 0;
10651 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10652 wxString result;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 PyObject *swig_obj[1] ;
10656
10657 if (!args) SWIG_fail;
10658 swig_obj[0] = args;
10659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10660 if (!SWIG_IsOK(res1)) {
10661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10662 }
10663 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 #if wxUSE_UNICODE
10672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10673 #else
10674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10675 #endif
10676 }
10677 return resultobj;
10678 fail:
10679 return NULL;
10680 }
10681
10682
10683 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10684 PyObject *resultobj = 0;
10685 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10686 wxString result;
10687 void *argp1 = 0 ;
10688 int res1 = 0 ;
10689 PyObject *swig_obj[1] ;
10690
10691 if (!args) SWIG_fail;
10692 swig_obj[0] = args;
10693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10694 if (!SWIG_IsOK(res1)) {
10695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10696 }
10697 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10698 {
10699 PyThreadState* __tstate = wxPyBeginAllowThreads();
10700 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 {
10705 #if wxUSE_UNICODE
10706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10707 #else
10708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10709 #endif
10710 }
10711 return resultobj;
10712 fail:
10713 return NULL;
10714 }
10715
10716
10717 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10718 PyObject *resultobj = 0;
10719 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10720 wxString result;
10721 void *argp1 = 0 ;
10722 int res1 = 0 ;
10723 PyObject *swig_obj[1] ;
10724
10725 if (!args) SWIG_fail;
10726 swig_obj[0] = args;
10727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10728 if (!SWIG_IsOK(res1)) {
10729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10730 }
10731 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10732 {
10733 PyThreadState* __tstate = wxPyBeginAllowThreads();
10734 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 {
10739 #if wxUSE_UNICODE
10740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10741 #else
10742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10743 #endif
10744 }
10745 return resultobj;
10746 fail:
10747 return NULL;
10748 }
10749
10750
10751 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10752 PyObject *resultobj = 0;
10753 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10754 wxString result;
10755 void *argp1 = 0 ;
10756 int res1 = 0 ;
10757 PyObject *swig_obj[1] ;
10758
10759 if (!args) SWIG_fail;
10760 swig_obj[0] = args;
10761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10762 if (!SWIG_IsOK(res1)) {
10763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10764 }
10765 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10769 wxPyEndAllowThreads(__tstate);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 {
10773 #if wxUSE_UNICODE
10774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10775 #else
10776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10777 #endif
10778 }
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10786 PyObject *resultobj = 0;
10787 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10788 wxString result;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 PyObject *swig_obj[1] ;
10792
10793 if (!args) SWIG_fail;
10794 swig_obj[0] = args;
10795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10796 if (!SWIG_IsOK(res1)) {
10797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10798 }
10799 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 #if wxUSE_UNICODE
10808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10809 #else
10810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10811 #endif
10812 }
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10822 int arg2 ;
10823 int arg3 ;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 int val2 ;
10827 int ecode2 = 0 ;
10828 int val3 ;
10829 int ecode3 = 0 ;
10830 PyObject * obj0 = 0 ;
10831 PyObject * obj1 = 0 ;
10832 PyObject * obj2 = 0 ;
10833 char * kwnames[] = {
10834 (char *) "self",(char *) "major",(char *) "minor", NULL
10835 };
10836
10837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10839 if (!SWIG_IsOK(res1)) {
10840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10841 }
10842 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10843 ecode2 = SWIG_AsVal_int(obj1, &val2);
10844 if (!SWIG_IsOK(ecode2)) {
10845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10846 }
10847 arg2 = static_cast< int >(val2);
10848 ecode3 = SWIG_AsVal_int(obj2, &val3);
10849 if (!SWIG_IsOK(ecode3)) {
10850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10851 }
10852 arg3 = static_cast< int >(val3);
10853 {
10854 PyThreadState* __tstate = wxPyBeginAllowThreads();
10855 (arg1)->SetOSVersion(arg2,arg3);
10856 wxPyEndAllowThreads(__tstate);
10857 if (PyErr_Occurred()) SWIG_fail;
10858 }
10859 resultobj = SWIG_Py_Void();
10860 return resultobj;
10861 fail:
10862 return NULL;
10863 }
10864
10865
10866 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10867 PyObject *resultobj = 0;
10868 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10869 int arg2 ;
10870 int arg3 ;
10871 void *argp1 = 0 ;
10872 int res1 = 0 ;
10873 int val2 ;
10874 int ecode2 = 0 ;
10875 int val3 ;
10876 int ecode3 = 0 ;
10877 PyObject * obj0 = 0 ;
10878 PyObject * obj1 = 0 ;
10879 PyObject * obj2 = 0 ;
10880 char * kwnames[] = {
10881 (char *) "self",(char *) "major",(char *) "minor", NULL
10882 };
10883
10884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10886 if (!SWIG_IsOK(res1)) {
10887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10888 }
10889 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10890 ecode2 = SWIG_AsVal_int(obj1, &val2);
10891 if (!SWIG_IsOK(ecode2)) {
10892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10893 }
10894 arg2 = static_cast< int >(val2);
10895 ecode3 = SWIG_AsVal_int(obj2, &val3);
10896 if (!SWIG_IsOK(ecode3)) {
10897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10898 }
10899 arg3 = static_cast< int >(val3);
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 (arg1)->SetToolkitVersion(arg2,arg3);
10903 wxPyEndAllowThreads(__tstate);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 resultobj = SWIG_Py_Void();
10907 return resultobj;
10908 fail:
10909 return NULL;
10910 }
10911
10912
10913 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10914 PyObject *resultobj = 0;
10915 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10916 wxOperatingSystemId arg2 ;
10917 void *argp1 = 0 ;
10918 int res1 = 0 ;
10919 int val2 ;
10920 int ecode2 = 0 ;
10921 PyObject * obj0 = 0 ;
10922 PyObject * obj1 = 0 ;
10923 char * kwnames[] = {
10924 (char *) "self",(char *) "n", NULL
10925 };
10926
10927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10929 if (!SWIG_IsOK(res1)) {
10930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10931 }
10932 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10933 ecode2 = SWIG_AsVal_int(obj1, &val2);
10934 if (!SWIG_IsOK(ecode2)) {
10935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10936 }
10937 arg2 = static_cast< wxOperatingSystemId >(val2);
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 (arg1)->SetOperatingSystemId(arg2);
10941 wxPyEndAllowThreads(__tstate);
10942 if (PyErr_Occurred()) SWIG_fail;
10943 }
10944 resultobj = SWIG_Py_Void();
10945 return resultobj;
10946 fail:
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10954 wxPortId arg2 ;
10955 void *argp1 = 0 ;
10956 int res1 = 0 ;
10957 int val2 ;
10958 int ecode2 = 0 ;
10959 PyObject * obj0 = 0 ;
10960 PyObject * obj1 = 0 ;
10961 char * kwnames[] = {
10962 (char *) "self",(char *) "n", NULL
10963 };
10964
10965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10967 if (!SWIG_IsOK(res1)) {
10968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10969 }
10970 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10971 ecode2 = SWIG_AsVal_int(obj1, &val2);
10972 if (!SWIG_IsOK(ecode2)) {
10973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10974 }
10975 arg2 = static_cast< wxPortId >(val2);
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 (arg1)->SetPortId(arg2);
10979 wxPyEndAllowThreads(__tstate);
10980 if (PyErr_Occurred()) SWIG_fail;
10981 }
10982 resultobj = SWIG_Py_Void();
10983 return resultobj;
10984 fail:
10985 return NULL;
10986 }
10987
10988
10989 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10990 PyObject *resultobj = 0;
10991 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10992 wxArchitecture arg2 ;
10993 void *argp1 = 0 ;
10994 int res1 = 0 ;
10995 int val2 ;
10996 int ecode2 = 0 ;
10997 PyObject * obj0 = 0 ;
10998 PyObject * obj1 = 0 ;
10999 char * kwnames[] = {
11000 (char *) "self",(char *) "n", NULL
11001 };
11002
11003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
11004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11005 if (!SWIG_IsOK(res1)) {
11006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11007 }
11008 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11009 ecode2 = SWIG_AsVal_int(obj1, &val2);
11010 if (!SWIG_IsOK(ecode2)) {
11011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11012 }
11013 arg2 = static_cast< wxArchitecture >(val2);
11014 {
11015 PyThreadState* __tstate = wxPyBeginAllowThreads();
11016 (arg1)->SetArchitecture(arg2);
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 resultobj = SWIG_Py_Void();
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj = 0;
11029 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11030 wxEndianness arg2 ;
11031 void *argp1 = 0 ;
11032 int res1 = 0 ;
11033 int val2 ;
11034 int ecode2 = 0 ;
11035 PyObject * obj0 = 0 ;
11036 PyObject * obj1 = 0 ;
11037 char * kwnames[] = {
11038 (char *) "self",(char *) "n", NULL
11039 };
11040
11041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11043 if (!SWIG_IsOK(res1)) {
11044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11045 }
11046 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11047 ecode2 = SWIG_AsVal_int(obj1, &val2);
11048 if (!SWIG_IsOK(ecode2)) {
11049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11050 }
11051 arg2 = static_cast< wxEndianness >(val2);
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 (arg1)->SetEndianness(arg2);
11055 wxPyEndAllowThreads(__tstate);
11056 if (PyErr_Occurred()) SWIG_fail;
11057 }
11058 resultobj = SWIG_Py_Void();
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11066 PyObject *resultobj = 0;
11067 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11068 bool result;
11069 void *argp1 = 0 ;
11070 int res1 = 0 ;
11071 PyObject *swig_obj[1] ;
11072
11073 if (!args) SWIG_fail;
11074 swig_obj[0] = args;
11075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11076 if (!SWIG_IsOK(res1)) {
11077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11078 }
11079 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11083 wxPyEndAllowThreads(__tstate);
11084 if (PyErr_Occurred()) SWIG_fail;
11085 }
11086 {
11087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11088 }
11089 return resultobj;
11090 fail:
11091 return NULL;
11092 }
11093
11094
11095 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11096 PyObject *obj;
11097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11098 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11099 return SWIG_Py_Void();
11100 }
11101
11102 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11103 return SWIG_Python_InitShadowInstance(args);
11104 }
11105
11106 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11107 PyObject *resultobj = 0;
11108 wxWindow *arg1 = (wxWindow *) 0 ;
11109 wxDC *arg2 = 0 ;
11110 bool result;
11111 void *argp1 = 0 ;
11112 int res1 = 0 ;
11113 void *argp2 = 0 ;
11114 int res2 = 0 ;
11115 PyObject * obj0 = 0 ;
11116 PyObject * obj1 = 0 ;
11117 char * kwnames[] = {
11118 (char *) "window",(char *) "dc", NULL
11119 };
11120
11121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11123 if (!SWIG_IsOK(res1)) {
11124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11125 }
11126 arg1 = reinterpret_cast< wxWindow * >(argp1);
11127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11128 if (!SWIG_IsOK(res2)) {
11129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11130 }
11131 if (!argp2) {
11132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11133 }
11134 arg2 = reinterpret_cast< wxDC * >(argp2);
11135 {
11136 PyThreadState* __tstate = wxPyBeginAllowThreads();
11137 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 {
11142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11143 }
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11151 PyObject *resultobj = 0;
11152 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11153 void *argp1 = 0 ;
11154 int res1 = 0 ;
11155 PyObject *swig_obj[1] ;
11156
11157 if (!args) SWIG_fail;
11158 swig_obj[0] = args;
11159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11160 if (!SWIG_IsOK(res1)) {
11161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11162 }
11163 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11164 {
11165 PyThreadState* __tstate = wxPyBeginAllowThreads();
11166 delete arg1;
11167
11168 wxPyEndAllowThreads(__tstate);
11169 if (PyErr_Occurred()) SWIG_fail;
11170 }
11171 resultobj = SWIG_Py_Void();
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11179 PyObject *resultobj = 0;
11180 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11181 wxString result;
11182 void *argp1 = 0 ;
11183 int res1 = 0 ;
11184 PyObject *swig_obj[1] ;
11185
11186 if (!args) SWIG_fail;
11187 swig_obj[0] = args;
11188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11189 if (!SWIG_IsOK(res1)) {
11190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11191 }
11192 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11193 {
11194 PyThreadState* __tstate = wxPyBeginAllowThreads();
11195 result = (arg1)->GetTip();
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 {
11200 #if wxUSE_UNICODE
11201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11202 #else
11203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11204 #endif
11205 }
11206 return resultobj;
11207 fail:
11208 return NULL;
11209 }
11210
11211
11212 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11213 PyObject *resultobj = 0;
11214 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11215 size_t result;
11216 void *argp1 = 0 ;
11217 int res1 = 0 ;
11218 PyObject *swig_obj[1] ;
11219
11220 if (!args) SWIG_fail;
11221 swig_obj[0] = args;
11222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11223 if (!SWIG_IsOK(res1)) {
11224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11225 }
11226 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 result = (size_t)(arg1)->GetCurrentTip();
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11241 PyObject *resultobj = 0;
11242 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11243 wxString *arg2 = 0 ;
11244 wxString result;
11245 void *argp1 = 0 ;
11246 int res1 = 0 ;
11247 bool temp2 = false ;
11248 PyObject * obj0 = 0 ;
11249 PyObject * obj1 = 0 ;
11250 char * kwnames[] = {
11251 (char *) "self",(char *) "tip", NULL
11252 };
11253
11254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11256 if (!SWIG_IsOK(res1)) {
11257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11258 }
11259 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11260 {
11261 arg2 = wxString_in_helper(obj1);
11262 if (arg2 == NULL) SWIG_fail;
11263 temp2 = true;
11264 }
11265 {
11266 PyThreadState* __tstate = wxPyBeginAllowThreads();
11267 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11268 wxPyEndAllowThreads(__tstate);
11269 if (PyErr_Occurred()) SWIG_fail;
11270 }
11271 {
11272 #if wxUSE_UNICODE
11273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11274 #else
11275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11276 #endif
11277 }
11278 {
11279 if (temp2)
11280 delete arg2;
11281 }
11282 return resultobj;
11283 fail:
11284 {
11285 if (temp2)
11286 delete arg2;
11287 }
11288 return NULL;
11289 }
11290
11291
11292 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11293 PyObject *obj;
11294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11295 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11296 return SWIG_Py_Void();
11297 }
11298
11299 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11300 PyObject *resultobj = 0;
11301 size_t arg1 ;
11302 wxPyTipProvider *result = 0 ;
11303 size_t val1 ;
11304 int ecode1 = 0 ;
11305 PyObject * obj0 = 0 ;
11306 char * kwnames[] = {
11307 (char *) "currentTip", NULL
11308 };
11309
11310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11311 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11312 if (!SWIG_IsOK(ecode1)) {
11313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11314 }
11315 arg1 = static_cast< size_t >(val1);
11316 {
11317 PyThreadState* __tstate = wxPyBeginAllowThreads();
11318 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11319 wxPyEndAllowThreads(__tstate);
11320 if (PyErr_Occurred()) SWIG_fail;
11321 }
11322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11330 PyObject *resultobj = 0;
11331 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11332 PyObject *arg2 = (PyObject *) 0 ;
11333 PyObject *arg3 = (PyObject *) 0 ;
11334 void *argp1 = 0 ;
11335 int res1 = 0 ;
11336 PyObject * obj0 = 0 ;
11337 PyObject * obj1 = 0 ;
11338 PyObject * obj2 = 0 ;
11339 char * kwnames[] = {
11340 (char *) "self",(char *) "self",(char *) "_class", NULL
11341 };
11342
11343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11345 if (!SWIG_IsOK(res1)) {
11346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11347 }
11348 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11349 arg2 = obj1;
11350 arg3 = obj2;
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 (arg1)->_setCallbackInfo(arg2,arg3);
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 return resultobj;
11359 fail:
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11365 PyObject *obj;
11366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11367 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11368 return SWIG_Py_Void();
11369 }
11370
11371 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11372 return SWIG_Python_InitShadowInstance(args);
11373 }
11374
11375 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11376 PyObject *resultobj = 0;
11377 wxWindow *arg1 = (wxWindow *) 0 ;
11378 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11379 bool arg3 = (bool) true ;
11380 bool result;
11381 void *argp1 = 0 ;
11382 int res1 = 0 ;
11383 void *argp2 = 0 ;
11384 int res2 = 0 ;
11385 bool val3 ;
11386 int ecode3 = 0 ;
11387 PyObject * obj0 = 0 ;
11388 PyObject * obj1 = 0 ;
11389 PyObject * obj2 = 0 ;
11390 char * kwnames[] = {
11391 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11392 };
11393
11394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11396 if (!SWIG_IsOK(res1)) {
11397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11398 }
11399 arg1 = reinterpret_cast< wxWindow * >(argp1);
11400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11401 if (!SWIG_IsOK(res2)) {
11402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11403 }
11404 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11405 if (obj2) {
11406 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11407 if (!SWIG_IsOK(ecode3)) {
11408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11409 }
11410 arg3 = static_cast< bool >(val3);
11411 }
11412 {
11413 if (!wxPyCheckForApp()) SWIG_fail;
11414 PyThreadState* __tstate = wxPyBeginAllowThreads();
11415 result = (bool)wxShowTip(arg1,arg2,arg3);
11416 wxPyEndAllowThreads(__tstate);
11417 if (PyErr_Occurred()) SWIG_fail;
11418 }
11419 {
11420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11421 }
11422 return resultobj;
11423 fail:
11424 return NULL;
11425 }
11426
11427
11428 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11429 PyObject *resultobj = 0;
11430 wxString *arg1 = 0 ;
11431 size_t arg2 ;
11432 wxTipProvider *result = 0 ;
11433 bool temp1 = false ;
11434 size_t val2 ;
11435 int ecode2 = 0 ;
11436 PyObject * obj0 = 0 ;
11437 PyObject * obj1 = 0 ;
11438 char * kwnames[] = {
11439 (char *) "filename",(char *) "currentTip", NULL
11440 };
11441
11442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11443 {
11444 arg1 = wxString_in_helper(obj0);
11445 if (arg1 == NULL) SWIG_fail;
11446 temp1 = true;
11447 }
11448 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11449 if (!SWIG_IsOK(ecode2)) {
11450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11451 }
11452 arg2 = static_cast< size_t >(val2);
11453 {
11454 if (!wxPyCheckForApp()) SWIG_fail;
11455 PyThreadState* __tstate = wxPyBeginAllowThreads();
11456 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11461 {
11462 if (temp1)
11463 delete arg1;
11464 }
11465 return resultobj;
11466 fail:
11467 {
11468 if (temp1)
11469 delete arg1;
11470 }
11471 return NULL;
11472 }
11473
11474
11475 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11476 PyObject *resultobj = 0;
11477 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11478 int arg2 = (int) wxID_ANY ;
11479 wxPyTimer *result = 0 ;
11480 void *argp1 = 0 ;
11481 int res1 = 0 ;
11482 int val2 ;
11483 int ecode2 = 0 ;
11484 PyObject * obj0 = 0 ;
11485 PyObject * obj1 = 0 ;
11486 char * kwnames[] = {
11487 (char *) "owner",(char *) "id", NULL
11488 };
11489
11490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11491 if (obj0) {
11492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11493 if (!SWIG_IsOK(res1)) {
11494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11495 }
11496 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11497 }
11498 if (obj1) {
11499 ecode2 = SWIG_AsVal_int(obj1, &val2);
11500 if (!SWIG_IsOK(ecode2)) {
11501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11502 }
11503 arg2 = static_cast< int >(val2);
11504 }
11505 {
11506 if (!wxPyCheckForApp()) SWIG_fail;
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11509 wxPyEndAllowThreads(__tstate);
11510 if (PyErr_Occurred()) SWIG_fail;
11511 }
11512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11513 return resultobj;
11514 fail:
11515 return NULL;
11516 }
11517
11518
11519 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11520 PyObject *resultobj = 0;
11521 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11522 void *argp1 = 0 ;
11523 int res1 = 0 ;
11524 PyObject *swig_obj[1] ;
11525
11526 if (!args) SWIG_fail;
11527 swig_obj[0] = args;
11528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11529 if (!SWIG_IsOK(res1)) {
11530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11531 }
11532 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 delete arg1;
11536
11537 wxPyEndAllowThreads(__tstate);
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 resultobj = SWIG_Py_Void();
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11548 PyObject *resultobj = 0;
11549 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11550 PyObject *arg2 = (PyObject *) 0 ;
11551 PyObject *arg3 = (PyObject *) 0 ;
11552 int arg4 = (int) 0 ;
11553 void *argp1 = 0 ;
11554 int res1 = 0 ;
11555 int val4 ;
11556 int ecode4 = 0 ;
11557 PyObject * obj0 = 0 ;
11558 PyObject * obj1 = 0 ;
11559 PyObject * obj2 = 0 ;
11560 PyObject * obj3 = 0 ;
11561 char * kwnames[] = {
11562 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11563 };
11564
11565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11567 if (!SWIG_IsOK(res1)) {
11568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11569 }
11570 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11571 arg2 = obj1;
11572 arg3 = obj2;
11573 if (obj3) {
11574 ecode4 = SWIG_AsVal_int(obj3, &val4);
11575 if (!SWIG_IsOK(ecode4)) {
11576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11577 }
11578 arg4 = static_cast< int >(val4);
11579 }
11580 {
11581 PyThreadState* __tstate = wxPyBeginAllowThreads();
11582 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11583 wxPyEndAllowThreads(__tstate);
11584 if (PyErr_Occurred()) SWIG_fail;
11585 }
11586 resultobj = SWIG_Py_Void();
11587 return resultobj;
11588 fail:
11589 return NULL;
11590 }
11591
11592
11593 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11594 PyObject *resultobj = 0;
11595 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11596 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11597 int arg3 = (int) wxID_ANY ;
11598 void *argp1 = 0 ;
11599 int res1 = 0 ;
11600 void *argp2 = 0 ;
11601 int res2 = 0 ;
11602 int val3 ;
11603 int ecode3 = 0 ;
11604 PyObject * obj0 = 0 ;
11605 PyObject * obj1 = 0 ;
11606 PyObject * obj2 = 0 ;
11607 char * kwnames[] = {
11608 (char *) "self",(char *) "owner",(char *) "id", NULL
11609 };
11610
11611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11613 if (!SWIG_IsOK(res1)) {
11614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11615 }
11616 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11618 if (!SWIG_IsOK(res2)) {
11619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11620 }
11621 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11622 if (obj2) {
11623 ecode3 = SWIG_AsVal_int(obj2, &val3);
11624 if (!SWIG_IsOK(ecode3)) {
11625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11626 }
11627 arg3 = static_cast< int >(val3);
11628 }
11629 {
11630 PyThreadState* __tstate = wxPyBeginAllowThreads();
11631 (arg1)->SetOwner(arg2,arg3);
11632 wxPyEndAllowThreads(__tstate);
11633 if (PyErr_Occurred()) SWIG_fail;
11634 }
11635 resultobj = SWIG_Py_Void();
11636 return resultobj;
11637 fail:
11638 return NULL;
11639 }
11640
11641
11642 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11643 PyObject *resultobj = 0;
11644 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11645 wxEvtHandler *result = 0 ;
11646 void *argp1 = 0 ;
11647 int res1 = 0 ;
11648 PyObject *swig_obj[1] ;
11649
11650 if (!args) SWIG_fail;
11651 swig_obj[0] = args;
11652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11655 }
11656 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (wxEvtHandler *)(arg1)->GetOwner();
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 {
11664 resultobj = wxPyMake_wxObject(result, 0);
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11673 PyObject *resultobj = 0;
11674 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11675 int arg2 = (int) -1 ;
11676 bool arg3 = (bool) false ;
11677 bool result;
11678 void *argp1 = 0 ;
11679 int res1 = 0 ;
11680 int val2 ;
11681 int ecode2 = 0 ;
11682 bool val3 ;
11683 int ecode3 = 0 ;
11684 PyObject * obj0 = 0 ;
11685 PyObject * obj1 = 0 ;
11686 PyObject * obj2 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11695 }
11696 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11697 if (obj1) {
11698 ecode2 = SWIG_AsVal_int(obj1, &val2);
11699 if (!SWIG_IsOK(ecode2)) {
11700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11701 }
11702 arg2 = static_cast< int >(val2);
11703 }
11704 if (obj2) {
11705 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11706 if (!SWIG_IsOK(ecode3)) {
11707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11708 }
11709 arg3 = static_cast< bool >(val3);
11710 }
11711 {
11712 PyThreadState* __tstate = wxPyBeginAllowThreads();
11713 result = (bool)(arg1)->Start(arg2,arg3);
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 {
11718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11727 PyObject *resultobj = 0;
11728 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11729 void *argp1 = 0 ;
11730 int res1 = 0 ;
11731 PyObject *swig_obj[1] ;
11732
11733 if (!args) SWIG_fail;
11734 swig_obj[0] = args;
11735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11736 if (!SWIG_IsOK(res1)) {
11737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11738 }
11739 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 (arg1)->Stop();
11743 wxPyEndAllowThreads(__tstate);
11744 if (PyErr_Occurred()) SWIG_fail;
11745 }
11746 resultobj = SWIG_Py_Void();
11747 return resultobj;
11748 fail:
11749 return NULL;
11750 }
11751
11752
11753 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11754 PyObject *resultobj = 0;
11755 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11756 void *argp1 = 0 ;
11757 int res1 = 0 ;
11758 PyObject *swig_obj[1] ;
11759
11760 if (!args) SWIG_fail;
11761 swig_obj[0] = args;
11762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11763 if (!SWIG_IsOK(res1)) {
11764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11765 }
11766 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 (arg1)->Notify();
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 resultobj = SWIG_Py_Void();
11774 return resultobj;
11775 fail:
11776 return NULL;
11777 }
11778
11779
11780 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11781 PyObject *resultobj = 0;
11782 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11783 bool result;
11784 void *argp1 = 0 ;
11785 int res1 = 0 ;
11786 PyObject *swig_obj[1] ;
11787
11788 if (!args) SWIG_fail;
11789 swig_obj[0] = args;
11790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11791 if (!SWIG_IsOK(res1)) {
11792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11793 }
11794 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11795 {
11796 PyThreadState* __tstate = wxPyBeginAllowThreads();
11797 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11798 wxPyEndAllowThreads(__tstate);
11799 if (PyErr_Occurred()) SWIG_fail;
11800 }
11801 {
11802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11803 }
11804 return resultobj;
11805 fail:
11806 return NULL;
11807 }
11808
11809
11810 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11811 PyObject *resultobj = 0;
11812 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11813 int result;
11814 void *argp1 = 0 ;
11815 int res1 = 0 ;
11816 PyObject *swig_obj[1] ;
11817
11818 if (!args) SWIG_fail;
11819 swig_obj[0] = args;
11820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11821 if (!SWIG_IsOK(res1)) {
11822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11823 }
11824 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11825 {
11826 PyThreadState* __tstate = wxPyBeginAllowThreads();
11827 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 resultobj = SWIG_From_int(static_cast< int >(result));
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11839 PyObject *resultobj = 0;
11840 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11841 int result;
11842 void *argp1 = 0 ;
11843 int res1 = 0 ;
11844 PyObject *swig_obj[1] ;
11845
11846 if (!args) SWIG_fail;
11847 swig_obj[0] = args;
11848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11849 if (!SWIG_IsOK(res1)) {
11850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11851 }
11852 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 result = (int)((wxPyTimer const *)arg1)->GetId();
11856 wxPyEndAllowThreads(__tstate);
11857 if (PyErr_Occurred()) SWIG_fail;
11858 }
11859 resultobj = SWIG_From_int(static_cast< int >(result));
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11867 PyObject *resultobj = 0;
11868 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11869 bool result;
11870 void *argp1 = 0 ;
11871 int res1 = 0 ;
11872 PyObject *swig_obj[1] ;
11873
11874 if (!args) SWIG_fail;
11875 swig_obj[0] = args;
11876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11877 if (!SWIG_IsOK(res1)) {
11878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11879 }
11880 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 {
11888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11889 }
11890 return resultobj;
11891 fail:
11892 return NULL;
11893 }
11894
11895
11896 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11897 PyObject *obj;
11898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11899 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11900 return SWIG_Py_Void();
11901 }
11902
11903 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11904 return SWIG_Python_InitShadowInstance(args);
11905 }
11906
11907 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11908 PyObject *resultobj = 0;
11909 int arg1 = (int) 0 ;
11910 int arg2 = (int) 0 ;
11911 wxTimerEvent *result = 0 ;
11912 int val1 ;
11913 int ecode1 = 0 ;
11914 int val2 ;
11915 int ecode2 = 0 ;
11916 PyObject * obj0 = 0 ;
11917 PyObject * obj1 = 0 ;
11918 char * kwnames[] = {
11919 (char *) "timerid",(char *) "interval", NULL
11920 };
11921
11922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11923 if (obj0) {
11924 ecode1 = SWIG_AsVal_int(obj0, &val1);
11925 if (!SWIG_IsOK(ecode1)) {
11926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11927 }
11928 arg1 = static_cast< int >(val1);
11929 }
11930 if (obj1) {
11931 ecode2 = SWIG_AsVal_int(obj1, &val2);
11932 if (!SWIG_IsOK(ecode2)) {
11933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11934 }
11935 arg2 = static_cast< int >(val2);
11936 }
11937 {
11938 PyThreadState* __tstate = wxPyBeginAllowThreads();
11939 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11940 wxPyEndAllowThreads(__tstate);
11941 if (PyErr_Occurred()) SWIG_fail;
11942 }
11943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11951 PyObject *resultobj = 0;
11952 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11953 int result;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 PyObject *swig_obj[1] ;
11957
11958 if (!args) SWIG_fail;
11959 swig_obj[0] = args;
11960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11961 if (!SWIG_IsOK(res1)) {
11962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11963 }
11964 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 resultobj = SWIG_From_int(static_cast< int >(result));
11972 return resultobj;
11973 fail:
11974 return NULL;
11975 }
11976
11977
11978 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11979 PyObject *obj;
11980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11981 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11982 return SWIG_Py_Void();
11983 }
11984
11985 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11986 return SWIG_Python_InitShadowInstance(args);
11987 }
11988
11989 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11990 PyObject *resultobj = 0;
11991 wxTimer *arg1 = 0 ;
11992 wxTimerRunner *result = 0 ;
11993 void *argp1 = 0 ;
11994 int res1 = 0 ;
11995
11996 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11998 if (!SWIG_IsOK(res1)) {
11999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12000 }
12001 if (!argp1) {
12002 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12003 }
12004 arg1 = reinterpret_cast< wxTimer * >(argp1);
12005 {
12006 if (!wxPyCheckForApp()) SWIG_fail;
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12020 PyObject *resultobj = 0;
12021 wxTimer *arg1 = 0 ;
12022 int arg2 ;
12023 bool arg3 = (bool) false ;
12024 wxTimerRunner *result = 0 ;
12025 void *argp1 = 0 ;
12026 int res1 = 0 ;
12027 int val2 ;
12028 int ecode2 = 0 ;
12029 bool val3 ;
12030 int ecode3 = 0 ;
12031
12032 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12034 if (!SWIG_IsOK(res1)) {
12035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12036 }
12037 if (!argp1) {
12038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12039 }
12040 arg1 = reinterpret_cast< wxTimer * >(argp1);
12041 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12042 if (!SWIG_IsOK(ecode2)) {
12043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12044 }
12045 arg2 = static_cast< int >(val2);
12046 if (swig_obj[2]) {
12047 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12048 if (!SWIG_IsOK(ecode3)) {
12049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12050 }
12051 arg3 = static_cast< bool >(val3);
12052 }
12053 {
12054 if (!wxPyCheckForApp()) SWIG_fail;
12055 PyThreadState* __tstate = wxPyBeginAllowThreads();
12056 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12061 return resultobj;
12062 fail:
12063 return NULL;
12064 }
12065
12066
12067 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12068 int argc;
12069 PyObject *argv[4];
12070
12071 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12072 --argc;
12073 if (argc == 1) {
12074 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12075 }
12076 if ((argc >= 2) && (argc <= 3)) {
12077 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12078 }
12079
12080 fail:
12081 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12082 return NULL;
12083 }
12084
12085
12086 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12087 PyObject *resultobj = 0;
12088 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12089 void *argp1 = 0 ;
12090 int res1 = 0 ;
12091 PyObject *swig_obj[1] ;
12092
12093 if (!args) SWIG_fail;
12094 swig_obj[0] = args;
12095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12096 if (!SWIG_IsOK(res1)) {
12097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12098 }
12099 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 delete arg1;
12103
12104 wxPyEndAllowThreads(__tstate);
12105 if (PyErr_Occurred()) SWIG_fail;
12106 }
12107 resultobj = SWIG_Py_Void();
12108 return resultobj;
12109 fail:
12110 return NULL;
12111 }
12112
12113
12114 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12115 PyObject *resultobj = 0;
12116 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12117 int arg2 ;
12118 bool arg3 = (bool) false ;
12119 void *argp1 = 0 ;
12120 int res1 = 0 ;
12121 int val2 ;
12122 int ecode2 = 0 ;
12123 bool val3 ;
12124 int ecode3 = 0 ;
12125 PyObject * obj0 = 0 ;
12126 PyObject * obj1 = 0 ;
12127 PyObject * obj2 = 0 ;
12128 char * kwnames[] = {
12129 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12130 };
12131
12132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12134 if (!SWIG_IsOK(res1)) {
12135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12136 }
12137 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12138 ecode2 = SWIG_AsVal_int(obj1, &val2);
12139 if (!SWIG_IsOK(ecode2)) {
12140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12141 }
12142 arg2 = static_cast< int >(val2);
12143 if (obj2) {
12144 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12145 if (!SWIG_IsOK(ecode3)) {
12146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12147 }
12148 arg3 = static_cast< bool >(val3);
12149 }
12150 {
12151 PyThreadState* __tstate = wxPyBeginAllowThreads();
12152 (arg1)->Start(arg2,arg3);
12153 wxPyEndAllowThreads(__tstate);
12154 if (PyErr_Occurred()) SWIG_fail;
12155 }
12156 resultobj = SWIG_Py_Void();
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12164 PyObject *obj;
12165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12166 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12167 return SWIG_Py_Void();
12168 }
12169
12170 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12171 return SWIG_Python_InitShadowInstance(args);
12172 }
12173
12174 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12175 PyObject *resultobj = 0;
12176 wxLog *result = 0 ;
12177
12178 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12179 {
12180 PyThreadState* __tstate = wxPyBeginAllowThreads();
12181 result = (wxLog *)new wxLog();
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12186 return resultobj;
12187 fail:
12188 return NULL;
12189 }
12190
12191
12192 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12193 PyObject *resultobj = 0;
12194 wxLog *arg1 = (wxLog *) 0 ;
12195 void *argp1 = 0 ;
12196 int res1 = 0 ;
12197 PyObject *swig_obj[1] ;
12198
12199 if (!args) SWIG_fail;
12200 swig_obj[0] = args;
12201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12202 if (!SWIG_IsOK(res1)) {
12203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12204 }
12205 arg1 = reinterpret_cast< wxLog * >(argp1);
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 delete arg1;
12209
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 resultobj = SWIG_Py_Void();
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12221 PyObject *resultobj = 0;
12222 bool result;
12223
12224 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12225 {
12226 PyThreadState* __tstate = wxPyBeginAllowThreads();
12227 result = (bool)wxLog::IsEnabled();
12228 wxPyEndAllowThreads(__tstate);
12229 if (PyErr_Occurred()) SWIG_fail;
12230 }
12231 {
12232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12233 }
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj = 0;
12242 bool arg1 = (bool) true ;
12243 bool result;
12244 bool val1 ;
12245 int ecode1 = 0 ;
12246 PyObject * obj0 = 0 ;
12247 char * kwnames[] = {
12248 (char *) "doIt", NULL
12249 };
12250
12251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12252 if (obj0) {
12253 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12254 if (!SWIG_IsOK(ecode1)) {
12255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12256 }
12257 arg1 = static_cast< bool >(val1);
12258 }
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 result = (bool)wxLog::EnableLogging(arg1);
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12267 }
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj = 0;
12276 wxLogLevel arg1 ;
12277 wxChar *arg2 = (wxChar *) 0 ;
12278 time_t arg3 ;
12279 unsigned long val1 ;
12280 int ecode1 = 0 ;
12281 void *argp2 = 0 ;
12282 int res2 = 0 ;
12283 unsigned int val3 ;
12284 int ecode3 = 0 ;
12285 PyObject * obj0 = 0 ;
12286 PyObject * obj1 = 0 ;
12287 PyObject * obj2 = 0 ;
12288 char * kwnames[] = {
12289 (char *) "level",(char *) "szString",(char *) "t", NULL
12290 };
12291
12292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12293 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12294 if (!SWIG_IsOK(ecode1)) {
12295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12296 }
12297 arg1 = static_cast< wxLogLevel >(val1);
12298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12299 if (!SWIG_IsOK(res2)) {
12300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12301 }
12302 arg2 = reinterpret_cast< wxChar * >(argp2);
12303 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12304 if (!SWIG_IsOK(ecode3)) {
12305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12306 }
12307 arg3 = static_cast< time_t >(val3);
12308 {
12309 PyThreadState* __tstate = wxPyBeginAllowThreads();
12310 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12311 wxPyEndAllowThreads(__tstate);
12312 if (PyErr_Occurred()) SWIG_fail;
12313 }
12314 resultobj = SWIG_Py_Void();
12315 return resultobj;
12316 fail:
12317 return NULL;
12318 }
12319
12320
12321 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12322 PyObject *resultobj = 0;
12323 wxLog *arg1 = (wxLog *) 0 ;
12324 void *argp1 = 0 ;
12325 int res1 = 0 ;
12326 PyObject *swig_obj[1] ;
12327
12328 if (!args) SWIG_fail;
12329 swig_obj[0] = args;
12330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12331 if (!SWIG_IsOK(res1)) {
12332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12333 }
12334 arg1 = reinterpret_cast< wxLog * >(argp1);
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 (arg1)->Flush();
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 resultobj = SWIG_Py_Void();
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12349 PyObject *resultobj = 0;
12350
12351 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 wxLog::FlushActive();
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_Py_Void();
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12366 PyObject *resultobj = 0;
12367 wxLog *result = 0 ;
12368
12369 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (wxLog *)wxLog::GetActiveTarget();
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12377 return resultobj;
12378 fail:
12379 return NULL;
12380 }
12381
12382
12383 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj = 0;
12385 wxLog *arg1 = (wxLog *) 0 ;
12386 wxLog *result = 0 ;
12387 int res1 = 0 ;
12388 PyObject * obj0 = 0 ;
12389 char * kwnames[] = {
12390 (char *) "pLogger", NULL
12391 };
12392
12393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12394 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12395 if (!SWIG_IsOK(res1)) {
12396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12397 }
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12405 return resultobj;
12406 fail:
12407 return NULL;
12408 }
12409
12410
12411 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12412 PyObject *resultobj = 0;
12413
12414 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12415 {
12416 PyThreadState* __tstate = wxPyBeginAllowThreads();
12417 wxLog::Suspend();
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 resultobj = SWIG_Py_Void();
12422 return resultobj;
12423 fail:
12424 return NULL;
12425 }
12426
12427
12428 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12429 PyObject *resultobj = 0;
12430
12431 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 wxLog::Resume();
12435 wxPyEndAllowThreads(__tstate);
12436 if (PyErr_Occurred()) SWIG_fail;
12437 }
12438 resultobj = SWIG_Py_Void();
12439 return resultobj;
12440 fail:
12441 return NULL;
12442 }
12443
12444
12445 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12446 PyObject *resultobj = 0;
12447 bool arg1 = (bool) true ;
12448 bool val1 ;
12449 int ecode1 = 0 ;
12450 PyObject * obj0 = 0 ;
12451 char * kwnames[] = {
12452 (char *) "bVerbose", NULL
12453 };
12454
12455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12456 if (obj0) {
12457 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12458 if (!SWIG_IsOK(ecode1)) {
12459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12460 }
12461 arg1 = static_cast< bool >(val1);
12462 }
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 wxLog::SetVerbose(arg1);
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 resultobj = SWIG_Py_Void();
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12477 PyObject *resultobj = 0;
12478 wxLogLevel arg1 ;
12479 unsigned long val1 ;
12480 int ecode1 = 0 ;
12481 PyObject * obj0 = 0 ;
12482 char * kwnames[] = {
12483 (char *) "logLevel", NULL
12484 };
12485
12486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12487 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12488 if (!SWIG_IsOK(ecode1)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12490 }
12491 arg1 = static_cast< wxLogLevel >(val1);
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 wxLog::SetLogLevel(arg1);
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 resultobj = SWIG_Py_Void();
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12506 PyObject *resultobj = 0;
12507
12508 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 wxLog::DontCreateOnDemand();
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 resultobj = SWIG_Py_Void();
12516 return resultobj;
12517 fail:
12518 return NULL;
12519 }
12520
12521
12522 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj = 0;
12524 bool arg1 = (bool) true ;
12525 bool val1 ;
12526 int ecode1 = 0 ;
12527 PyObject * obj0 = 0 ;
12528 char * kwnames[] = {
12529 (char *) "bRepetCounting", NULL
12530 };
12531
12532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12533 if (obj0) {
12534 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12535 if (!SWIG_IsOK(ecode1)) {
12536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12537 }
12538 arg1 = static_cast< bool >(val1);
12539 }
12540 {
12541 PyThreadState* __tstate = wxPyBeginAllowThreads();
12542 wxLog::SetRepetitionCounting(arg1);
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 resultobj = SWIG_Py_Void();
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12554 PyObject *resultobj = 0;
12555 bool result;
12556
12557 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (bool)wxLog::GetRepetitionCounting();
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 {
12565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12566 }
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj = 0;
12575 wxTraceMask arg1 ;
12576 unsigned long val1 ;
12577 int ecode1 = 0 ;
12578 PyObject * obj0 = 0 ;
12579 char * kwnames[] = {
12580 (char *) "ulMask", NULL
12581 };
12582
12583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12584 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12585 if (!SWIG_IsOK(ecode1)) {
12586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12587 }
12588 arg1 = static_cast< wxTraceMask >(val1);
12589 {
12590 PyThreadState* __tstate = wxPyBeginAllowThreads();
12591 wxLog::SetTraceMask(arg1);
12592 wxPyEndAllowThreads(__tstate);
12593 if (PyErr_Occurred()) SWIG_fail;
12594 }
12595 resultobj = SWIG_Py_Void();
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12603 PyObject *resultobj = 0;
12604 wxString *arg1 = 0 ;
12605 bool temp1 = false ;
12606 PyObject * obj0 = 0 ;
12607 char * kwnames[] = {
12608 (char *) "str", NULL
12609 };
12610
12611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12612 {
12613 arg1 = wxString_in_helper(obj0);
12614 if (arg1 == NULL) SWIG_fail;
12615 temp1 = true;
12616 }
12617 {
12618 PyThreadState* __tstate = wxPyBeginAllowThreads();
12619 wxLog::AddTraceMask((wxString const &)*arg1);
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = SWIG_Py_Void();
12624 {
12625 if (temp1)
12626 delete arg1;
12627 }
12628 return resultobj;
12629 fail:
12630 {
12631 if (temp1)
12632 delete arg1;
12633 }
12634 return NULL;
12635 }
12636
12637
12638 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj = 0;
12640 wxString *arg1 = 0 ;
12641 bool temp1 = false ;
12642 PyObject * obj0 = 0 ;
12643 char * kwnames[] = {
12644 (char *) "str", NULL
12645 };
12646
12647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12648 {
12649 arg1 = wxString_in_helper(obj0);
12650 if (arg1 == NULL) SWIG_fail;
12651 temp1 = true;
12652 }
12653 {
12654 PyThreadState* __tstate = wxPyBeginAllowThreads();
12655 wxLog::RemoveTraceMask((wxString const &)*arg1);
12656 wxPyEndAllowThreads(__tstate);
12657 if (PyErr_Occurred()) SWIG_fail;
12658 }
12659 resultobj = SWIG_Py_Void();
12660 {
12661 if (temp1)
12662 delete arg1;
12663 }
12664 return resultobj;
12665 fail:
12666 {
12667 if (temp1)
12668 delete arg1;
12669 }
12670 return NULL;
12671 }
12672
12673
12674 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12675 PyObject *resultobj = 0;
12676
12677 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 wxLog::ClearTraceMasks();
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 resultobj = SWIG_Py_Void();
12685 return resultobj;
12686 fail:
12687 return NULL;
12688 }
12689
12690
12691 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12692 PyObject *resultobj = 0;
12693 wxArrayString *result = 0 ;
12694
12695 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 {
12699 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12700 result = (wxArrayString *) &_result_ref;
12701 }
12702 wxPyEndAllowThreads(__tstate);
12703 if (PyErr_Occurred()) SWIG_fail;
12704 }
12705 {
12706 resultobj = wxArrayString2PyList_helper(*result);
12707 }
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj = 0;
12716 wxChar *arg1 = (wxChar *) 0 ;
12717 void *argp1 = 0 ;
12718 int res1 = 0 ;
12719 PyObject * obj0 = 0 ;
12720 char * kwnames[] = {
12721 (char *) "ts", NULL
12722 };
12723
12724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12726 if (!SWIG_IsOK(res1)) {
12727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12728 }
12729 arg1 = reinterpret_cast< wxChar * >(argp1);
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 wxLog::SetTimestamp((wxChar const *)arg1);
12733 wxPyEndAllowThreads(__tstate);
12734 if (PyErr_Occurred()) SWIG_fail;
12735 }
12736 resultobj = SWIG_Py_Void();
12737 return resultobj;
12738 fail:
12739 return NULL;
12740 }
12741
12742
12743 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12744 PyObject *resultobj = 0;
12745 bool result;
12746
12747 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12748 {
12749 PyThreadState* __tstate = wxPyBeginAllowThreads();
12750 result = (bool)wxLog::GetVerbose();
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 {
12755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12756 }
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12764 PyObject *resultobj = 0;
12765 wxTraceMask result;
12766
12767 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (wxTraceMask)wxLog::GetTraceMask();
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj = 0;
12783 wxChar *arg1 = (wxChar *) 0 ;
12784 bool result;
12785 void *argp1 = 0 ;
12786 int res1 = 0 ;
12787 PyObject * obj0 = 0 ;
12788 char * kwnames[] = {
12789 (char *) "mask", NULL
12790 };
12791
12792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12794 if (!SWIG_IsOK(res1)) {
12795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12796 }
12797 arg1 = reinterpret_cast< wxChar * >(argp1);
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12801 wxPyEndAllowThreads(__tstate);
12802 if (PyErr_Occurred()) SWIG_fail;
12803 }
12804 {
12805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12806 }
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12814 PyObject *resultobj = 0;
12815 wxLogLevel result;
12816
12817 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (wxLogLevel)wxLog::GetLogLevel();
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12832 PyObject *resultobj = 0;
12833 wxChar *result = 0 ;
12834
12835 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 result = (wxChar *)wxLog::GetTimestamp();
12839 wxPyEndAllowThreads(__tstate);
12840 if (PyErr_Occurred()) SWIG_fail;
12841 }
12842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12850 PyObject *resultobj = 0;
12851 wxString result;
12852
12853 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12854 {
12855 PyThreadState* __tstate = wxPyBeginAllowThreads();
12856 result = wxLog_TimeStamp();
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 {
12861 #if wxUSE_UNICODE
12862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12863 #else
12864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12865 #endif
12866 }
12867 return resultobj;
12868 fail:
12869 return NULL;
12870 }
12871
12872
12873 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12874 PyObject *resultobj = 0;
12875 wxLog *arg1 = (wxLog *) 0 ;
12876 void *argp1 = 0 ;
12877 int res1 = 0 ;
12878 PyObject *swig_obj[1] ;
12879
12880 if (!args) SWIG_fail;
12881 swig_obj[0] = args;
12882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12883 if (!SWIG_IsOK(res1)) {
12884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12885 }
12886 arg1 = reinterpret_cast< wxLog * >(argp1);
12887 {
12888 PyThreadState* __tstate = wxPyBeginAllowThreads();
12889 wxLog_Destroy(arg1);
12890 wxPyEndAllowThreads(__tstate);
12891 if (PyErr_Occurred()) SWIG_fail;
12892 }
12893 resultobj = SWIG_Py_Void();
12894 return resultobj;
12895 fail:
12896 return NULL;
12897 }
12898
12899
12900 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12901 PyObject *obj;
12902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12903 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12904 return SWIG_Py_Void();
12905 }
12906
12907 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 return SWIG_Python_InitShadowInstance(args);
12909 }
12910
12911 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912 PyObject *resultobj = 0;
12913 wxLogStderr *result = 0 ;
12914
12915 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12916 {
12917 PyThreadState* __tstate = wxPyBeginAllowThreads();
12918 result = (wxLogStderr *)new wxLogStderr();
12919 wxPyEndAllowThreads(__tstate);
12920 if (PyErr_Occurred()) SWIG_fail;
12921 }
12922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12923 return resultobj;
12924 fail:
12925 return NULL;
12926 }
12927
12928
12929 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12930 PyObject *obj;
12931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12932 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12933 return SWIG_Py_Void();
12934 }
12935
12936 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12937 return SWIG_Python_InitShadowInstance(args);
12938 }
12939
12940 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12941 PyObject *resultobj = 0;
12942 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12943 wxLogTextCtrl *result = 0 ;
12944 void *argp1 = 0 ;
12945 int res1 = 0 ;
12946 PyObject * obj0 = 0 ;
12947 char * kwnames[] = {
12948 (char *) "pTextCtrl", NULL
12949 };
12950
12951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12953 if (!SWIG_IsOK(res1)) {
12954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12955 }
12956 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12957 {
12958 PyThreadState* __tstate = wxPyBeginAllowThreads();
12959 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12960 wxPyEndAllowThreads(__tstate);
12961 if (PyErr_Occurred()) SWIG_fail;
12962 }
12963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12964 return resultobj;
12965 fail:
12966 return NULL;
12967 }
12968
12969
12970 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12971 PyObject *obj;
12972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12973 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12974 return SWIG_Py_Void();
12975 }
12976
12977 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 return SWIG_Python_InitShadowInstance(args);
12979 }
12980
12981 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12982 PyObject *resultobj = 0;
12983 wxLogGui *result = 0 ;
12984
12985 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 result = (wxLogGui *)new wxLogGui();
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12993 return resultobj;
12994 fail:
12995 return NULL;
12996 }
12997
12998
12999 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13000 PyObject *obj;
13001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13002 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
13003 return SWIG_Py_Void();
13004 }
13005
13006 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13007 return SWIG_Python_InitShadowInstance(args);
13008 }
13009
13010 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13011 PyObject *resultobj = 0;
13012 wxFrame *arg1 = (wxFrame *) 0 ;
13013 wxString *arg2 = 0 ;
13014 bool arg3 = (bool) true ;
13015 bool arg4 = (bool) true ;
13016 wxLogWindow *result = 0 ;
13017 void *argp1 = 0 ;
13018 int res1 = 0 ;
13019 bool temp2 = false ;
13020 bool val3 ;
13021 int ecode3 = 0 ;
13022 bool val4 ;
13023 int ecode4 = 0 ;
13024 PyObject * obj0 = 0 ;
13025 PyObject * obj1 = 0 ;
13026 PyObject * obj2 = 0 ;
13027 PyObject * obj3 = 0 ;
13028 char * kwnames[] = {
13029 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13030 };
13031
13032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13034 if (!SWIG_IsOK(res1)) {
13035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13036 }
13037 arg1 = reinterpret_cast< wxFrame * >(argp1);
13038 {
13039 arg2 = wxString_in_helper(obj1);
13040 if (arg2 == NULL) SWIG_fail;
13041 temp2 = true;
13042 }
13043 if (obj2) {
13044 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13045 if (!SWIG_IsOK(ecode3)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13047 }
13048 arg3 = static_cast< bool >(val3);
13049 }
13050 if (obj3) {
13051 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13052 if (!SWIG_IsOK(ecode4)) {
13053 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13054 }
13055 arg4 = static_cast< bool >(val4);
13056 }
13057 {
13058 PyThreadState* __tstate = wxPyBeginAllowThreads();
13059 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13064 {
13065 if (temp2)
13066 delete arg2;
13067 }
13068 return resultobj;
13069 fail:
13070 {
13071 if (temp2)
13072 delete arg2;
13073 }
13074 return NULL;
13075 }
13076
13077
13078 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13079 PyObject *resultobj = 0;
13080 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13081 bool arg2 = (bool) true ;
13082 void *argp1 = 0 ;
13083 int res1 = 0 ;
13084 bool val2 ;
13085 int ecode2 = 0 ;
13086 PyObject * obj0 = 0 ;
13087 PyObject * obj1 = 0 ;
13088 char * kwnames[] = {
13089 (char *) "self",(char *) "bShow", NULL
13090 };
13091
13092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13094 if (!SWIG_IsOK(res1)) {
13095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13096 }
13097 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13098 if (obj1) {
13099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13100 if (!SWIG_IsOK(ecode2)) {
13101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13102 }
13103 arg2 = static_cast< bool >(val2);
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 (arg1)->Show(arg2);
13108 wxPyEndAllowThreads(__tstate);
13109 if (PyErr_Occurred()) SWIG_fail;
13110 }
13111 resultobj = SWIG_Py_Void();
13112 return resultobj;
13113 fail:
13114 return NULL;
13115 }
13116
13117
13118 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13119 PyObject *resultobj = 0;
13120 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13121 wxFrame *result = 0 ;
13122 void *argp1 = 0 ;
13123 int res1 = 0 ;
13124 PyObject *swig_obj[1] ;
13125
13126 if (!args) SWIG_fail;
13127 swig_obj[0] = args;
13128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13129 if (!SWIG_IsOK(res1)) {
13130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13131 }
13132 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13133 {
13134 PyThreadState* __tstate = wxPyBeginAllowThreads();
13135 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 {
13140 resultobj = wxPyMake_wxObject(result, (bool)0);
13141 }
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13149 PyObject *resultobj = 0;
13150 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13151 wxLog *result = 0 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 PyObject *swig_obj[1] ;
13155
13156 if (!args) SWIG_fail;
13157 swig_obj[0] = args;
13158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13159 if (!SWIG_IsOK(res1)) {
13160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13161 }
13162 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13166 wxPyEndAllowThreads(__tstate);
13167 if (PyErr_Occurred()) SWIG_fail;
13168 }
13169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13177 PyObject *resultobj = 0;
13178 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13179 bool result;
13180 void *argp1 = 0 ;
13181 int res1 = 0 ;
13182 PyObject *swig_obj[1] ;
13183
13184 if (!args) SWIG_fail;
13185 swig_obj[0] = args;
13186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13187 if (!SWIG_IsOK(res1)) {
13188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13189 }
13190 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13191 {
13192 PyThreadState* __tstate = wxPyBeginAllowThreads();
13193 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 {
13198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13199 }
13200 return resultobj;
13201 fail:
13202 return NULL;
13203 }
13204
13205
13206 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13207 PyObject *resultobj = 0;
13208 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13209 bool arg2 ;
13210 void *argp1 = 0 ;
13211 int res1 = 0 ;
13212 bool val2 ;
13213 int ecode2 = 0 ;
13214 PyObject * obj0 = 0 ;
13215 PyObject * obj1 = 0 ;
13216 char * kwnames[] = {
13217 (char *) "self",(char *) "bDoPass", NULL
13218 };
13219
13220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13222 if (!SWIG_IsOK(res1)) {
13223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13224 }
13225 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13226 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13227 if (!SWIG_IsOK(ecode2)) {
13228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13229 }
13230 arg2 = static_cast< bool >(val2);
13231 {
13232 PyThreadState* __tstate = wxPyBeginAllowThreads();
13233 (arg1)->PassMessages(arg2);
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 resultobj = SWIG_Py_Void();
13238 return resultobj;
13239 fail:
13240 return NULL;
13241 }
13242
13243
13244 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13245 PyObject *obj;
13246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13247 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13248 return SWIG_Py_Void();
13249 }
13250
13251 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13252 return SWIG_Python_InitShadowInstance(args);
13253 }
13254
13255 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13256 PyObject *resultobj = 0;
13257 wxLog *arg1 = (wxLog *) 0 ;
13258 wxLogChain *result = 0 ;
13259 void *argp1 = 0 ;
13260 int res1 = 0 ;
13261 PyObject * obj0 = 0 ;
13262 char * kwnames[] = {
13263 (char *) "logger", NULL
13264 };
13265
13266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13268 if (!SWIG_IsOK(res1)) {
13269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13270 }
13271 arg1 = reinterpret_cast< wxLog * >(argp1);
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (wxLogChain *)new wxLogChain(arg1);
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13279 return resultobj;
13280 fail:
13281 return NULL;
13282 }
13283
13284
13285 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj = 0;
13287 wxLogChain *arg1 = (wxLogChain *) 0 ;
13288 wxLog *arg2 = (wxLog *) 0 ;
13289 void *argp1 = 0 ;
13290 int res1 = 0 ;
13291 void *argp2 = 0 ;
13292 int res2 = 0 ;
13293 PyObject * obj0 = 0 ;
13294 PyObject * obj1 = 0 ;
13295 char * kwnames[] = {
13296 (char *) "self",(char *) "logger", NULL
13297 };
13298
13299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13301 if (!SWIG_IsOK(res1)) {
13302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13303 }
13304 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13306 if (!SWIG_IsOK(res2)) {
13307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13308 }
13309 arg2 = reinterpret_cast< wxLog * >(argp2);
13310 {
13311 PyThreadState* __tstate = wxPyBeginAllowThreads();
13312 (arg1)->SetLog(arg2);
13313 wxPyEndAllowThreads(__tstate);
13314 if (PyErr_Occurred()) SWIG_fail;
13315 }
13316 resultobj = SWIG_Py_Void();
13317 return resultobj;
13318 fail:
13319 return NULL;
13320 }
13321
13322
13323 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13324 PyObject *resultobj = 0;
13325 wxLogChain *arg1 = (wxLogChain *) 0 ;
13326 bool arg2 ;
13327 void *argp1 = 0 ;
13328 int res1 = 0 ;
13329 bool val2 ;
13330 int ecode2 = 0 ;
13331 PyObject * obj0 = 0 ;
13332 PyObject * obj1 = 0 ;
13333 char * kwnames[] = {
13334 (char *) "self",(char *) "bDoPass", NULL
13335 };
13336
13337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13339 if (!SWIG_IsOK(res1)) {
13340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13341 }
13342 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13346 }
13347 arg2 = static_cast< bool >(val2);
13348 {
13349 PyThreadState* __tstate = wxPyBeginAllowThreads();
13350 (arg1)->PassMessages(arg2);
13351 wxPyEndAllowThreads(__tstate);
13352 if (PyErr_Occurred()) SWIG_fail;
13353 }
13354 resultobj = SWIG_Py_Void();
13355 return resultobj;
13356 fail:
13357 return NULL;
13358 }
13359
13360
13361 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13362 PyObject *resultobj = 0;
13363 wxLogChain *arg1 = (wxLogChain *) 0 ;
13364 bool result;
13365 void *argp1 = 0 ;
13366 int res1 = 0 ;
13367 PyObject *swig_obj[1] ;
13368
13369 if (!args) SWIG_fail;
13370 swig_obj[0] = args;
13371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13372 if (!SWIG_IsOK(res1)) {
13373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13374 }
13375 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 result = (bool)(arg1)->IsPassingMessages();
13379 wxPyEndAllowThreads(__tstate);
13380 if (PyErr_Occurred()) SWIG_fail;
13381 }
13382 {
13383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13384 }
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392 PyObject *resultobj = 0;
13393 wxLogChain *arg1 = (wxLogChain *) 0 ;
13394 wxLog *result = 0 ;
13395 void *argp1 = 0 ;
13396 int res1 = 0 ;
13397 PyObject *swig_obj[1] ;
13398
13399 if (!args) SWIG_fail;
13400 swig_obj[0] = args;
13401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13402 if (!SWIG_IsOK(res1)) {
13403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13404 }
13405 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13406 {
13407 PyThreadState* __tstate = wxPyBeginAllowThreads();
13408 result = (wxLog *)(arg1)->GetOldLog();
13409 wxPyEndAllowThreads(__tstate);
13410 if (PyErr_Occurred()) SWIG_fail;
13411 }
13412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13413 return resultobj;
13414 fail:
13415 return NULL;
13416 }
13417
13418
13419 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13420 PyObject *obj;
13421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13422 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13423 return SWIG_Py_Void();
13424 }
13425
13426 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13427 return SWIG_Python_InitShadowInstance(args);
13428 }
13429
13430 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13431 PyObject *resultobj = 0;
13432 wxLogBuffer *result = 0 ;
13433
13434 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13435 {
13436 PyThreadState* __tstate = wxPyBeginAllowThreads();
13437 result = (wxLogBuffer *)new wxLogBuffer();
13438 wxPyEndAllowThreads(__tstate);
13439 if (PyErr_Occurred()) SWIG_fail;
13440 }
13441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13442 return resultobj;
13443 fail:
13444 return NULL;
13445 }
13446
13447
13448 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13449 PyObject *resultobj = 0;
13450 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13451 wxString *result = 0 ;
13452 void *argp1 = 0 ;
13453 int res1 = 0 ;
13454 PyObject *swig_obj[1] ;
13455
13456 if (!args) SWIG_fail;
13457 swig_obj[0] = args;
13458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13459 if (!SWIG_IsOK(res1)) {
13460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13461 }
13462 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 {
13466 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13467 result = (wxString *) &_result_ref;
13468 }
13469 wxPyEndAllowThreads(__tstate);
13470 if (PyErr_Occurred()) SWIG_fail;
13471 }
13472 {
13473 #if wxUSE_UNICODE
13474 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13475 #else
13476 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13477 #endif
13478 }
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13486 PyObject *obj;
13487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13488 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13489 return SWIG_Py_Void();
13490 }
13491
13492 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13493 return SWIG_Python_InitShadowInstance(args);
13494 }
13495
13496 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13497 PyObject *resultobj = 0;
13498 unsigned long result;
13499
13500 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13501 {
13502 PyThreadState* __tstate = wxPyBeginAllowThreads();
13503 result = (unsigned long)wxSysErrorCode();
13504 wxPyEndAllowThreads(__tstate);
13505 if (PyErr_Occurred()) SWIG_fail;
13506 }
13507 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13508 return resultobj;
13509 fail:
13510 return NULL;
13511 }
13512
13513
13514 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj = 0;
13516 unsigned long arg1 = (unsigned long) 0 ;
13517 wxString result;
13518 unsigned long val1 ;
13519 int ecode1 = 0 ;
13520 PyObject * obj0 = 0 ;
13521 char * kwnames[] = {
13522 (char *) "nErrCode", NULL
13523 };
13524
13525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13526 if (obj0) {
13527 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13528 if (!SWIG_IsOK(ecode1)) {
13529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13530 }
13531 arg1 = static_cast< unsigned long >(val1);
13532 }
13533 {
13534 PyThreadState* __tstate = wxPyBeginAllowThreads();
13535 result = wxSysErrorMsg(arg1);
13536 wxPyEndAllowThreads(__tstate);
13537 if (PyErr_Occurred()) SWIG_fail;
13538 }
13539 {
13540 #if wxUSE_UNICODE
13541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13542 #else
13543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13544 #endif
13545 }
13546 return resultobj;
13547 fail:
13548 return NULL;
13549 }
13550
13551
13552 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj = 0;
13554 wxString *arg1 = 0 ;
13555 bool temp1 = false ;
13556 PyObject * obj0 = 0 ;
13557 char * kwnames[] = {
13558 (char *) "msg", NULL
13559 };
13560
13561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13562 {
13563 arg1 = wxString_in_helper(obj0);
13564 if (arg1 == NULL) SWIG_fail;
13565 temp1 = true;
13566 }
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 wxPyLogFatalError((wxString const &)*arg1);
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 resultobj = SWIG_Py_Void();
13574 {
13575 if (temp1)
13576 delete arg1;
13577 }
13578 return resultobj;
13579 fail:
13580 {
13581 if (temp1)
13582 delete arg1;
13583 }
13584 return NULL;
13585 }
13586
13587
13588 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13589 PyObject *resultobj = 0;
13590 wxString *arg1 = 0 ;
13591 bool temp1 = false ;
13592 PyObject * obj0 = 0 ;
13593 char * kwnames[] = {
13594 (char *) "msg", NULL
13595 };
13596
13597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13598 {
13599 arg1 = wxString_in_helper(obj0);
13600 if (arg1 == NULL) SWIG_fail;
13601 temp1 = true;
13602 }
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 wxPyLogError((wxString const &)*arg1);
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 resultobj = SWIG_Py_Void();
13610 {
13611 if (temp1)
13612 delete arg1;
13613 }
13614 return resultobj;
13615 fail:
13616 {
13617 if (temp1)
13618 delete arg1;
13619 }
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 wxString *arg1 = 0 ;
13627 bool temp1 = false ;
13628 PyObject * obj0 = 0 ;
13629 char * kwnames[] = {
13630 (char *) "msg", NULL
13631 };
13632
13633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13634 {
13635 arg1 = wxString_in_helper(obj0);
13636 if (arg1 == NULL) SWIG_fail;
13637 temp1 = true;
13638 }
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 wxPyLogWarning((wxString const &)*arg1);
13642 wxPyEndAllowThreads(__tstate);
13643 if (PyErr_Occurred()) SWIG_fail;
13644 }
13645 resultobj = SWIG_Py_Void();
13646 {
13647 if (temp1)
13648 delete arg1;
13649 }
13650 return resultobj;
13651 fail:
13652 {
13653 if (temp1)
13654 delete arg1;
13655 }
13656 return NULL;
13657 }
13658
13659
13660 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13661 PyObject *resultobj = 0;
13662 wxString *arg1 = 0 ;
13663 bool temp1 = false ;
13664 PyObject * obj0 = 0 ;
13665 char * kwnames[] = {
13666 (char *) "msg", NULL
13667 };
13668
13669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13670 {
13671 arg1 = wxString_in_helper(obj0);
13672 if (arg1 == NULL) SWIG_fail;
13673 temp1 = true;
13674 }
13675 {
13676 PyThreadState* __tstate = wxPyBeginAllowThreads();
13677 wxPyLogMessage((wxString const &)*arg1);
13678 wxPyEndAllowThreads(__tstate);
13679 if (PyErr_Occurred()) SWIG_fail;
13680 }
13681 resultobj = SWIG_Py_Void();
13682 {
13683 if (temp1)
13684 delete arg1;
13685 }
13686 return resultobj;
13687 fail:
13688 {
13689 if (temp1)
13690 delete arg1;
13691 }
13692 return NULL;
13693 }
13694
13695
13696 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13697 PyObject *resultobj = 0;
13698 wxString *arg1 = 0 ;
13699 bool temp1 = false ;
13700 PyObject * obj0 = 0 ;
13701 char * kwnames[] = {
13702 (char *) "msg", NULL
13703 };
13704
13705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13706 {
13707 arg1 = wxString_in_helper(obj0);
13708 if (arg1 == NULL) SWIG_fail;
13709 temp1 = true;
13710 }
13711 {
13712 PyThreadState* __tstate = wxPyBeginAllowThreads();
13713 wxPyLogInfo((wxString const &)*arg1);
13714 wxPyEndAllowThreads(__tstate);
13715 if (PyErr_Occurred()) SWIG_fail;
13716 }
13717 resultobj = SWIG_Py_Void();
13718 {
13719 if (temp1)
13720 delete arg1;
13721 }
13722 return resultobj;
13723 fail:
13724 {
13725 if (temp1)
13726 delete arg1;
13727 }
13728 return NULL;
13729 }
13730
13731
13732 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13733 PyObject *resultobj = 0;
13734 wxString *arg1 = 0 ;
13735 bool temp1 = false ;
13736 PyObject * obj0 = 0 ;
13737 char * kwnames[] = {
13738 (char *) "msg", NULL
13739 };
13740
13741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13742 {
13743 arg1 = wxString_in_helper(obj0);
13744 if (arg1 == NULL) SWIG_fail;
13745 temp1 = true;
13746 }
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 wxPyLogDebug((wxString const &)*arg1);
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 resultobj = SWIG_Py_Void();
13754 {
13755 if (temp1)
13756 delete arg1;
13757 }
13758 return resultobj;
13759 fail:
13760 {
13761 if (temp1)
13762 delete arg1;
13763 }
13764 return NULL;
13765 }
13766
13767
13768 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13769 PyObject *resultobj = 0;
13770 wxString *arg1 = 0 ;
13771 bool temp1 = false ;
13772 PyObject * obj0 = 0 ;
13773 char * kwnames[] = {
13774 (char *) "msg", NULL
13775 };
13776
13777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13778 {
13779 arg1 = wxString_in_helper(obj0);
13780 if (arg1 == NULL) SWIG_fail;
13781 temp1 = true;
13782 }
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 wxPyLogVerbose((wxString const &)*arg1);
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 resultobj = SWIG_Py_Void();
13790 {
13791 if (temp1)
13792 delete arg1;
13793 }
13794 return resultobj;
13795 fail:
13796 {
13797 if (temp1)
13798 delete arg1;
13799 }
13800 return NULL;
13801 }
13802
13803
13804 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj = 0;
13806 wxString *arg1 = 0 ;
13807 bool temp1 = false ;
13808 PyObject * obj0 = 0 ;
13809 char * kwnames[] = {
13810 (char *) "msg", NULL
13811 };
13812
13813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13814 {
13815 arg1 = wxString_in_helper(obj0);
13816 if (arg1 == NULL) SWIG_fail;
13817 temp1 = true;
13818 }
13819 {
13820 PyThreadState* __tstate = wxPyBeginAllowThreads();
13821 wxPyLogStatus((wxString const &)*arg1);
13822 wxPyEndAllowThreads(__tstate);
13823 if (PyErr_Occurred()) SWIG_fail;
13824 }
13825 resultobj = SWIG_Py_Void();
13826 {
13827 if (temp1)
13828 delete arg1;
13829 }
13830 return resultobj;
13831 fail:
13832 {
13833 if (temp1)
13834 delete arg1;
13835 }
13836 return NULL;
13837 }
13838
13839
13840 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13841 PyObject *resultobj = 0;
13842 wxFrame *arg1 = (wxFrame *) 0 ;
13843 wxString *arg2 = 0 ;
13844 void *argp1 = 0 ;
13845 int res1 = 0 ;
13846 bool temp2 = false ;
13847 PyObject * obj0 = 0 ;
13848 PyObject * obj1 = 0 ;
13849 char * kwnames[] = {
13850 (char *) "pFrame",(char *) "msg", NULL
13851 };
13852
13853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13855 if (!SWIG_IsOK(res1)) {
13856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13857 }
13858 arg1 = reinterpret_cast< wxFrame * >(argp1);
13859 {
13860 arg2 = wxString_in_helper(obj1);
13861 if (arg2 == NULL) SWIG_fail;
13862 temp2 = true;
13863 }
13864 {
13865 PyThreadState* __tstate = wxPyBeginAllowThreads();
13866 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13867 wxPyEndAllowThreads(__tstate);
13868 if (PyErr_Occurred()) SWIG_fail;
13869 }
13870 resultobj = SWIG_Py_Void();
13871 {
13872 if (temp2)
13873 delete arg2;
13874 }
13875 return resultobj;
13876 fail:
13877 {
13878 if (temp2)
13879 delete arg2;
13880 }
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13886 PyObject *resultobj = 0;
13887 wxString *arg1 = 0 ;
13888 bool temp1 = false ;
13889 PyObject * obj0 = 0 ;
13890 char * kwnames[] = {
13891 (char *) "msg", NULL
13892 };
13893
13894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13895 {
13896 arg1 = wxString_in_helper(obj0);
13897 if (arg1 == NULL) SWIG_fail;
13898 temp1 = true;
13899 }
13900 {
13901 PyThreadState* __tstate = wxPyBeginAllowThreads();
13902 wxPyLogSysError((wxString const &)*arg1);
13903 wxPyEndAllowThreads(__tstate);
13904 if (PyErr_Occurred()) SWIG_fail;
13905 }
13906 resultobj = SWIG_Py_Void();
13907 {
13908 if (temp1)
13909 delete arg1;
13910 }
13911 return resultobj;
13912 fail:
13913 {
13914 if (temp1)
13915 delete arg1;
13916 }
13917 return NULL;
13918 }
13919
13920
13921 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj = 0;
13923 unsigned long arg1 ;
13924 wxString *arg2 = 0 ;
13925 unsigned long val1 ;
13926 int ecode1 = 0 ;
13927 bool temp2 = false ;
13928 PyObject * obj0 = 0 ;
13929 PyObject * obj1 = 0 ;
13930 char * kwnames[] = {
13931 (char *) "level",(char *) "msg", NULL
13932 };
13933
13934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13935 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13936 if (!SWIG_IsOK(ecode1)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13938 }
13939 arg1 = static_cast< unsigned long >(val1);
13940 {
13941 arg2 = wxString_in_helper(obj1);
13942 if (arg2 == NULL) SWIG_fail;
13943 temp2 = true;
13944 }
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_Py_Void();
13952 {
13953 if (temp2)
13954 delete arg2;
13955 }
13956 return resultobj;
13957 fail:
13958 {
13959 if (temp2)
13960 delete arg2;
13961 }
13962 return NULL;
13963 }
13964
13965
13966 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13967 PyObject *resultobj = 0;
13968 unsigned long arg1 ;
13969 wxString *arg2 = 0 ;
13970 unsigned long val1 ;
13971 int ecode1 = 0 ;
13972 bool temp2 = false ;
13973
13974 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13975 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13976 if (!SWIG_IsOK(ecode1)) {
13977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13978 }
13979 arg1 = static_cast< unsigned long >(val1);
13980 {
13981 arg2 = wxString_in_helper(swig_obj[1]);
13982 if (arg2 == NULL) SWIG_fail;
13983 temp2 = true;
13984 }
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 wxPyLogTrace(arg1,(wxString const &)*arg2);
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 resultobj = SWIG_Py_Void();
13992 {
13993 if (temp2)
13994 delete arg2;
13995 }
13996 return resultobj;
13997 fail:
13998 {
13999 if (temp2)
14000 delete arg2;
14001 }
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14007 PyObject *resultobj = 0;
14008 wxString *arg1 = 0 ;
14009 wxString *arg2 = 0 ;
14010 bool temp1 = false ;
14011 bool temp2 = false ;
14012
14013 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14014 {
14015 arg1 = wxString_in_helper(swig_obj[0]);
14016 if (arg1 == NULL) SWIG_fail;
14017 temp1 = true;
14018 }
14019 {
14020 arg2 = wxString_in_helper(swig_obj[1]);
14021 if (arg2 == NULL) SWIG_fail;
14022 temp2 = true;
14023 }
14024 {
14025 PyThreadState* __tstate = wxPyBeginAllowThreads();
14026 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14027 wxPyEndAllowThreads(__tstate);
14028 if (PyErr_Occurred()) SWIG_fail;
14029 }
14030 resultobj = SWIG_Py_Void();
14031 {
14032 if (temp1)
14033 delete arg1;
14034 }
14035 {
14036 if (temp2)
14037 delete arg2;
14038 }
14039 return resultobj;
14040 fail:
14041 {
14042 if (temp1)
14043 delete arg1;
14044 }
14045 {
14046 if (temp2)
14047 delete arg2;
14048 }
14049 return NULL;
14050 }
14051
14052
14053 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14054 int argc;
14055 PyObject *argv[3];
14056
14057 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14058 --argc;
14059 if (argc == 2) {
14060 int _v = 0;
14061 {
14062 {
14063 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14064 }
14065 }
14066 if (!_v) goto check_1;
14067 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14068 }
14069 check_1:
14070
14071 if (argc == 2) {
14072 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14073 }
14074
14075 fail:
14076 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14077 return NULL;
14078 }
14079
14080
14081 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14082 PyObject *resultobj = 0;
14083 wxString *arg1 = 0 ;
14084 wxString *arg2 = 0 ;
14085 bool temp1 = false ;
14086 bool temp2 = false ;
14087 PyObject * obj0 = 0 ;
14088 PyObject * obj1 = 0 ;
14089 char * kwnames[] = {
14090 (char *) "title",(char *) "text", NULL
14091 };
14092
14093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14094 {
14095 arg1 = wxString_in_helper(obj0);
14096 if (arg1 == NULL) SWIG_fail;
14097 temp1 = true;
14098 }
14099 {
14100 arg2 = wxString_in_helper(obj1);
14101 if (arg2 == NULL) SWIG_fail;
14102 temp2 = true;
14103 }
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14107 wxPyEndAllowThreads(__tstate);
14108 if (PyErr_Occurred()) SWIG_fail;
14109 }
14110 resultobj = SWIG_Py_Void();
14111 {
14112 if (temp1)
14113 delete arg1;
14114 }
14115 {
14116 if (temp2)
14117 delete arg2;
14118 }
14119 return resultobj;
14120 fail:
14121 {
14122 if (temp1)
14123 delete arg1;
14124 }
14125 {
14126 if (temp2)
14127 delete arg2;
14128 }
14129 return NULL;
14130 }
14131
14132
14133 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14134 PyObject *resultobj = 0;
14135 wxLogNull *result = 0 ;
14136
14137 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 result = (wxLogNull *)new wxLogNull();
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14145 return resultobj;
14146 fail:
14147 return NULL;
14148 }
14149
14150
14151 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14152 PyObject *resultobj = 0;
14153 wxLogNull *arg1 = (wxLogNull *) 0 ;
14154 void *argp1 = 0 ;
14155 int res1 = 0 ;
14156 PyObject *swig_obj[1] ;
14157
14158 if (!args) SWIG_fail;
14159 swig_obj[0] = args;
14160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14161 if (!SWIG_IsOK(res1)) {
14162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14163 }
14164 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 delete arg1;
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 resultobj = SWIG_Py_Void();
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14180 PyObject *obj;
14181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14182 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14183 return SWIG_Py_Void();
14184 }
14185
14186 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14187 return SWIG_Python_InitShadowInstance(args);
14188 }
14189
14190 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14191 PyObject *resultobj = 0;
14192 wxPyLog *result = 0 ;
14193
14194 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14195 {
14196 PyThreadState* __tstate = wxPyBeginAllowThreads();
14197 result = (wxPyLog *)new wxPyLog();
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj = 0;
14210 wxPyLog *arg1 = (wxPyLog *) 0 ;
14211 PyObject *arg2 = (PyObject *) 0 ;
14212 PyObject *arg3 = (PyObject *) 0 ;
14213 void *argp1 = 0 ;
14214 int res1 = 0 ;
14215 PyObject * obj0 = 0 ;
14216 PyObject * obj1 = 0 ;
14217 PyObject * obj2 = 0 ;
14218 char * kwnames[] = {
14219 (char *) "self",(char *) "self",(char *) "_class", NULL
14220 };
14221
14222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14224 if (!SWIG_IsOK(res1)) {
14225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14226 }
14227 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14228 arg2 = obj1;
14229 arg3 = obj2;
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 (arg1)->_setCallbackInfo(arg2,arg3);
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 resultobj = SWIG_Py_Void();
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14244 PyObject *obj;
14245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14246 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14247 return SWIG_Py_Void();
14248 }
14249
14250 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14251 return SWIG_Python_InitShadowInstance(args);
14252 }
14253
14254 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj = 0;
14256 int arg1 ;
14257 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14258 int arg3 = (int) wxKILL_NOCHILDREN ;
14259 wxKillError result;
14260 int val1 ;
14261 int ecode1 = 0 ;
14262 int val2 ;
14263 int ecode2 = 0 ;
14264 int val3 ;
14265 int ecode3 = 0 ;
14266 PyObject * obj0 = 0 ;
14267 PyObject * obj1 = 0 ;
14268 PyObject * obj2 = 0 ;
14269 char * kwnames[] = {
14270 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14271 };
14272
14273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14274 ecode1 = SWIG_AsVal_int(obj0, &val1);
14275 if (!SWIG_IsOK(ecode1)) {
14276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14277 }
14278 arg1 = static_cast< int >(val1);
14279 if (obj1) {
14280 ecode2 = SWIG_AsVal_int(obj1, &val2);
14281 if (!SWIG_IsOK(ecode2)) {
14282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14283 }
14284 arg2 = static_cast< wxSignal >(val2);
14285 }
14286 if (obj2) {
14287 ecode3 = SWIG_AsVal_int(obj2, &val3);
14288 if (!SWIG_IsOK(ecode3)) {
14289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14290 }
14291 arg3 = static_cast< int >(val3);
14292 }
14293 {
14294 PyThreadState* __tstate = wxPyBeginAllowThreads();
14295 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14296 wxPyEndAllowThreads(__tstate);
14297 if (PyErr_Occurred()) SWIG_fail;
14298 }
14299 resultobj = SWIG_From_int(static_cast< int >(result));
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj = 0;
14308 int arg1 ;
14309 bool result;
14310 int val1 ;
14311 int ecode1 = 0 ;
14312 PyObject * obj0 = 0 ;
14313 char * kwnames[] = {
14314 (char *) "pid", NULL
14315 };
14316
14317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14318 ecode1 = SWIG_AsVal_int(obj0, &val1);
14319 if (!SWIG_IsOK(ecode1)) {
14320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14321 }
14322 arg1 = static_cast< int >(val1);
14323 {
14324 PyThreadState* __tstate = wxPyBeginAllowThreads();
14325 result = (bool)wxPyProcess::Exists(arg1);
14326 wxPyEndAllowThreads(__tstate);
14327 if (PyErr_Occurred()) SWIG_fail;
14328 }
14329 {
14330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14331 }
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14339 PyObject *resultobj = 0;
14340 wxString *arg1 = 0 ;
14341 int arg2 = (int) wxEXEC_ASYNC ;
14342 wxPyProcess *result = 0 ;
14343 bool temp1 = false ;
14344 int val2 ;
14345 int ecode2 = 0 ;
14346 PyObject * obj0 = 0 ;
14347 PyObject * obj1 = 0 ;
14348 char * kwnames[] = {
14349 (char *) "cmd",(char *) "flags", NULL
14350 };
14351
14352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14353 {
14354 arg1 = wxString_in_helper(obj0);
14355 if (arg1 == NULL) SWIG_fail;
14356 temp1 = true;
14357 }
14358 if (obj1) {
14359 ecode2 = SWIG_AsVal_int(obj1, &val2);
14360 if (!SWIG_IsOK(ecode2)) {
14361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14362 }
14363 arg2 = static_cast< int >(val2);
14364 }
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14372 {
14373 if (temp1)
14374 delete arg1;
14375 }
14376 return resultobj;
14377 fail:
14378 {
14379 if (temp1)
14380 delete arg1;
14381 }
14382 return NULL;
14383 }
14384
14385
14386 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14387 PyObject *resultobj = 0;
14388 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14389 int arg2 = (int) -1 ;
14390 wxPyProcess *result = 0 ;
14391 void *argp1 = 0 ;
14392 int res1 = 0 ;
14393 int val2 ;
14394 int ecode2 = 0 ;
14395 PyObject * obj0 = 0 ;
14396 PyObject * obj1 = 0 ;
14397 char * kwnames[] = {
14398 (char *) "parent",(char *) "id", NULL
14399 };
14400
14401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14402 if (obj0) {
14403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14404 if (!SWIG_IsOK(res1)) {
14405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14406 }
14407 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14408 }
14409 if (obj1) {
14410 ecode2 = SWIG_AsVal_int(obj1, &val2);
14411 if (!SWIG_IsOK(ecode2)) {
14412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14413 }
14414 arg2 = static_cast< int >(val2);
14415 }
14416 {
14417 PyThreadState* __tstate = wxPyBeginAllowThreads();
14418 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14419 wxPyEndAllowThreads(__tstate);
14420 if (PyErr_Occurred()) SWIG_fail;
14421 }
14422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14430 PyObject *resultobj = 0;
14431 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14432 void *argp1 = 0 ;
14433 int res1 = 0 ;
14434 PyObject *swig_obj[1] ;
14435
14436 if (!args) SWIG_fail;
14437 swig_obj[0] = args;
14438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14439 if (!SWIG_IsOK(res1)) {
14440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14441 }
14442 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 delete arg1;
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 resultobj = SWIG_Py_Void();
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj = 0;
14459 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14460 PyObject *arg2 = (PyObject *) 0 ;
14461 PyObject *arg3 = (PyObject *) 0 ;
14462 void *argp1 = 0 ;
14463 int res1 = 0 ;
14464 PyObject * obj0 = 0 ;
14465 PyObject * obj1 = 0 ;
14466 PyObject * obj2 = 0 ;
14467 char * kwnames[] = {
14468 (char *) "self",(char *) "self",(char *) "_class", NULL
14469 };
14470
14471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14473 if (!SWIG_IsOK(res1)) {
14474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14475 }
14476 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14477 arg2 = obj1;
14478 arg3 = obj2;
14479 {
14480 PyThreadState* __tstate = wxPyBeginAllowThreads();
14481 (arg1)->_setCallbackInfo(arg2,arg3);
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 resultobj = SWIG_Py_Void();
14486 return resultobj;
14487 fail:
14488 return NULL;
14489 }
14490
14491
14492 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14493 PyObject *resultobj = 0;
14494 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14495 long result;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 PyObject *swig_obj[1] ;
14499
14500 if (!args) SWIG_fail;
14501 swig_obj[0] = args;
14502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14503 if (!SWIG_IsOK(res1)) {
14504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14505 }
14506 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14507 {
14508 PyThreadState* __tstate = wxPyBeginAllowThreads();
14509 result = (long)((wxPyProcess const *)arg1)->GetPid();
14510 wxPyEndAllowThreads(__tstate);
14511 if (PyErr_Occurred()) SWIG_fail;
14512 }
14513 resultobj = SWIG_From_long(static_cast< long >(result));
14514 return resultobj;
14515 fail:
14516 return NULL;
14517 }
14518
14519
14520 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14521 PyObject *resultobj = 0;
14522 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14523 int arg2 ;
14524 int arg3 ;
14525 void *argp1 = 0 ;
14526 int res1 = 0 ;
14527 int val2 ;
14528 int ecode2 = 0 ;
14529 int val3 ;
14530 int ecode3 = 0 ;
14531 PyObject * obj0 = 0 ;
14532 PyObject * obj1 = 0 ;
14533 PyObject * obj2 = 0 ;
14534 char * kwnames[] = {
14535 (char *) "self",(char *) "pid",(char *) "status", NULL
14536 };
14537
14538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14540 if (!SWIG_IsOK(res1)) {
14541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14542 }
14543 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14544 ecode2 = SWIG_AsVal_int(obj1, &val2);
14545 if (!SWIG_IsOK(ecode2)) {
14546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14547 }
14548 arg2 = static_cast< int >(val2);
14549 ecode3 = SWIG_AsVal_int(obj2, &val3);
14550 if (!SWIG_IsOK(ecode3)) {
14551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14552 }
14553 arg3 = static_cast< int >(val3);
14554 {
14555 PyThreadState* __tstate = wxPyBeginAllowThreads();
14556 (arg1)->OnTerminate(arg2,arg3);
14557 wxPyEndAllowThreads(__tstate);
14558 if (PyErr_Occurred()) SWIG_fail;
14559 }
14560 resultobj = SWIG_Py_Void();
14561 return resultobj;
14562 fail:
14563 return NULL;
14564 }
14565
14566
14567 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14568 PyObject *resultobj = 0;
14569 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 PyObject *swig_obj[1] ;
14573
14574 if (!args) SWIG_fail;
14575 swig_obj[0] = args;
14576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14577 if (!SWIG_IsOK(res1)) {
14578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14579 }
14580 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14581 {
14582 PyThreadState* __tstate = wxPyBeginAllowThreads();
14583 (arg1)->Redirect();
14584 wxPyEndAllowThreads(__tstate);
14585 if (PyErr_Occurred()) SWIG_fail;
14586 }
14587 resultobj = SWIG_Py_Void();
14588 return resultobj;
14589 fail:
14590 return NULL;
14591 }
14592
14593
14594 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14595 PyObject *resultobj = 0;
14596 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14597 bool result;
14598 void *argp1 = 0 ;
14599 int res1 = 0 ;
14600 PyObject *swig_obj[1] ;
14601
14602 if (!args) SWIG_fail;
14603 swig_obj[0] = args;
14604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14605 if (!SWIG_IsOK(res1)) {
14606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14607 }
14608 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 result = (bool)(arg1)->IsRedirected();
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 {
14616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14617 }
14618 return resultobj;
14619 fail:
14620 return NULL;
14621 }
14622
14623
14624 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14625 PyObject *resultobj = 0;
14626 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14627 void *argp1 = 0 ;
14628 int res1 = 0 ;
14629 PyObject *swig_obj[1] ;
14630
14631 if (!args) SWIG_fail;
14632 swig_obj[0] = args;
14633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14636 }
14637 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14638 {
14639 PyThreadState* __tstate = wxPyBeginAllowThreads();
14640 (arg1)->Detach();
14641 wxPyEndAllowThreads(__tstate);
14642 if (PyErr_Occurred()) SWIG_fail;
14643 }
14644 resultobj = SWIG_Py_Void();
14645 return resultobj;
14646 fail:
14647 return NULL;
14648 }
14649
14650
14651 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14652 PyObject *resultobj = 0;
14653 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14654 wxInputStream *result = 0 ;
14655 void *argp1 = 0 ;
14656 int res1 = 0 ;
14657 PyObject *swig_obj[1] ;
14658
14659 if (!args) SWIG_fail;
14660 swig_obj[0] = args;
14661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14662 if (!SWIG_IsOK(res1)) {
14663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14664 }
14665 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14666 {
14667 PyThreadState* __tstate = wxPyBeginAllowThreads();
14668 result = (wxInputStream *)(arg1)->GetInputStream();
14669 wxPyEndAllowThreads(__tstate);
14670 if (PyErr_Occurred()) SWIG_fail;
14671 }
14672 {
14673 wxPyInputStream * _ptr = NULL;
14674
14675 if (result) {
14676 _ptr = new wxPyInputStream(result);
14677 }
14678 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14679 }
14680 return resultobj;
14681 fail:
14682 return NULL;
14683 }
14684
14685
14686 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14687 PyObject *resultobj = 0;
14688 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14689 wxInputStream *result = 0 ;
14690 void *argp1 = 0 ;
14691 int res1 = 0 ;
14692 PyObject *swig_obj[1] ;
14693
14694 if (!args) SWIG_fail;
14695 swig_obj[0] = args;
14696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14697 if (!SWIG_IsOK(res1)) {
14698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14699 }
14700 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14701 {
14702 PyThreadState* __tstate = wxPyBeginAllowThreads();
14703 result = (wxInputStream *)(arg1)->GetErrorStream();
14704 wxPyEndAllowThreads(__tstate);
14705 if (PyErr_Occurred()) SWIG_fail;
14706 }
14707 {
14708 wxPyInputStream * _ptr = NULL;
14709
14710 if (result) {
14711 _ptr = new wxPyInputStream(result);
14712 }
14713 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14714 }
14715 return resultobj;
14716 fail:
14717 return NULL;
14718 }
14719
14720
14721 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14722 PyObject *resultobj = 0;
14723 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14724 wxOutputStream *result = 0 ;
14725 void *argp1 = 0 ;
14726 int res1 = 0 ;
14727 PyObject *swig_obj[1] ;
14728
14729 if (!args) SWIG_fail;
14730 swig_obj[0] = args;
14731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14732 if (!SWIG_IsOK(res1)) {
14733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14734 }
14735 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14736 {
14737 PyThreadState* __tstate = wxPyBeginAllowThreads();
14738 result = (wxOutputStream *)(arg1)->GetOutputStream();
14739 wxPyEndAllowThreads(__tstate);
14740 if (PyErr_Occurred()) SWIG_fail;
14741 }
14742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14743 return resultobj;
14744 fail:
14745 return NULL;
14746 }
14747
14748
14749 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14750 PyObject *resultobj = 0;
14751 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14752 void *argp1 = 0 ;
14753 int res1 = 0 ;
14754 PyObject *swig_obj[1] ;
14755
14756 if (!args) SWIG_fail;
14757 swig_obj[0] = args;
14758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14761 }
14762 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14763 {
14764 PyThreadState* __tstate = wxPyBeginAllowThreads();
14765 (arg1)->CloseOutput();
14766 wxPyEndAllowThreads(__tstate);
14767 if (PyErr_Occurred()) SWIG_fail;
14768 }
14769 resultobj = SWIG_Py_Void();
14770 return resultobj;
14771 fail:
14772 return NULL;
14773 }
14774
14775
14776 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14777 PyObject *resultobj = 0;
14778 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14779 bool result;
14780 void *argp1 = 0 ;
14781 int res1 = 0 ;
14782 PyObject *swig_obj[1] ;
14783
14784 if (!args) SWIG_fail;
14785 swig_obj[0] = args;
14786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14787 if (!SWIG_IsOK(res1)) {
14788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14789 }
14790 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 {
14798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14799 }
14800 return resultobj;
14801 fail:
14802 return NULL;
14803 }
14804
14805
14806 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14807 PyObject *resultobj = 0;
14808 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14809 bool result;
14810 void *argp1 = 0 ;
14811 int res1 = 0 ;
14812 PyObject *swig_obj[1] ;
14813
14814 if (!args) SWIG_fail;
14815 swig_obj[0] = args;
14816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14817 if (!SWIG_IsOK(res1)) {
14818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14819 }
14820 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14821 {
14822 PyThreadState* __tstate = wxPyBeginAllowThreads();
14823 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 {
14828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14829 }
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14837 PyObject *resultobj = 0;
14838 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14839 bool result;
14840 void *argp1 = 0 ;
14841 int res1 = 0 ;
14842 PyObject *swig_obj[1] ;
14843
14844 if (!args) SWIG_fail;
14845 swig_obj[0] = args;
14846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14847 if (!SWIG_IsOK(res1)) {
14848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14849 }
14850 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14859 }
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14867 PyObject *obj;
14868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14869 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14870 return SWIG_Py_Void();
14871 }
14872
14873 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14874 return SWIG_Python_InitShadowInstance(args);
14875 }
14876
14877 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14878 PyObject *resultobj = 0;
14879 int arg1 = (int) 0 ;
14880 int arg2 = (int) 0 ;
14881 int arg3 = (int) 0 ;
14882 wxProcessEvent *result = 0 ;
14883 int val1 ;
14884 int ecode1 = 0 ;
14885 int val2 ;
14886 int ecode2 = 0 ;
14887 int val3 ;
14888 int ecode3 = 0 ;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 PyObject * obj2 = 0 ;
14892 char * kwnames[] = {
14893 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14894 };
14895
14896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14897 if (obj0) {
14898 ecode1 = SWIG_AsVal_int(obj0, &val1);
14899 if (!SWIG_IsOK(ecode1)) {
14900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14901 }
14902 arg1 = static_cast< int >(val1);
14903 }
14904 if (obj1) {
14905 ecode2 = SWIG_AsVal_int(obj1, &val2);
14906 if (!SWIG_IsOK(ecode2)) {
14907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14908 }
14909 arg2 = static_cast< int >(val2);
14910 }
14911 if (obj2) {
14912 ecode3 = SWIG_AsVal_int(obj2, &val3);
14913 if (!SWIG_IsOK(ecode3)) {
14914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14915 }
14916 arg3 = static_cast< int >(val3);
14917 }
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14921 wxPyEndAllowThreads(__tstate);
14922 if (PyErr_Occurred()) SWIG_fail;
14923 }
14924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14925 return resultobj;
14926 fail:
14927 return NULL;
14928 }
14929
14930
14931 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14932 PyObject *resultobj = 0;
14933 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14934 int result;
14935 void *argp1 = 0 ;
14936 int res1 = 0 ;
14937 PyObject *swig_obj[1] ;
14938
14939 if (!args) SWIG_fail;
14940 swig_obj[0] = args;
14941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14942 if (!SWIG_IsOK(res1)) {
14943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14944 }
14945 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14946 {
14947 PyThreadState* __tstate = wxPyBeginAllowThreads();
14948 result = (int)(arg1)->GetPid();
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 resultobj = SWIG_From_int(static_cast< int >(result));
14953 return resultobj;
14954 fail:
14955 return NULL;
14956 }
14957
14958
14959 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14960 PyObject *resultobj = 0;
14961 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14962 int result;
14963 void *argp1 = 0 ;
14964 int res1 = 0 ;
14965 PyObject *swig_obj[1] ;
14966
14967 if (!args) SWIG_fail;
14968 swig_obj[0] = args;
14969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14970 if (!SWIG_IsOK(res1)) {
14971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14972 }
14973 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14974 {
14975 PyThreadState* __tstate = wxPyBeginAllowThreads();
14976 result = (int)(arg1)->GetExitCode();
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 resultobj = SWIG_From_int(static_cast< int >(result));
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14988 PyObject *resultobj = 0;
14989 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14990 int arg2 ;
14991 void *argp1 = 0 ;
14992 int res1 = 0 ;
14993 int val2 ;
14994 int ecode2 = 0 ;
14995 PyObject *swig_obj[2] ;
14996
14997 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14999 if (!SWIG_IsOK(res1)) {
15000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15001 }
15002 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15003 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15004 if (!SWIG_IsOK(ecode2)) {
15005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
15006 }
15007 arg2 = static_cast< int >(val2);
15008 if (arg1) (arg1)->m_pid = arg2;
15009
15010 resultobj = SWIG_Py_Void();
15011 return resultobj;
15012 fail:
15013 return NULL;
15014 }
15015
15016
15017 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15018 PyObject *resultobj = 0;
15019 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15020 int result;
15021 void *argp1 = 0 ;
15022 int res1 = 0 ;
15023 PyObject *swig_obj[1] ;
15024
15025 if (!args) SWIG_fail;
15026 swig_obj[0] = args;
15027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15028 if (!SWIG_IsOK(res1)) {
15029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15030 }
15031 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15032 result = (int) ((arg1)->m_pid);
15033 resultobj = SWIG_From_int(static_cast< int >(result));
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15041 PyObject *resultobj = 0;
15042 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15043 int arg2 ;
15044 void *argp1 = 0 ;
15045 int res1 = 0 ;
15046 int val2 ;
15047 int ecode2 = 0 ;
15048 PyObject *swig_obj[2] ;
15049
15050 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15052 if (!SWIG_IsOK(res1)) {
15053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15054 }
15055 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15056 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15057 if (!SWIG_IsOK(ecode2)) {
15058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15059 }
15060 arg2 = static_cast< int >(val2);
15061 if (arg1) (arg1)->m_exitcode = arg2;
15062
15063 resultobj = SWIG_Py_Void();
15064 return resultobj;
15065 fail:
15066 return NULL;
15067 }
15068
15069
15070 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15071 PyObject *resultobj = 0;
15072 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15073 int result;
15074 void *argp1 = 0 ;
15075 int res1 = 0 ;
15076 PyObject *swig_obj[1] ;
15077
15078 if (!args) SWIG_fail;
15079 swig_obj[0] = args;
15080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15081 if (!SWIG_IsOK(res1)) {
15082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15083 }
15084 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15085 result = (int) ((arg1)->m_exitcode);
15086 resultobj = SWIG_From_int(static_cast< int >(result));
15087 return resultobj;
15088 fail:
15089 return NULL;
15090 }
15091
15092
15093 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15094 PyObject *obj;
15095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15096 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15097 return SWIG_Py_Void();
15098 }
15099
15100 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15101 return SWIG_Python_InitShadowInstance(args);
15102 }
15103
15104 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15105 PyObject *resultobj = 0;
15106 wxString *arg1 = 0 ;
15107 int arg2 = (int) wxEXEC_ASYNC ;
15108 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15109 long result;
15110 bool temp1 = false ;
15111 int val2 ;
15112 int ecode2 = 0 ;
15113 void *argp3 = 0 ;
15114 int res3 = 0 ;
15115 PyObject * obj0 = 0 ;
15116 PyObject * obj1 = 0 ;
15117 PyObject * obj2 = 0 ;
15118 char * kwnames[] = {
15119 (char *) "command",(char *) "flags",(char *) "process", NULL
15120 };
15121
15122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15123 {
15124 arg1 = wxString_in_helper(obj0);
15125 if (arg1 == NULL) SWIG_fail;
15126 temp1 = true;
15127 }
15128 if (obj1) {
15129 ecode2 = SWIG_AsVal_int(obj1, &val2);
15130 if (!SWIG_IsOK(ecode2)) {
15131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15132 }
15133 arg2 = static_cast< int >(val2);
15134 }
15135 if (obj2) {
15136 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15137 if (!SWIG_IsOK(res3)) {
15138 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15139 }
15140 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15141 }
15142 {
15143 if (!wxPyCheckForApp()) SWIG_fail;
15144 PyThreadState* __tstate = wxPyBeginAllowThreads();
15145 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15146 wxPyEndAllowThreads(__tstate);
15147 if (PyErr_Occurred()) SWIG_fail;
15148 }
15149 resultobj = SWIG_From_long(static_cast< long >(result));
15150 {
15151 if (temp1)
15152 delete arg1;
15153 }
15154 return resultobj;
15155 fail:
15156 {
15157 if (temp1)
15158 delete arg1;
15159 }
15160 return NULL;
15161 }
15162
15163
15164 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15165 PyObject *resultobj = 0;
15166 long arg1 ;
15167 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15168 wxKillError *arg3 = (wxKillError *) 0 ;
15169 int arg4 = (int) wxKILL_NOCHILDREN ;
15170 int result;
15171 long val1 ;
15172 int ecode1 = 0 ;
15173 int val2 ;
15174 int ecode2 = 0 ;
15175 wxKillError temp3 ;
15176 int val4 ;
15177 int ecode4 = 0 ;
15178 PyObject * obj0 = 0 ;
15179 PyObject * obj1 = 0 ;
15180 PyObject * obj2 = 0 ;
15181 char * kwnames[] = {
15182 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15183 };
15184
15185 {
15186 arg3 = &temp3;
15187 }
15188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15189 ecode1 = SWIG_AsVal_long(obj0, &val1);
15190 if (!SWIG_IsOK(ecode1)) {
15191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15192 }
15193 arg1 = static_cast< long >(val1);
15194 if (obj1) {
15195 ecode2 = SWIG_AsVal_int(obj1, &val2);
15196 if (!SWIG_IsOK(ecode2)) {
15197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15198 }
15199 arg2 = static_cast< wxSignal >(val2);
15200 }
15201 if (obj2) {
15202 ecode4 = SWIG_AsVal_int(obj2, &val4);
15203 if (!SWIG_IsOK(ecode4)) {
15204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15205 }
15206 arg4 = static_cast< int >(val4);
15207 }
15208 {
15209 PyThreadState* __tstate = wxPyBeginAllowThreads();
15210 result = (int)wxKill(arg1,arg2,arg3,arg4);
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 resultobj = SWIG_From_int(static_cast< int >(result));
15215 {
15216 PyObject* o;
15217 o = PyInt_FromLong((long) (*arg3));
15218
15219
15220
15221 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15222
15223 }
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15231 PyObject *resultobj = 0;
15232 int arg1 = (int) wxJOYSTICK1 ;
15233 wxJoystick *result = 0 ;
15234 int val1 ;
15235 int ecode1 = 0 ;
15236 PyObject * obj0 = 0 ;
15237 char * kwnames[] = {
15238 (char *) "joystick", NULL
15239 };
15240
15241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15242 if (obj0) {
15243 ecode1 = SWIG_AsVal_int(obj0, &val1);
15244 if (!SWIG_IsOK(ecode1)) {
15245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15246 }
15247 arg1 = static_cast< int >(val1);
15248 }
15249 {
15250 if (!wxPyCheckForApp()) SWIG_fail;
15251 PyThreadState* __tstate = wxPyBeginAllowThreads();
15252 result = (wxJoystick *)new wxJoystick(arg1);
15253 wxPyEndAllowThreads(__tstate);
15254 if (PyErr_Occurred()) SWIG_fail;
15255 }
15256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15257 return resultobj;
15258 fail:
15259 return NULL;
15260 }
15261
15262
15263 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15264 PyObject *resultobj = 0;
15265 wxJoystick *arg1 = (wxJoystick *) 0 ;
15266 void *argp1 = 0 ;
15267 int res1 = 0 ;
15268 PyObject *swig_obj[1] ;
15269
15270 if (!args) SWIG_fail;
15271 swig_obj[0] = args;
15272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15273 if (!SWIG_IsOK(res1)) {
15274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15275 }
15276 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 delete arg1;
15280
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 resultobj = SWIG_Py_Void();
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15292 PyObject *resultobj = 0;
15293 wxJoystick *arg1 = (wxJoystick *) 0 ;
15294 wxPoint result;
15295 void *argp1 = 0 ;
15296 int res1 = 0 ;
15297 PyObject *swig_obj[1] ;
15298
15299 if (!args) SWIG_fail;
15300 swig_obj[0] = args;
15301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15302 if (!SWIG_IsOK(res1)) {
15303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15304 }
15305 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 result = (arg1)->GetPosition();
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15320 PyObject *resultobj = 0;
15321 wxJoystick *arg1 = (wxJoystick *) 0 ;
15322 int result;
15323 void *argp1 = 0 ;
15324 int res1 = 0 ;
15325 PyObject *swig_obj[1] ;
15326
15327 if (!args) SWIG_fail;
15328 swig_obj[0] = args;
15329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15330 if (!SWIG_IsOK(res1)) {
15331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15332 }
15333 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (int)(arg1)->GetZPosition();
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 resultobj = SWIG_From_int(static_cast< int >(result));
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15348 PyObject *resultobj = 0;
15349 wxJoystick *arg1 = (wxJoystick *) 0 ;
15350 int result;
15351 void *argp1 = 0 ;
15352 int res1 = 0 ;
15353 PyObject *swig_obj[1] ;
15354
15355 if (!args) SWIG_fail;
15356 swig_obj[0] = args;
15357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15358 if (!SWIG_IsOK(res1)) {
15359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15360 }
15361 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (int)(arg1)->GetButtonState();
15365 wxPyEndAllowThreads(__tstate);
15366 if (PyErr_Occurred()) SWIG_fail;
15367 }
15368 resultobj = SWIG_From_int(static_cast< int >(result));
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15376 PyObject *resultobj = 0;
15377 wxJoystick *arg1 = (wxJoystick *) 0 ;
15378 int result;
15379 void *argp1 = 0 ;
15380 int res1 = 0 ;
15381 PyObject *swig_obj[1] ;
15382
15383 if (!args) SWIG_fail;
15384 swig_obj[0] = args;
15385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15386 if (!SWIG_IsOK(res1)) {
15387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15388 }
15389 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15390 {
15391 PyThreadState* __tstate = wxPyBeginAllowThreads();
15392 result = (int)(arg1)->GetPOVPosition();
15393 wxPyEndAllowThreads(__tstate);
15394 if (PyErr_Occurred()) SWIG_fail;
15395 }
15396 resultobj = SWIG_From_int(static_cast< int >(result));
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15404 PyObject *resultobj = 0;
15405 wxJoystick *arg1 = (wxJoystick *) 0 ;
15406 int result;
15407 void *argp1 = 0 ;
15408 int res1 = 0 ;
15409 PyObject *swig_obj[1] ;
15410
15411 if (!args) SWIG_fail;
15412 swig_obj[0] = args;
15413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15414 if (!SWIG_IsOK(res1)) {
15415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15416 }
15417 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15418 {
15419 PyThreadState* __tstate = wxPyBeginAllowThreads();
15420 result = (int)(arg1)->GetPOVCTSPosition();
15421 wxPyEndAllowThreads(__tstate);
15422 if (PyErr_Occurred()) SWIG_fail;
15423 }
15424 resultobj = SWIG_From_int(static_cast< int >(result));
15425 return resultobj;
15426 fail:
15427 return NULL;
15428 }
15429
15430
15431 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15432 PyObject *resultobj = 0;
15433 wxJoystick *arg1 = (wxJoystick *) 0 ;
15434 int result;
15435 void *argp1 = 0 ;
15436 int res1 = 0 ;
15437 PyObject *swig_obj[1] ;
15438
15439 if (!args) SWIG_fail;
15440 swig_obj[0] = args;
15441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15444 }
15445 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 result = (int)(arg1)->GetRudderPosition();
15449 wxPyEndAllowThreads(__tstate);
15450 if (PyErr_Occurred()) SWIG_fail;
15451 }
15452 resultobj = SWIG_From_int(static_cast< int >(result));
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15460 PyObject *resultobj = 0;
15461 wxJoystick *arg1 = (wxJoystick *) 0 ;
15462 int result;
15463 void *argp1 = 0 ;
15464 int res1 = 0 ;
15465 PyObject *swig_obj[1] ;
15466
15467 if (!args) SWIG_fail;
15468 swig_obj[0] = args;
15469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15472 }
15473 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 result = (int)(arg1)->GetUPosition();
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = SWIG_From_int(static_cast< int >(result));
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15488 PyObject *resultobj = 0;
15489 wxJoystick *arg1 = (wxJoystick *) 0 ;
15490 int result;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 PyObject *swig_obj[1] ;
15494
15495 if (!args) SWIG_fail;
15496 swig_obj[0] = args;
15497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15498 if (!SWIG_IsOK(res1)) {
15499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15500 }
15501 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15502 {
15503 PyThreadState* __tstate = wxPyBeginAllowThreads();
15504 result = (int)(arg1)->GetVPosition();
15505 wxPyEndAllowThreads(__tstate);
15506 if (PyErr_Occurred()) SWIG_fail;
15507 }
15508 resultobj = SWIG_From_int(static_cast< int >(result));
15509 return resultobj;
15510 fail:
15511 return NULL;
15512 }
15513
15514
15515 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15516 PyObject *resultobj = 0;
15517 wxJoystick *arg1 = (wxJoystick *) 0 ;
15518 int result;
15519 void *argp1 = 0 ;
15520 int res1 = 0 ;
15521 PyObject *swig_obj[1] ;
15522
15523 if (!args) SWIG_fail;
15524 swig_obj[0] = args;
15525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15526 if (!SWIG_IsOK(res1)) {
15527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15528 }
15529 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15530 {
15531 PyThreadState* __tstate = wxPyBeginAllowThreads();
15532 result = (int)(arg1)->GetMovementThreshold();
15533 wxPyEndAllowThreads(__tstate);
15534 if (PyErr_Occurred()) SWIG_fail;
15535 }
15536 resultobj = SWIG_From_int(static_cast< int >(result));
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15544 PyObject *resultobj = 0;
15545 wxJoystick *arg1 = (wxJoystick *) 0 ;
15546 int arg2 ;
15547 void *argp1 = 0 ;
15548 int res1 = 0 ;
15549 int val2 ;
15550 int ecode2 = 0 ;
15551 PyObject * obj0 = 0 ;
15552 PyObject * obj1 = 0 ;
15553 char * kwnames[] = {
15554 (char *) "self",(char *) "threshold", NULL
15555 };
15556
15557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15559 if (!SWIG_IsOK(res1)) {
15560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15561 }
15562 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15563 ecode2 = SWIG_AsVal_int(obj1, &val2);
15564 if (!SWIG_IsOK(ecode2)) {
15565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15566 }
15567 arg2 = static_cast< int >(val2);
15568 {
15569 PyThreadState* __tstate = wxPyBeginAllowThreads();
15570 (arg1)->SetMovementThreshold(arg2);
15571 wxPyEndAllowThreads(__tstate);
15572 if (PyErr_Occurred()) SWIG_fail;
15573 }
15574 resultobj = SWIG_Py_Void();
15575 return resultobj;
15576 fail:
15577 return NULL;
15578 }
15579
15580
15581 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15582 PyObject *resultobj = 0;
15583 wxJoystick *arg1 = (wxJoystick *) 0 ;
15584 bool result;
15585 void *argp1 = 0 ;
15586 int res1 = 0 ;
15587 PyObject *swig_obj[1] ;
15588
15589 if (!args) SWIG_fail;
15590 swig_obj[0] = args;
15591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15592 if (!SWIG_IsOK(res1)) {
15593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15594 }
15595 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 result = (bool)(arg1)->IsOk();
15599 wxPyEndAllowThreads(__tstate);
15600 if (PyErr_Occurred()) SWIG_fail;
15601 }
15602 {
15603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15604 }
15605 return resultobj;
15606 fail:
15607 return NULL;
15608 }
15609
15610
15611 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15612 PyObject *resultobj = 0;
15613 wxJoystick *arg1 = (wxJoystick *) 0 ;
15614 int result;
15615 void *argp1 = 0 ;
15616 int res1 = 0 ;
15617 PyObject *swig_obj[1] ;
15618
15619 if (!args) SWIG_fail;
15620 swig_obj[0] = args;
15621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15622 if (!SWIG_IsOK(res1)) {
15623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15624 }
15625 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15626 {
15627 PyThreadState* __tstate = wxPyBeginAllowThreads();
15628 result = (int)(arg1)->GetNumberJoysticks();
15629 wxPyEndAllowThreads(__tstate);
15630 if (PyErr_Occurred()) SWIG_fail;
15631 }
15632 resultobj = SWIG_From_int(static_cast< int >(result));
15633 return resultobj;
15634 fail:
15635 return NULL;
15636 }
15637
15638
15639 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15640 PyObject *resultobj = 0;
15641 wxJoystick *arg1 = (wxJoystick *) 0 ;
15642 int result;
15643 void *argp1 = 0 ;
15644 int res1 = 0 ;
15645 PyObject *swig_obj[1] ;
15646
15647 if (!args) SWIG_fail;
15648 swig_obj[0] = args;
15649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15650 if (!SWIG_IsOK(res1)) {
15651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15652 }
15653 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15654 {
15655 PyThreadState* __tstate = wxPyBeginAllowThreads();
15656 result = (int)(arg1)->GetManufacturerId();
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 resultobj = SWIG_From_int(static_cast< int >(result));
15661 return resultobj;
15662 fail:
15663 return NULL;
15664 }
15665
15666
15667 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15668 PyObject *resultobj = 0;
15669 wxJoystick *arg1 = (wxJoystick *) 0 ;
15670 int result;
15671 void *argp1 = 0 ;
15672 int res1 = 0 ;
15673 PyObject *swig_obj[1] ;
15674
15675 if (!args) SWIG_fail;
15676 swig_obj[0] = args;
15677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15678 if (!SWIG_IsOK(res1)) {
15679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15680 }
15681 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15682 {
15683 PyThreadState* __tstate = wxPyBeginAllowThreads();
15684 result = (int)(arg1)->GetProductId();
15685 wxPyEndAllowThreads(__tstate);
15686 if (PyErr_Occurred()) SWIG_fail;
15687 }
15688 resultobj = SWIG_From_int(static_cast< int >(result));
15689 return resultobj;
15690 fail:
15691 return NULL;
15692 }
15693
15694
15695 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15696 PyObject *resultobj = 0;
15697 wxJoystick *arg1 = (wxJoystick *) 0 ;
15698 wxString result;
15699 void *argp1 = 0 ;
15700 int res1 = 0 ;
15701 PyObject *swig_obj[1] ;
15702
15703 if (!args) SWIG_fail;
15704 swig_obj[0] = args;
15705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15706 if (!SWIG_IsOK(res1)) {
15707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15708 }
15709 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = (arg1)->GetProductName();
15713 wxPyEndAllowThreads(__tstate);
15714 if (PyErr_Occurred()) SWIG_fail;
15715 }
15716 {
15717 #if wxUSE_UNICODE
15718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15719 #else
15720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15721 #endif
15722 }
15723 return resultobj;
15724 fail:
15725 return NULL;
15726 }
15727
15728
15729 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15730 PyObject *resultobj = 0;
15731 wxJoystick *arg1 = (wxJoystick *) 0 ;
15732 int result;
15733 void *argp1 = 0 ;
15734 int res1 = 0 ;
15735 PyObject *swig_obj[1] ;
15736
15737 if (!args) SWIG_fail;
15738 swig_obj[0] = args;
15739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15740 if (!SWIG_IsOK(res1)) {
15741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15742 }
15743 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15744 {
15745 PyThreadState* __tstate = wxPyBeginAllowThreads();
15746 result = (int)(arg1)->GetXMin();
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 resultobj = SWIG_From_int(static_cast< int >(result));
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15758 PyObject *resultobj = 0;
15759 wxJoystick *arg1 = (wxJoystick *) 0 ;
15760 int result;
15761 void *argp1 = 0 ;
15762 int res1 = 0 ;
15763 PyObject *swig_obj[1] ;
15764
15765 if (!args) SWIG_fail;
15766 swig_obj[0] = args;
15767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15768 if (!SWIG_IsOK(res1)) {
15769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15770 }
15771 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 result = (int)(arg1)->GetYMin();
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 resultobj = SWIG_From_int(static_cast< int >(result));
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15786 PyObject *resultobj = 0;
15787 wxJoystick *arg1 = (wxJoystick *) 0 ;
15788 int result;
15789 void *argp1 = 0 ;
15790 int res1 = 0 ;
15791 PyObject *swig_obj[1] ;
15792
15793 if (!args) SWIG_fail;
15794 swig_obj[0] = args;
15795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15796 if (!SWIG_IsOK(res1)) {
15797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15798 }
15799 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15800 {
15801 PyThreadState* __tstate = wxPyBeginAllowThreads();
15802 result = (int)(arg1)->GetZMin();
15803 wxPyEndAllowThreads(__tstate);
15804 if (PyErr_Occurred()) SWIG_fail;
15805 }
15806 resultobj = SWIG_From_int(static_cast< int >(result));
15807 return resultobj;
15808 fail:
15809 return NULL;
15810 }
15811
15812
15813 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15814 PyObject *resultobj = 0;
15815 wxJoystick *arg1 = (wxJoystick *) 0 ;
15816 int result;
15817 void *argp1 = 0 ;
15818 int res1 = 0 ;
15819 PyObject *swig_obj[1] ;
15820
15821 if (!args) SWIG_fail;
15822 swig_obj[0] = args;
15823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15824 if (!SWIG_IsOK(res1)) {
15825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15826 }
15827 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15828 {
15829 PyThreadState* __tstate = wxPyBeginAllowThreads();
15830 result = (int)(arg1)->GetXMax();
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 resultobj = SWIG_From_int(static_cast< int >(result));
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15842 PyObject *resultobj = 0;
15843 wxJoystick *arg1 = (wxJoystick *) 0 ;
15844 int result;
15845 void *argp1 = 0 ;
15846 int res1 = 0 ;
15847 PyObject *swig_obj[1] ;
15848
15849 if (!args) SWIG_fail;
15850 swig_obj[0] = args;
15851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15852 if (!SWIG_IsOK(res1)) {
15853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15854 }
15855 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15856 {
15857 PyThreadState* __tstate = wxPyBeginAllowThreads();
15858 result = (int)(arg1)->GetYMax();
15859 wxPyEndAllowThreads(__tstate);
15860 if (PyErr_Occurred()) SWIG_fail;
15861 }
15862 resultobj = SWIG_From_int(static_cast< int >(result));
15863 return resultobj;
15864 fail:
15865 return NULL;
15866 }
15867
15868
15869 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15870 PyObject *resultobj = 0;
15871 wxJoystick *arg1 = (wxJoystick *) 0 ;
15872 int result;
15873 void *argp1 = 0 ;
15874 int res1 = 0 ;
15875 PyObject *swig_obj[1] ;
15876
15877 if (!args) SWIG_fail;
15878 swig_obj[0] = args;
15879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15880 if (!SWIG_IsOK(res1)) {
15881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15882 }
15883 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15884 {
15885 PyThreadState* __tstate = wxPyBeginAllowThreads();
15886 result = (int)(arg1)->GetZMax();
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 resultobj = SWIG_From_int(static_cast< int >(result));
15891 return resultobj;
15892 fail:
15893 return NULL;
15894 }
15895
15896
15897 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15898 PyObject *resultobj = 0;
15899 wxJoystick *arg1 = (wxJoystick *) 0 ;
15900 int result;
15901 void *argp1 = 0 ;
15902 int res1 = 0 ;
15903 PyObject *swig_obj[1] ;
15904
15905 if (!args) SWIG_fail;
15906 swig_obj[0] = args;
15907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15908 if (!SWIG_IsOK(res1)) {
15909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15910 }
15911 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15912 {
15913 PyThreadState* __tstate = wxPyBeginAllowThreads();
15914 result = (int)(arg1)->GetNumberButtons();
15915 wxPyEndAllowThreads(__tstate);
15916 if (PyErr_Occurred()) SWIG_fail;
15917 }
15918 resultobj = SWIG_From_int(static_cast< int >(result));
15919 return resultobj;
15920 fail:
15921 return NULL;
15922 }
15923
15924
15925 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15926 PyObject *resultobj = 0;
15927 wxJoystick *arg1 = (wxJoystick *) 0 ;
15928 int result;
15929 void *argp1 = 0 ;
15930 int res1 = 0 ;
15931 PyObject *swig_obj[1] ;
15932
15933 if (!args) SWIG_fail;
15934 swig_obj[0] = args;
15935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15938 }
15939 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 result = (int)(arg1)->GetNumberAxes();
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 resultobj = SWIG_From_int(static_cast< int >(result));
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15954 PyObject *resultobj = 0;
15955 wxJoystick *arg1 = (wxJoystick *) 0 ;
15956 int result;
15957 void *argp1 = 0 ;
15958 int res1 = 0 ;
15959 PyObject *swig_obj[1] ;
15960
15961 if (!args) SWIG_fail;
15962 swig_obj[0] = args;
15963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15964 if (!SWIG_IsOK(res1)) {
15965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15966 }
15967 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15968 {
15969 PyThreadState* __tstate = wxPyBeginAllowThreads();
15970 result = (int)(arg1)->GetMaxButtons();
15971 wxPyEndAllowThreads(__tstate);
15972 if (PyErr_Occurred()) SWIG_fail;
15973 }
15974 resultobj = SWIG_From_int(static_cast< int >(result));
15975 return resultobj;
15976 fail:
15977 return NULL;
15978 }
15979
15980
15981 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15982 PyObject *resultobj = 0;
15983 wxJoystick *arg1 = (wxJoystick *) 0 ;
15984 int result;
15985 void *argp1 = 0 ;
15986 int res1 = 0 ;
15987 PyObject *swig_obj[1] ;
15988
15989 if (!args) SWIG_fail;
15990 swig_obj[0] = args;
15991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15994 }
15995 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 result = (int)(arg1)->GetMaxAxes();
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_From_int(static_cast< int >(result));
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16010 PyObject *resultobj = 0;
16011 wxJoystick *arg1 = (wxJoystick *) 0 ;
16012 int result;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 PyObject *swig_obj[1] ;
16016
16017 if (!args) SWIG_fail;
16018 swig_obj[0] = args;
16019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16020 if (!SWIG_IsOK(res1)) {
16021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16022 }
16023 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 result = (int)(arg1)->GetPollingMin();
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 resultobj = SWIG_From_int(static_cast< int >(result));
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16038 PyObject *resultobj = 0;
16039 wxJoystick *arg1 = (wxJoystick *) 0 ;
16040 int result;
16041 void *argp1 = 0 ;
16042 int res1 = 0 ;
16043 PyObject *swig_obj[1] ;
16044
16045 if (!args) SWIG_fail;
16046 swig_obj[0] = args;
16047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16048 if (!SWIG_IsOK(res1)) {
16049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16050 }
16051 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16052 {
16053 PyThreadState* __tstate = wxPyBeginAllowThreads();
16054 result = (int)(arg1)->GetPollingMax();
16055 wxPyEndAllowThreads(__tstate);
16056 if (PyErr_Occurred()) SWIG_fail;
16057 }
16058 resultobj = SWIG_From_int(static_cast< int >(result));
16059 return resultobj;
16060 fail:
16061 return NULL;
16062 }
16063
16064
16065 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16066 PyObject *resultobj = 0;
16067 wxJoystick *arg1 = (wxJoystick *) 0 ;
16068 int result;
16069 void *argp1 = 0 ;
16070 int res1 = 0 ;
16071 PyObject *swig_obj[1] ;
16072
16073 if (!args) SWIG_fail;
16074 swig_obj[0] = args;
16075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16076 if (!SWIG_IsOK(res1)) {
16077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16078 }
16079 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16080 {
16081 PyThreadState* __tstate = wxPyBeginAllowThreads();
16082 result = (int)(arg1)->GetRudderMin();
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 resultobj = SWIG_From_int(static_cast< int >(result));
16087 return resultobj;
16088 fail:
16089 return NULL;
16090 }
16091
16092
16093 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16094 PyObject *resultobj = 0;
16095 wxJoystick *arg1 = (wxJoystick *) 0 ;
16096 int result;
16097 void *argp1 = 0 ;
16098 int res1 = 0 ;
16099 PyObject *swig_obj[1] ;
16100
16101 if (!args) SWIG_fail;
16102 swig_obj[0] = args;
16103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16104 if (!SWIG_IsOK(res1)) {
16105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16106 }
16107 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16108 {
16109 PyThreadState* __tstate = wxPyBeginAllowThreads();
16110 result = (int)(arg1)->GetRudderMax();
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 resultobj = SWIG_From_int(static_cast< int >(result));
16115 return resultobj;
16116 fail:
16117 return NULL;
16118 }
16119
16120
16121 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16122 PyObject *resultobj = 0;
16123 wxJoystick *arg1 = (wxJoystick *) 0 ;
16124 int result;
16125 void *argp1 = 0 ;
16126 int res1 = 0 ;
16127 PyObject *swig_obj[1] ;
16128
16129 if (!args) SWIG_fail;
16130 swig_obj[0] = args;
16131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16132 if (!SWIG_IsOK(res1)) {
16133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16134 }
16135 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16136 {
16137 PyThreadState* __tstate = wxPyBeginAllowThreads();
16138 result = (int)(arg1)->GetUMin();
16139 wxPyEndAllowThreads(__tstate);
16140 if (PyErr_Occurred()) SWIG_fail;
16141 }
16142 resultobj = SWIG_From_int(static_cast< int >(result));
16143 return resultobj;
16144 fail:
16145 return NULL;
16146 }
16147
16148
16149 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16150 PyObject *resultobj = 0;
16151 wxJoystick *arg1 = (wxJoystick *) 0 ;
16152 int result;
16153 void *argp1 = 0 ;
16154 int res1 = 0 ;
16155 PyObject *swig_obj[1] ;
16156
16157 if (!args) SWIG_fail;
16158 swig_obj[0] = args;
16159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16160 if (!SWIG_IsOK(res1)) {
16161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16162 }
16163 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16164 {
16165 PyThreadState* __tstate = wxPyBeginAllowThreads();
16166 result = (int)(arg1)->GetUMax();
16167 wxPyEndAllowThreads(__tstate);
16168 if (PyErr_Occurred()) SWIG_fail;
16169 }
16170 resultobj = SWIG_From_int(static_cast< int >(result));
16171 return resultobj;
16172 fail:
16173 return NULL;
16174 }
16175
16176
16177 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16178 PyObject *resultobj = 0;
16179 wxJoystick *arg1 = (wxJoystick *) 0 ;
16180 int result;
16181 void *argp1 = 0 ;
16182 int res1 = 0 ;
16183 PyObject *swig_obj[1] ;
16184
16185 if (!args) SWIG_fail;
16186 swig_obj[0] = args;
16187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16190 }
16191 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = (int)(arg1)->GetVMin();
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_From_int(static_cast< int >(result));
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16206 PyObject *resultobj = 0;
16207 wxJoystick *arg1 = (wxJoystick *) 0 ;
16208 int result;
16209 void *argp1 = 0 ;
16210 int res1 = 0 ;
16211 PyObject *swig_obj[1] ;
16212
16213 if (!args) SWIG_fail;
16214 swig_obj[0] = args;
16215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16216 if (!SWIG_IsOK(res1)) {
16217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16218 }
16219 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16220 {
16221 PyThreadState* __tstate = wxPyBeginAllowThreads();
16222 result = (int)(arg1)->GetVMax();
16223 wxPyEndAllowThreads(__tstate);
16224 if (PyErr_Occurred()) SWIG_fail;
16225 }
16226 resultobj = SWIG_From_int(static_cast< int >(result));
16227 return resultobj;
16228 fail:
16229 return NULL;
16230 }
16231
16232
16233 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16234 PyObject *resultobj = 0;
16235 wxJoystick *arg1 = (wxJoystick *) 0 ;
16236 bool result;
16237 void *argp1 = 0 ;
16238 int res1 = 0 ;
16239 PyObject *swig_obj[1] ;
16240
16241 if (!args) SWIG_fail;
16242 swig_obj[0] = args;
16243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16244 if (!SWIG_IsOK(res1)) {
16245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16246 }
16247 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16248 {
16249 PyThreadState* __tstate = wxPyBeginAllowThreads();
16250 result = (bool)(arg1)->HasRudder();
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 {
16255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16256 }
16257 return resultobj;
16258 fail:
16259 return NULL;
16260 }
16261
16262
16263 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16264 PyObject *resultobj = 0;
16265 wxJoystick *arg1 = (wxJoystick *) 0 ;
16266 bool result;
16267 void *argp1 = 0 ;
16268 int res1 = 0 ;
16269 PyObject *swig_obj[1] ;
16270
16271 if (!args) SWIG_fail;
16272 swig_obj[0] = args;
16273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16274 if (!SWIG_IsOK(res1)) {
16275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16276 }
16277 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16278 {
16279 PyThreadState* __tstate = wxPyBeginAllowThreads();
16280 result = (bool)(arg1)->HasZ();
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 {
16285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16286 }
16287 return resultobj;
16288 fail:
16289 return NULL;
16290 }
16291
16292
16293 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16294 PyObject *resultobj = 0;
16295 wxJoystick *arg1 = (wxJoystick *) 0 ;
16296 bool result;
16297 void *argp1 = 0 ;
16298 int res1 = 0 ;
16299 PyObject *swig_obj[1] ;
16300
16301 if (!args) SWIG_fail;
16302 swig_obj[0] = args;
16303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16304 if (!SWIG_IsOK(res1)) {
16305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16306 }
16307 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16308 {
16309 PyThreadState* __tstate = wxPyBeginAllowThreads();
16310 result = (bool)(arg1)->HasU();
16311 wxPyEndAllowThreads(__tstate);
16312 if (PyErr_Occurred()) SWIG_fail;
16313 }
16314 {
16315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16316 }
16317 return resultobj;
16318 fail:
16319 return NULL;
16320 }
16321
16322
16323 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16324 PyObject *resultobj = 0;
16325 wxJoystick *arg1 = (wxJoystick *) 0 ;
16326 bool result;
16327 void *argp1 = 0 ;
16328 int res1 = 0 ;
16329 PyObject *swig_obj[1] ;
16330
16331 if (!args) SWIG_fail;
16332 swig_obj[0] = args;
16333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16334 if (!SWIG_IsOK(res1)) {
16335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16336 }
16337 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 result = (bool)(arg1)->HasV();
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 {
16345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16346 }
16347 return resultobj;
16348 fail:
16349 return NULL;
16350 }
16351
16352
16353 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16354 PyObject *resultobj = 0;
16355 wxJoystick *arg1 = (wxJoystick *) 0 ;
16356 bool result;
16357 void *argp1 = 0 ;
16358 int res1 = 0 ;
16359 PyObject *swig_obj[1] ;
16360
16361 if (!args) SWIG_fail;
16362 swig_obj[0] = args;
16363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16364 if (!SWIG_IsOK(res1)) {
16365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16366 }
16367 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16368 {
16369 PyThreadState* __tstate = wxPyBeginAllowThreads();
16370 result = (bool)(arg1)->HasPOV();
16371 wxPyEndAllowThreads(__tstate);
16372 if (PyErr_Occurred()) SWIG_fail;
16373 }
16374 {
16375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16376 }
16377 return resultobj;
16378 fail:
16379 return NULL;
16380 }
16381
16382
16383 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16384 PyObject *resultobj = 0;
16385 wxJoystick *arg1 = (wxJoystick *) 0 ;
16386 bool result;
16387 void *argp1 = 0 ;
16388 int res1 = 0 ;
16389 PyObject *swig_obj[1] ;
16390
16391 if (!args) SWIG_fail;
16392 swig_obj[0] = args;
16393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16394 if (!SWIG_IsOK(res1)) {
16395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16396 }
16397 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16398 {
16399 PyThreadState* __tstate = wxPyBeginAllowThreads();
16400 result = (bool)(arg1)->HasPOV4Dir();
16401 wxPyEndAllowThreads(__tstate);
16402 if (PyErr_Occurred()) SWIG_fail;
16403 }
16404 {
16405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16406 }
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16414 PyObject *resultobj = 0;
16415 wxJoystick *arg1 = (wxJoystick *) 0 ;
16416 bool result;
16417 void *argp1 = 0 ;
16418 int res1 = 0 ;
16419 PyObject *swig_obj[1] ;
16420
16421 if (!args) SWIG_fail;
16422 swig_obj[0] = args;
16423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16426 }
16427 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (bool)(arg1)->HasPOVCTS();
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 {
16435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16436 }
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj = 0;
16445 wxJoystick *arg1 = (wxJoystick *) 0 ;
16446 wxWindow *arg2 = (wxWindow *) 0 ;
16447 int arg3 = (int) 0 ;
16448 bool result;
16449 void *argp1 = 0 ;
16450 int res1 = 0 ;
16451 void *argp2 = 0 ;
16452 int res2 = 0 ;
16453 int val3 ;
16454 int ecode3 = 0 ;
16455 PyObject * obj0 = 0 ;
16456 PyObject * obj1 = 0 ;
16457 PyObject * obj2 = 0 ;
16458 char * kwnames[] = {
16459 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16460 };
16461
16462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16464 if (!SWIG_IsOK(res1)) {
16465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16466 }
16467 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16468 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16469 if (!SWIG_IsOK(res2)) {
16470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16471 }
16472 arg2 = reinterpret_cast< wxWindow * >(argp2);
16473 if (obj2) {
16474 ecode3 = SWIG_AsVal_int(obj2, &val3);
16475 if (!SWIG_IsOK(ecode3)) {
16476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16477 }
16478 arg3 = static_cast< int >(val3);
16479 }
16480 {
16481 PyThreadState* __tstate = wxPyBeginAllowThreads();
16482 result = (bool)(arg1)->SetCapture(arg2,arg3);
16483 wxPyEndAllowThreads(__tstate);
16484 if (PyErr_Occurred()) SWIG_fail;
16485 }
16486 {
16487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16488 }
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16496 PyObject *resultobj = 0;
16497 wxJoystick *arg1 = (wxJoystick *) 0 ;
16498 bool result;
16499 void *argp1 = 0 ;
16500 int res1 = 0 ;
16501 PyObject *swig_obj[1] ;
16502
16503 if (!args) SWIG_fail;
16504 swig_obj[0] = args;
16505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16506 if (!SWIG_IsOK(res1)) {
16507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16508 }
16509 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)(arg1)->ReleaseCapture();
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 {
16517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16518 }
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16526 PyObject *obj;
16527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16528 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16529 return SWIG_Py_Void();
16530 }
16531
16532 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16533 return SWIG_Python_InitShadowInstance(args);
16534 }
16535
16536 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16537 PyObject *resultobj = 0;
16538 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16539 int arg2 = (int) 0 ;
16540 int arg3 = (int) wxJOYSTICK1 ;
16541 int arg4 = (int) 0 ;
16542 wxJoystickEvent *result = 0 ;
16543 int val1 ;
16544 int ecode1 = 0 ;
16545 int val2 ;
16546 int ecode2 = 0 ;
16547 int val3 ;
16548 int ecode3 = 0 ;
16549 int val4 ;
16550 int ecode4 = 0 ;
16551 PyObject * obj0 = 0 ;
16552 PyObject * obj1 = 0 ;
16553 PyObject * obj2 = 0 ;
16554 PyObject * obj3 = 0 ;
16555 char * kwnames[] = {
16556 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16557 };
16558
16559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16560 if (obj0) {
16561 ecode1 = SWIG_AsVal_int(obj0, &val1);
16562 if (!SWIG_IsOK(ecode1)) {
16563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16564 }
16565 arg1 = static_cast< wxEventType >(val1);
16566 }
16567 if (obj1) {
16568 ecode2 = SWIG_AsVal_int(obj1, &val2);
16569 if (!SWIG_IsOK(ecode2)) {
16570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16571 }
16572 arg2 = static_cast< int >(val2);
16573 }
16574 if (obj2) {
16575 ecode3 = SWIG_AsVal_int(obj2, &val3);
16576 if (!SWIG_IsOK(ecode3)) {
16577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16578 }
16579 arg3 = static_cast< int >(val3);
16580 }
16581 if (obj3) {
16582 ecode4 = SWIG_AsVal_int(obj3, &val4);
16583 if (!SWIG_IsOK(ecode4)) {
16584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16585 }
16586 arg4 = static_cast< int >(val4);
16587 }
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16595 return resultobj;
16596 fail:
16597 return NULL;
16598 }
16599
16600
16601 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16602 PyObject *resultobj = 0;
16603 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16604 wxPoint result;
16605 void *argp1 = 0 ;
16606 int res1 = 0 ;
16607 PyObject *swig_obj[1] ;
16608
16609 if (!args) SWIG_fail;
16610 swig_obj[0] = args;
16611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16612 if (!SWIG_IsOK(res1)) {
16613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16614 }
16615 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16630 PyObject *resultobj = 0;
16631 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16632 int result;
16633 void *argp1 = 0 ;
16634 int res1 = 0 ;
16635 PyObject *swig_obj[1] ;
16636
16637 if (!args) SWIG_fail;
16638 swig_obj[0] = args;
16639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16640 if (!SWIG_IsOK(res1)) {
16641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16642 }
16643 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16644 {
16645 PyThreadState* __tstate = wxPyBeginAllowThreads();
16646 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 resultobj = SWIG_From_int(static_cast< int >(result));
16651 return resultobj;
16652 fail:
16653 return NULL;
16654 }
16655
16656
16657 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16658 PyObject *resultobj = 0;
16659 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16660 int result;
16661 void *argp1 = 0 ;
16662 int res1 = 0 ;
16663 PyObject *swig_obj[1] ;
16664
16665 if (!args) SWIG_fail;
16666 swig_obj[0] = args;
16667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16668 if (!SWIG_IsOK(res1)) {
16669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16670 }
16671 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_From_int(static_cast< int >(result));
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16686 PyObject *resultobj = 0;
16687 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16688 int result;
16689 void *argp1 = 0 ;
16690 int res1 = 0 ;
16691 PyObject *swig_obj[1] ;
16692
16693 if (!args) SWIG_fail;
16694 swig_obj[0] = args;
16695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16696 if (!SWIG_IsOK(res1)) {
16697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16698 }
16699 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 resultobj = SWIG_From_int(static_cast< int >(result));
16707 return resultobj;
16708 fail:
16709 return NULL;
16710 }
16711
16712
16713 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16714 PyObject *resultobj = 0;
16715 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16716 int result;
16717 void *argp1 = 0 ;
16718 int res1 = 0 ;
16719 PyObject *swig_obj[1] ;
16720
16721 if (!args) SWIG_fail;
16722 swig_obj[0] = args;
16723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16724 if (!SWIG_IsOK(res1)) {
16725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16726 }
16727 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16728 {
16729 PyThreadState* __tstate = wxPyBeginAllowThreads();
16730 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 resultobj = SWIG_From_int(static_cast< int >(result));
16735 return resultobj;
16736 fail:
16737 return NULL;
16738 }
16739
16740
16741 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16742 PyObject *resultobj = 0;
16743 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16744 int arg2 ;
16745 void *argp1 = 0 ;
16746 int res1 = 0 ;
16747 int val2 ;
16748 int ecode2 = 0 ;
16749 PyObject * obj0 = 0 ;
16750 PyObject * obj1 = 0 ;
16751 char * kwnames[] = {
16752 (char *) "self",(char *) "stick", NULL
16753 };
16754
16755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16757 if (!SWIG_IsOK(res1)) {
16758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16759 }
16760 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16761 ecode2 = SWIG_AsVal_int(obj1, &val2);
16762 if (!SWIG_IsOK(ecode2)) {
16763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16764 }
16765 arg2 = static_cast< int >(val2);
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 (arg1)->SetJoystick(arg2);
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 resultobj = SWIG_Py_Void();
16773 return resultobj;
16774 fail:
16775 return NULL;
16776 }
16777
16778
16779 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16780 PyObject *resultobj = 0;
16781 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16782 int arg2 ;
16783 void *argp1 = 0 ;
16784 int res1 = 0 ;
16785 int val2 ;
16786 int ecode2 = 0 ;
16787 PyObject * obj0 = 0 ;
16788 PyObject * obj1 = 0 ;
16789 char * kwnames[] = {
16790 (char *) "self",(char *) "state", NULL
16791 };
16792
16793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16795 if (!SWIG_IsOK(res1)) {
16796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16797 }
16798 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16799 ecode2 = SWIG_AsVal_int(obj1, &val2);
16800 if (!SWIG_IsOK(ecode2)) {
16801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16802 }
16803 arg2 = static_cast< int >(val2);
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 (arg1)->SetButtonState(arg2);
16807 wxPyEndAllowThreads(__tstate);
16808 if (PyErr_Occurred()) SWIG_fail;
16809 }
16810 resultobj = SWIG_Py_Void();
16811 return resultobj;
16812 fail:
16813 return NULL;
16814 }
16815
16816
16817 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16818 PyObject *resultobj = 0;
16819 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16820 int arg2 ;
16821 void *argp1 = 0 ;
16822 int res1 = 0 ;
16823 int val2 ;
16824 int ecode2 = 0 ;
16825 PyObject * obj0 = 0 ;
16826 PyObject * obj1 = 0 ;
16827 char * kwnames[] = {
16828 (char *) "self",(char *) "change", NULL
16829 };
16830
16831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16835 }
16836 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16837 ecode2 = SWIG_AsVal_int(obj1, &val2);
16838 if (!SWIG_IsOK(ecode2)) {
16839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16840 }
16841 arg2 = static_cast< int >(val2);
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 (arg1)->SetButtonChange(arg2);
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 resultobj = SWIG_Py_Void();
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16856 PyObject *resultobj = 0;
16857 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16858 wxPoint *arg2 = 0 ;
16859 void *argp1 = 0 ;
16860 int res1 = 0 ;
16861 wxPoint temp2 ;
16862 PyObject * obj0 = 0 ;
16863 PyObject * obj1 = 0 ;
16864 char * kwnames[] = {
16865 (char *) "self",(char *) "pos", NULL
16866 };
16867
16868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16870 if (!SWIG_IsOK(res1)) {
16871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16872 }
16873 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16874 {
16875 arg2 = &temp2;
16876 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16877 }
16878 {
16879 PyThreadState* __tstate = wxPyBeginAllowThreads();
16880 (arg1)->SetPosition((wxPoint const &)*arg2);
16881 wxPyEndAllowThreads(__tstate);
16882 if (PyErr_Occurred()) SWIG_fail;
16883 }
16884 resultobj = SWIG_Py_Void();
16885 return resultobj;
16886 fail:
16887 return NULL;
16888 }
16889
16890
16891 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16892 PyObject *resultobj = 0;
16893 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16894 int arg2 ;
16895 void *argp1 = 0 ;
16896 int res1 = 0 ;
16897 int val2 ;
16898 int ecode2 = 0 ;
16899 PyObject * obj0 = 0 ;
16900 PyObject * obj1 = 0 ;
16901 char * kwnames[] = {
16902 (char *) "self",(char *) "zPos", NULL
16903 };
16904
16905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16909 }
16910 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16911 ecode2 = SWIG_AsVal_int(obj1, &val2);
16912 if (!SWIG_IsOK(ecode2)) {
16913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16914 }
16915 arg2 = static_cast< int >(val2);
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 (arg1)->SetZPosition(arg2);
16919 wxPyEndAllowThreads(__tstate);
16920 if (PyErr_Occurred()) SWIG_fail;
16921 }
16922 resultobj = SWIG_Py_Void();
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16930 PyObject *resultobj = 0;
16931 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16932 bool result;
16933 void *argp1 = 0 ;
16934 int res1 = 0 ;
16935 PyObject *swig_obj[1] ;
16936
16937 if (!args) SWIG_fail;
16938 swig_obj[0] = args;
16939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16940 if (!SWIG_IsOK(res1)) {
16941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16942 }
16943 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 {
16951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16952 }
16953 return resultobj;
16954 fail:
16955 return NULL;
16956 }
16957
16958
16959 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16960 PyObject *resultobj = 0;
16961 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16962 bool result;
16963 void *argp1 = 0 ;
16964 int res1 = 0 ;
16965 PyObject *swig_obj[1] ;
16966
16967 if (!args) SWIG_fail;
16968 swig_obj[0] = args;
16969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16970 if (!SWIG_IsOK(res1)) {
16971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16972 }
16973 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16977 wxPyEndAllowThreads(__tstate);
16978 if (PyErr_Occurred()) SWIG_fail;
16979 }
16980 {
16981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16982 }
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16990 PyObject *resultobj = 0;
16991 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16992 bool result;
16993 void *argp1 = 0 ;
16994 int res1 = 0 ;
16995 PyObject *swig_obj[1] ;
16996
16997 if (!args) SWIG_fail;
16998 swig_obj[0] = args;
16999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17000 if (!SWIG_IsOK(res1)) {
17001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17002 }
17003 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 {
17011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17012 }
17013 return resultobj;
17014 fail:
17015 return NULL;
17016 }
17017
17018
17019 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17020 PyObject *resultobj = 0;
17021 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17022 int arg2 = (int) wxJOY_BUTTON_ANY ;
17023 bool result;
17024 void *argp1 = 0 ;
17025 int res1 = 0 ;
17026 int val2 ;
17027 int ecode2 = 0 ;
17028 PyObject * obj0 = 0 ;
17029 PyObject * obj1 = 0 ;
17030 char * kwnames[] = {
17031 (char *) "self",(char *) "but", NULL
17032 };
17033
17034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17036 if (!SWIG_IsOK(res1)) {
17037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17038 }
17039 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17040 if (obj1) {
17041 ecode2 = SWIG_AsVal_int(obj1, &val2);
17042 if (!SWIG_IsOK(ecode2)) {
17043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17044 }
17045 arg2 = static_cast< int >(val2);
17046 }
17047 {
17048 PyThreadState* __tstate = wxPyBeginAllowThreads();
17049 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17050 wxPyEndAllowThreads(__tstate);
17051 if (PyErr_Occurred()) SWIG_fail;
17052 }
17053 {
17054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17055 }
17056 return resultobj;
17057 fail:
17058 return NULL;
17059 }
17060
17061
17062 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17063 PyObject *resultobj = 0;
17064 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17065 int arg2 = (int) wxJOY_BUTTON_ANY ;
17066 bool result;
17067 void *argp1 = 0 ;
17068 int res1 = 0 ;
17069 int val2 ;
17070 int ecode2 = 0 ;
17071 PyObject * obj0 = 0 ;
17072 PyObject * obj1 = 0 ;
17073 char * kwnames[] = {
17074 (char *) "self",(char *) "but", NULL
17075 };
17076
17077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17079 if (!SWIG_IsOK(res1)) {
17080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17081 }
17082 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17083 if (obj1) {
17084 ecode2 = SWIG_AsVal_int(obj1, &val2);
17085 if (!SWIG_IsOK(ecode2)) {
17086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17087 }
17088 arg2 = static_cast< int >(val2);
17089 }
17090 {
17091 PyThreadState* __tstate = wxPyBeginAllowThreads();
17092 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17093 wxPyEndAllowThreads(__tstate);
17094 if (PyErr_Occurred()) SWIG_fail;
17095 }
17096 {
17097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17098 }
17099 return resultobj;
17100 fail:
17101 return NULL;
17102 }
17103
17104
17105 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj = 0;
17107 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17108 int arg2 = (int) wxJOY_BUTTON_ANY ;
17109 bool result;
17110 void *argp1 = 0 ;
17111 int res1 = 0 ;
17112 int val2 ;
17113 int ecode2 = 0 ;
17114 PyObject * obj0 = 0 ;
17115 PyObject * obj1 = 0 ;
17116 char * kwnames[] = {
17117 (char *) "self",(char *) "but", NULL
17118 };
17119
17120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17122 if (!SWIG_IsOK(res1)) {
17123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17124 }
17125 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17126 if (obj1) {
17127 ecode2 = SWIG_AsVal_int(obj1, &val2);
17128 if (!SWIG_IsOK(ecode2)) {
17129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17130 }
17131 arg2 = static_cast< int >(val2);
17132 }
17133 {
17134 PyThreadState* __tstate = wxPyBeginAllowThreads();
17135 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17136 wxPyEndAllowThreads(__tstate);
17137 if (PyErr_Occurred()) SWIG_fail;
17138 }
17139 {
17140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17141 }
17142 return resultobj;
17143 fail:
17144 return NULL;
17145 }
17146
17147
17148 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17149 PyObject *obj;
17150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17151 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17152 return SWIG_Py_Void();
17153 }
17154
17155 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17156 return SWIG_Python_InitShadowInstance(args);
17157 }
17158
17159 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17160 PyObject *resultobj = 0;
17161 wxString const &arg1_defvalue = wxPyEmptyString ;
17162 wxString *arg1 = (wxString *) &arg1_defvalue ;
17163 wxSound *result = 0 ;
17164 bool temp1 = false ;
17165 PyObject * obj0 = 0 ;
17166 char * kwnames[] = {
17167 (char *) "fileName", NULL
17168 };
17169
17170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17171 if (obj0) {
17172 {
17173 arg1 = wxString_in_helper(obj0);
17174 if (arg1 == NULL) SWIG_fail;
17175 temp1 = true;
17176 }
17177 }
17178 {
17179 if (!wxPyCheckForApp()) SWIG_fail;
17180 PyThreadState* __tstate = wxPyBeginAllowThreads();
17181 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17182 wxPyEndAllowThreads(__tstate);
17183 if (PyErr_Occurred()) SWIG_fail;
17184 }
17185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17186 {
17187 if (temp1)
17188 delete arg1;
17189 }
17190 return resultobj;
17191 fail:
17192 {
17193 if (temp1)
17194 delete arg1;
17195 }
17196 return NULL;
17197 }
17198
17199
17200 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17201 PyObject *resultobj = 0;
17202 PyObject *arg1 = (PyObject *) 0 ;
17203 wxSound *result = 0 ;
17204 PyObject * obj0 = 0 ;
17205 char * kwnames[] = {
17206 (char *) "data", NULL
17207 };
17208
17209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17210 arg1 = obj0;
17211 {
17212 if (!wxPyCheckForApp()) SWIG_fail;
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (wxSound *)new_wxSound(arg1);
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17226 PyObject *resultobj = 0;
17227 wxSound *arg1 = (wxSound *) 0 ;
17228 void *argp1 = 0 ;
17229 int res1 = 0 ;
17230 PyObject *swig_obj[1] ;
17231
17232 if (!args) SWIG_fail;
17233 swig_obj[0] = args;
17234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17235 if (!SWIG_IsOK(res1)) {
17236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17237 }
17238 arg1 = reinterpret_cast< wxSound * >(argp1);
17239 {
17240 PyThreadState* __tstate = wxPyBeginAllowThreads();
17241 delete arg1;
17242
17243 wxPyEndAllowThreads(__tstate);
17244 if (PyErr_Occurred()) SWIG_fail;
17245 }
17246 resultobj = SWIG_Py_Void();
17247 return resultobj;
17248 fail:
17249 return NULL;
17250 }
17251
17252
17253 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17254 PyObject *resultobj = 0;
17255 wxSound *arg1 = (wxSound *) 0 ;
17256 wxString *arg2 = 0 ;
17257 bool result;
17258 void *argp1 = 0 ;
17259 int res1 = 0 ;
17260 bool temp2 = false ;
17261 PyObject * obj0 = 0 ;
17262 PyObject * obj1 = 0 ;
17263 char * kwnames[] = {
17264 (char *) "self",(char *) "fileName", NULL
17265 };
17266
17267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17269 if (!SWIG_IsOK(res1)) {
17270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17271 }
17272 arg1 = reinterpret_cast< wxSound * >(argp1);
17273 {
17274 arg2 = wxString_in_helper(obj1);
17275 if (arg2 == NULL) SWIG_fail;
17276 temp2 = true;
17277 }
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (bool)(arg1)->Create((wxString const &)*arg2);
17281 wxPyEndAllowThreads(__tstate);
17282 if (PyErr_Occurred()) SWIG_fail;
17283 }
17284 {
17285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17286 }
17287 {
17288 if (temp2)
17289 delete arg2;
17290 }
17291 return resultobj;
17292 fail:
17293 {
17294 if (temp2)
17295 delete arg2;
17296 }
17297 return NULL;
17298 }
17299
17300
17301 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17302 PyObject *resultobj = 0;
17303 wxSound *arg1 = (wxSound *) 0 ;
17304 PyObject *arg2 = (PyObject *) 0 ;
17305 bool result;
17306 void *argp1 = 0 ;
17307 int res1 = 0 ;
17308 PyObject * obj0 = 0 ;
17309 PyObject * obj1 = 0 ;
17310 char * kwnames[] = {
17311 (char *) "self",(char *) "data", NULL
17312 };
17313
17314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17316 if (!SWIG_IsOK(res1)) {
17317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17318 }
17319 arg1 = reinterpret_cast< wxSound * >(argp1);
17320 arg2 = obj1;
17321 {
17322 PyThreadState* __tstate = wxPyBeginAllowThreads();
17323 result = (bool)wxSound_CreateFromData(arg1,arg2);
17324 wxPyEndAllowThreads(__tstate);
17325 if (PyErr_Occurred()) SWIG_fail;
17326 }
17327 {
17328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17329 }
17330 return resultobj;
17331 fail:
17332 return NULL;
17333 }
17334
17335
17336 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17337 PyObject *resultobj = 0;
17338 wxSound *arg1 = (wxSound *) 0 ;
17339 bool result;
17340 void *argp1 = 0 ;
17341 int res1 = 0 ;
17342 PyObject *swig_obj[1] ;
17343
17344 if (!args) SWIG_fail;
17345 swig_obj[0] = args;
17346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17347 if (!SWIG_IsOK(res1)) {
17348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17349 }
17350 arg1 = reinterpret_cast< wxSound * >(argp1);
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (bool)(arg1)->IsOk();
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 {
17358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17359 }
17360 return resultobj;
17361 fail:
17362 return NULL;
17363 }
17364
17365
17366 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17367 PyObject *resultobj = 0;
17368 wxSound *arg1 = (wxSound *) 0 ;
17369 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17370 bool result;
17371 void *argp1 = 0 ;
17372 int res1 = 0 ;
17373 unsigned int val2 ;
17374 int ecode2 = 0 ;
17375 PyObject * obj0 = 0 ;
17376 PyObject * obj1 = 0 ;
17377 char * kwnames[] = {
17378 (char *) "self",(char *) "flags", NULL
17379 };
17380
17381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17383 if (!SWIG_IsOK(res1)) {
17384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17385 }
17386 arg1 = reinterpret_cast< wxSound * >(argp1);
17387 if (obj1) {
17388 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17389 if (!SWIG_IsOK(ecode2)) {
17390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17391 }
17392 arg2 = static_cast< unsigned int >(val2);
17393 }
17394 {
17395 if (!wxPyCheckForApp()) SWIG_fail;
17396 PyThreadState* __tstate = wxPyBeginAllowThreads();
17397 result = (bool)((wxSound const *)arg1)->Play(arg2);
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 {
17402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17403 }
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj = 0;
17412 wxString *arg1 = 0 ;
17413 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17414 bool result;
17415 bool temp1 = false ;
17416 unsigned int val2 ;
17417 int ecode2 = 0 ;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 char * kwnames[] = {
17421 (char *) "filename",(char *) "flags", NULL
17422 };
17423
17424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17425 {
17426 arg1 = wxString_in_helper(obj0);
17427 if (arg1 == NULL) SWIG_fail;
17428 temp1 = true;
17429 }
17430 if (obj1) {
17431 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17432 if (!SWIG_IsOK(ecode2)) {
17433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17434 }
17435 arg2 = static_cast< unsigned int >(val2);
17436 }
17437 {
17438 if (!wxPyCheckForApp()) SWIG_fail;
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 {
17445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17446 }
17447 {
17448 if (temp1)
17449 delete arg1;
17450 }
17451 return resultobj;
17452 fail:
17453 {
17454 if (temp1)
17455 delete arg1;
17456 }
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 PyObject *resultobj = 0;
17463
17464 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17465 {
17466 if (!wxPyCheckForApp()) SWIG_fail;
17467 PyThreadState* __tstate = wxPyBeginAllowThreads();
17468 wxSound::Stop();
17469 wxPyEndAllowThreads(__tstate);
17470 if (PyErr_Occurred()) SWIG_fail;
17471 }
17472 resultobj = SWIG_Py_Void();
17473 return resultobj;
17474 fail:
17475 return NULL;
17476 }
17477
17478
17479 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17480 PyObject *obj;
17481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17482 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17483 return SWIG_Py_Void();
17484 }
17485
17486 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 return SWIG_Python_InitShadowInstance(args);
17488 }
17489
17490 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17491 PyObject *resultobj = 0;
17492 wxString *arg1 = 0 ;
17493 wxString *arg2 = 0 ;
17494 wxString *arg3 = 0 ;
17495 wxString *arg4 = 0 ;
17496 wxFileTypeInfo *result = 0 ;
17497 bool temp1 = false ;
17498 bool temp2 = false ;
17499 bool temp3 = false ;
17500 bool temp4 = false ;
17501 PyObject * obj0 = 0 ;
17502 PyObject * obj1 = 0 ;
17503 PyObject * obj2 = 0 ;
17504 PyObject * obj3 = 0 ;
17505 char * kwnames[] = {
17506 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17507 };
17508
17509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17510 {
17511 arg1 = wxString_in_helper(obj0);
17512 if (arg1 == NULL) SWIG_fail;
17513 temp1 = true;
17514 }
17515 {
17516 arg2 = wxString_in_helper(obj1);
17517 if (arg2 == NULL) SWIG_fail;
17518 temp2 = true;
17519 }
17520 {
17521 arg3 = wxString_in_helper(obj2);
17522 if (arg3 == NULL) SWIG_fail;
17523 temp3 = true;
17524 }
17525 {
17526 arg4 = wxString_in_helper(obj3);
17527 if (arg4 == NULL) SWIG_fail;
17528 temp4 = true;
17529 }
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17533 wxPyEndAllowThreads(__tstate);
17534 if (PyErr_Occurred()) SWIG_fail;
17535 }
17536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17537 {
17538 if (temp1)
17539 delete arg1;
17540 }
17541 {
17542 if (temp2)
17543 delete arg2;
17544 }
17545 {
17546 if (temp3)
17547 delete arg3;
17548 }
17549 {
17550 if (temp4)
17551 delete arg4;
17552 }
17553 return resultobj;
17554 fail:
17555 {
17556 if (temp1)
17557 delete arg1;
17558 }
17559 {
17560 if (temp2)
17561 delete arg2;
17562 }
17563 {
17564 if (temp3)
17565 delete arg3;
17566 }
17567 {
17568 if (temp4)
17569 delete arg4;
17570 }
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj = 0;
17577 wxArrayString *arg1 = 0 ;
17578 wxFileTypeInfo *result = 0 ;
17579 bool temp1 = false ;
17580 PyObject * obj0 = 0 ;
17581 char * kwnames[] = {
17582 (char *) "sArray", NULL
17583 };
17584
17585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17586 {
17587 if (! PySequence_Check(obj0)) {
17588 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17589 SWIG_fail;
17590 }
17591 arg1 = new wxArrayString;
17592 temp1 = true;
17593 int i, len=PySequence_Length(obj0);
17594 for (i=0; i<len; i++) {
17595 PyObject* item = PySequence_GetItem(obj0, i);
17596 wxString* s = wxString_in_helper(item);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 arg1->Add(*s);
17599 delete s;
17600 Py_DECREF(item);
17601 }
17602 }
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17610 {
17611 if (temp1) delete arg1;
17612 }
17613 return resultobj;
17614 fail:
17615 {
17616 if (temp1) delete arg1;
17617 }
17618 return NULL;
17619 }
17620
17621
17622 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17623 PyObject *resultobj = 0;
17624 wxFileTypeInfo *result = 0 ;
17625
17626 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17627 {
17628 PyThreadState* __tstate = wxPyBeginAllowThreads();
17629 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17630 wxPyEndAllowThreads(__tstate);
17631 if (PyErr_Occurred()) SWIG_fail;
17632 }
17633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17634 return resultobj;
17635 fail:
17636 return NULL;
17637 }
17638
17639
17640 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17641 PyObject *resultobj = 0;
17642 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17643 bool result;
17644 void *argp1 = 0 ;
17645 int res1 = 0 ;
17646 PyObject *swig_obj[1] ;
17647
17648 if (!args) SWIG_fail;
17649 swig_obj[0] = args;
17650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17651 if (!SWIG_IsOK(res1)) {
17652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17653 }
17654 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17655 {
17656 PyThreadState* __tstate = wxPyBeginAllowThreads();
17657 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17658 wxPyEndAllowThreads(__tstate);
17659 if (PyErr_Occurred()) SWIG_fail;
17660 }
17661 {
17662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17663 }
17664 return resultobj;
17665 fail:
17666 return NULL;
17667 }
17668
17669
17670 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17671 PyObject *resultobj = 0;
17672 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17673 wxString *arg2 = 0 ;
17674 int arg3 = (int) 0 ;
17675 void *argp1 = 0 ;
17676 int res1 = 0 ;
17677 bool temp2 = false ;
17678 int val3 ;
17679 int ecode3 = 0 ;
17680 PyObject * obj0 = 0 ;
17681 PyObject * obj1 = 0 ;
17682 PyObject * obj2 = 0 ;
17683 char * kwnames[] = {
17684 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17685 };
17686
17687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17689 if (!SWIG_IsOK(res1)) {
17690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17691 }
17692 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17693 {
17694 arg2 = wxString_in_helper(obj1);
17695 if (arg2 == NULL) SWIG_fail;
17696 temp2 = true;
17697 }
17698 if (obj2) {
17699 ecode3 = SWIG_AsVal_int(obj2, &val3);
17700 if (!SWIG_IsOK(ecode3)) {
17701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17702 }
17703 arg3 = static_cast< int >(val3);
17704 }
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17708 wxPyEndAllowThreads(__tstate);
17709 if (PyErr_Occurred()) SWIG_fail;
17710 }
17711 resultobj = SWIG_Py_Void();
17712 {
17713 if (temp2)
17714 delete arg2;
17715 }
17716 return resultobj;
17717 fail:
17718 {
17719 if (temp2)
17720 delete arg2;
17721 }
17722 return NULL;
17723 }
17724
17725
17726 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17727 PyObject *resultobj = 0;
17728 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17729 wxString *arg2 = 0 ;
17730 void *argp1 = 0 ;
17731 int res1 = 0 ;
17732 bool temp2 = false ;
17733 PyObject * obj0 = 0 ;
17734 PyObject * obj1 = 0 ;
17735 char * kwnames[] = {
17736 (char *) "self",(char *) "shortDesc", NULL
17737 };
17738
17739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17741 if (!SWIG_IsOK(res1)) {
17742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17743 }
17744 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17745 {
17746 arg2 = wxString_in_helper(obj1);
17747 if (arg2 == NULL) SWIG_fail;
17748 temp2 = true;
17749 }
17750 {
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 (arg1)->SetShortDesc((wxString const &)*arg2);
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 resultobj = SWIG_Py_Void();
17757 {
17758 if (temp2)
17759 delete arg2;
17760 }
17761 return resultobj;
17762 fail:
17763 {
17764 if (temp2)
17765 delete arg2;
17766 }
17767 return NULL;
17768 }
17769
17770
17771 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17772 PyObject *resultobj = 0;
17773 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17774 wxString *result = 0 ;
17775 void *argp1 = 0 ;
17776 int res1 = 0 ;
17777 PyObject *swig_obj[1] ;
17778
17779 if (!args) SWIG_fail;
17780 swig_obj[0] = args;
17781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17782 if (!SWIG_IsOK(res1)) {
17783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17784 }
17785 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 {
17789 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17790 result = (wxString *) &_result_ref;
17791 }
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 {
17796 #if wxUSE_UNICODE
17797 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17798 #else
17799 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17800 #endif
17801 }
17802 return resultobj;
17803 fail:
17804 return NULL;
17805 }
17806
17807
17808 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17809 PyObject *resultobj = 0;
17810 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17811 wxString *result = 0 ;
17812 void *argp1 = 0 ;
17813 int res1 = 0 ;
17814 PyObject *swig_obj[1] ;
17815
17816 if (!args) SWIG_fail;
17817 swig_obj[0] = args;
17818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17819 if (!SWIG_IsOK(res1)) {
17820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17821 }
17822 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17823 {
17824 PyThreadState* __tstate = wxPyBeginAllowThreads();
17825 {
17826 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17827 result = (wxString *) &_result_ref;
17828 }
17829 wxPyEndAllowThreads(__tstate);
17830 if (PyErr_Occurred()) SWIG_fail;
17831 }
17832 {
17833 #if wxUSE_UNICODE
17834 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17835 #else
17836 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17837 #endif
17838 }
17839 return resultobj;
17840 fail:
17841 return NULL;
17842 }
17843
17844
17845 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17846 PyObject *resultobj = 0;
17847 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17848 wxString *result = 0 ;
17849 void *argp1 = 0 ;
17850 int res1 = 0 ;
17851 PyObject *swig_obj[1] ;
17852
17853 if (!args) SWIG_fail;
17854 swig_obj[0] = args;
17855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17856 if (!SWIG_IsOK(res1)) {
17857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17858 }
17859 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 {
17863 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17864 result = (wxString *) &_result_ref;
17865 }
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 {
17870 #if wxUSE_UNICODE
17871 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17872 #else
17873 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17874 #endif
17875 }
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17885 wxString *result = 0 ;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 PyObject *swig_obj[1] ;
17889
17890 if (!args) SWIG_fail;
17891 swig_obj[0] = args;
17892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17893 if (!SWIG_IsOK(res1)) {
17894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17895 }
17896 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 {
17900 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17901 result = (wxString *) &_result_ref;
17902 }
17903 wxPyEndAllowThreads(__tstate);
17904 if (PyErr_Occurred()) SWIG_fail;
17905 }
17906 {
17907 #if wxUSE_UNICODE
17908 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17909 #else
17910 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17911 #endif
17912 }
17913 return resultobj;
17914 fail:
17915 return NULL;
17916 }
17917
17918
17919 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17920 PyObject *resultobj = 0;
17921 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17922 wxString *result = 0 ;
17923 void *argp1 = 0 ;
17924 int res1 = 0 ;
17925 PyObject *swig_obj[1] ;
17926
17927 if (!args) SWIG_fail;
17928 swig_obj[0] = args;
17929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17930 if (!SWIG_IsOK(res1)) {
17931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17932 }
17933 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17934 {
17935 PyThreadState* __tstate = wxPyBeginAllowThreads();
17936 {
17937 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17938 result = (wxString *) &_result_ref;
17939 }
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 {
17944 #if wxUSE_UNICODE
17945 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17946 #else
17947 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17948 #endif
17949 }
17950 return resultobj;
17951 fail:
17952 return NULL;
17953 }
17954
17955
17956 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17957 PyObject *resultobj = 0;
17958 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17959 wxArrayString *result = 0 ;
17960 void *argp1 = 0 ;
17961 int res1 = 0 ;
17962 PyObject *swig_obj[1] ;
17963
17964 if (!args) SWIG_fail;
17965 swig_obj[0] = args;
17966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17967 if (!SWIG_IsOK(res1)) {
17968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17969 }
17970 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17971 {
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 {
17974 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17975 result = (wxArrayString *) &_result_ref;
17976 }
17977 wxPyEndAllowThreads(__tstate);
17978 if (PyErr_Occurred()) SWIG_fail;
17979 }
17980 {
17981 resultobj = wxArrayString2PyList_helper(*result);
17982 }
17983 return resultobj;
17984 fail:
17985 return NULL;
17986 }
17987
17988
17989 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17990 PyObject *resultobj = 0;
17991 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17992 size_t result;
17993 void *argp1 = 0 ;
17994 int res1 = 0 ;
17995 PyObject *swig_obj[1] ;
17996
17997 if (!args) SWIG_fail;
17998 swig_obj[0] = args;
17999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18000 if (!SWIG_IsOK(res1)) {
18001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18002 }
18003 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18004 {
18005 PyThreadState* __tstate = wxPyBeginAllowThreads();
18006 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
18007 wxPyEndAllowThreads(__tstate);
18008 if (PyErr_Occurred()) SWIG_fail;
18009 }
18010 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18011 return resultobj;
18012 fail:
18013 return NULL;
18014 }
18015
18016
18017 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18018 PyObject *resultobj = 0;
18019 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18020 wxString *result = 0 ;
18021 void *argp1 = 0 ;
18022 int res1 = 0 ;
18023 PyObject *swig_obj[1] ;
18024
18025 if (!args) SWIG_fail;
18026 swig_obj[0] = args;
18027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18028 if (!SWIG_IsOK(res1)) {
18029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18030 }
18031 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18032 {
18033 PyThreadState* __tstate = wxPyBeginAllowThreads();
18034 {
18035 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18036 result = (wxString *) &_result_ref;
18037 }
18038 wxPyEndAllowThreads(__tstate);
18039 if (PyErr_Occurred()) SWIG_fail;
18040 }
18041 {
18042 #if wxUSE_UNICODE
18043 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18044 #else
18045 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18046 #endif
18047 }
18048 return resultobj;
18049 fail:
18050 return NULL;
18051 }
18052
18053
18054 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18055 PyObject *resultobj = 0;
18056 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18057 int result;
18058 void *argp1 = 0 ;
18059 int res1 = 0 ;
18060 PyObject *swig_obj[1] ;
18061
18062 if (!args) SWIG_fail;
18063 swig_obj[0] = args;
18064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18065 if (!SWIG_IsOK(res1)) {
18066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18067 }
18068 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18069 {
18070 PyThreadState* __tstate = wxPyBeginAllowThreads();
18071 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18072 wxPyEndAllowThreads(__tstate);
18073 if (PyErr_Occurred()) SWIG_fail;
18074 }
18075 resultobj = SWIG_From_int(static_cast< int >(result));
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18083 PyObject *obj;
18084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18085 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18086 return SWIG_Py_Void();
18087 }
18088
18089 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18090 return SWIG_Python_InitShadowInstance(args);
18091 }
18092
18093 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj = 0;
18095 wxFileTypeInfo *arg1 = 0 ;
18096 wxFileType *result = 0 ;
18097 void *argp1 = 0 ;
18098 int res1 = 0 ;
18099 PyObject * obj0 = 0 ;
18100 char * kwnames[] = {
18101 (char *) "ftInfo", NULL
18102 };
18103
18104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18105 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18108 }
18109 if (!argp1) {
18110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18111 }
18112 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18113 {
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18120 return resultobj;
18121 fail:
18122 return NULL;
18123 }
18124
18125
18126 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18127 PyObject *resultobj = 0;
18128 wxFileType *arg1 = (wxFileType *) 0 ;
18129 void *argp1 = 0 ;
18130 int res1 = 0 ;
18131 PyObject *swig_obj[1] ;
18132
18133 if (!args) SWIG_fail;
18134 swig_obj[0] = args;
18135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18136 if (!SWIG_IsOK(res1)) {
18137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18138 }
18139 arg1 = reinterpret_cast< wxFileType * >(argp1);
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 delete arg1;
18143
18144 wxPyEndAllowThreads(__tstate);
18145 if (PyErr_Occurred()) SWIG_fail;
18146 }
18147 resultobj = SWIG_Py_Void();
18148 return resultobj;
18149 fail:
18150 return NULL;
18151 }
18152
18153
18154 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18155 PyObject *resultobj = 0;
18156 wxFileType *arg1 = (wxFileType *) 0 ;
18157 PyObject *result = 0 ;
18158 void *argp1 = 0 ;
18159 int res1 = 0 ;
18160 PyObject *swig_obj[1] ;
18161
18162 if (!args) SWIG_fail;
18163 swig_obj[0] = args;
18164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18165 if (!SWIG_IsOK(res1)) {
18166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18167 }
18168 arg1 = reinterpret_cast< wxFileType * >(argp1);
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (PyObject *)wxFileType_GetMimeType(arg1);
18172 wxPyEndAllowThreads(__tstate);
18173 if (PyErr_Occurred()) SWIG_fail;
18174 }
18175 resultobj = result;
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *resultobj = 0;
18184 wxFileType *arg1 = (wxFileType *) 0 ;
18185 PyObject *result = 0 ;
18186 void *argp1 = 0 ;
18187 int res1 = 0 ;
18188 PyObject *swig_obj[1] ;
18189
18190 if (!args) SWIG_fail;
18191 swig_obj[0] = args;
18192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18193 if (!SWIG_IsOK(res1)) {
18194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18195 }
18196 arg1 = reinterpret_cast< wxFileType * >(argp1);
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 resultobj = result;
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18211 PyObject *resultobj = 0;
18212 wxFileType *arg1 = (wxFileType *) 0 ;
18213 PyObject *result = 0 ;
18214 void *argp1 = 0 ;
18215 int res1 = 0 ;
18216 PyObject *swig_obj[1] ;
18217
18218 if (!args) SWIG_fail;
18219 swig_obj[0] = args;
18220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18221 if (!SWIG_IsOK(res1)) {
18222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18223 }
18224 arg1 = reinterpret_cast< wxFileType * >(argp1);
18225 {
18226 PyThreadState* __tstate = wxPyBeginAllowThreads();
18227 result = (PyObject *)wxFileType_GetExtensions(arg1);
18228 wxPyEndAllowThreads(__tstate);
18229 if (PyErr_Occurred()) SWIG_fail;
18230 }
18231 resultobj = result;
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18239 PyObject *resultobj = 0;
18240 wxFileType *arg1 = (wxFileType *) 0 ;
18241 wxIcon *result = 0 ;
18242 void *argp1 = 0 ;
18243 int res1 = 0 ;
18244 PyObject *swig_obj[1] ;
18245
18246 if (!args) SWIG_fail;
18247 swig_obj[0] = args;
18248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18249 if (!SWIG_IsOK(res1)) {
18250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18251 }
18252 arg1 = reinterpret_cast< wxFileType * >(argp1);
18253 {
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 result = (wxIcon *)wxFileType_GetIcon(arg1);
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18267 PyObject *resultobj = 0;
18268 wxFileType *arg1 = (wxFileType *) 0 ;
18269 PyObject *result = 0 ;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 PyObject *swig_obj[1] ;
18273
18274 if (!args) SWIG_fail;
18275 swig_obj[0] = args;
18276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18277 if (!SWIG_IsOK(res1)) {
18278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18279 }
18280 arg1 = reinterpret_cast< wxFileType * >(argp1);
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 resultobj = result;
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18295 PyObject *resultobj = 0;
18296 wxFileType *arg1 = (wxFileType *) 0 ;
18297 PyObject *result = 0 ;
18298 void *argp1 = 0 ;
18299 int res1 = 0 ;
18300 PyObject *swig_obj[1] ;
18301
18302 if (!args) SWIG_fail;
18303 swig_obj[0] = args;
18304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18305 if (!SWIG_IsOK(res1)) {
18306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18307 }
18308 arg1 = reinterpret_cast< wxFileType * >(argp1);
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = (PyObject *)wxFileType_GetDescription(arg1);
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 resultobj = result;
18316 return resultobj;
18317 fail:
18318 return NULL;
18319 }
18320
18321
18322 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18323 PyObject *resultobj = 0;
18324 wxFileType *arg1 = (wxFileType *) 0 ;
18325 wxString *arg2 = 0 ;
18326 wxString const &arg3_defvalue = wxPyEmptyString ;
18327 wxString *arg3 = (wxString *) &arg3_defvalue ;
18328 PyObject *result = 0 ;
18329 void *argp1 = 0 ;
18330 int res1 = 0 ;
18331 bool temp2 = false ;
18332 bool temp3 = false ;
18333 PyObject * obj0 = 0 ;
18334 PyObject * obj1 = 0 ;
18335 PyObject * obj2 = 0 ;
18336 char * kwnames[] = {
18337 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18338 };
18339
18340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18344 }
18345 arg1 = reinterpret_cast< wxFileType * >(argp1);
18346 {
18347 arg2 = wxString_in_helper(obj1);
18348 if (arg2 == NULL) SWIG_fail;
18349 temp2 = true;
18350 }
18351 if (obj2) {
18352 {
18353 arg3 = wxString_in_helper(obj2);
18354 if (arg3 == NULL) SWIG_fail;
18355 temp3 = true;
18356 }
18357 }
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 resultobj = result;
18365 {
18366 if (temp2)
18367 delete arg2;
18368 }
18369 {
18370 if (temp3)
18371 delete arg3;
18372 }
18373 return resultobj;
18374 fail:
18375 {
18376 if (temp2)
18377 delete arg2;
18378 }
18379 {
18380 if (temp3)
18381 delete arg3;
18382 }
18383 return NULL;
18384 }
18385
18386
18387 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj = 0;
18389 wxFileType *arg1 = (wxFileType *) 0 ;
18390 wxString *arg2 = 0 ;
18391 wxString const &arg3_defvalue = wxPyEmptyString ;
18392 wxString *arg3 = (wxString *) &arg3_defvalue ;
18393 PyObject *result = 0 ;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 bool temp2 = false ;
18397 bool temp3 = false ;
18398 PyObject * obj0 = 0 ;
18399 PyObject * obj1 = 0 ;
18400 PyObject * obj2 = 0 ;
18401 char * kwnames[] = {
18402 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18403 };
18404
18405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18407 if (!SWIG_IsOK(res1)) {
18408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18409 }
18410 arg1 = reinterpret_cast< wxFileType * >(argp1);
18411 {
18412 arg2 = wxString_in_helper(obj1);
18413 if (arg2 == NULL) SWIG_fail;
18414 temp2 = true;
18415 }
18416 if (obj2) {
18417 {
18418 arg3 = wxString_in_helper(obj2);
18419 if (arg3 == NULL) SWIG_fail;
18420 temp3 = true;
18421 }
18422 }
18423 {
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18426 wxPyEndAllowThreads(__tstate);
18427 if (PyErr_Occurred()) SWIG_fail;
18428 }
18429 resultobj = result;
18430 {
18431 if (temp2)
18432 delete arg2;
18433 }
18434 {
18435 if (temp3)
18436 delete arg3;
18437 }
18438 return resultobj;
18439 fail:
18440 {
18441 if (temp2)
18442 delete arg2;
18443 }
18444 {
18445 if (temp3)
18446 delete arg3;
18447 }
18448 return NULL;
18449 }
18450
18451
18452 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18453 PyObject *resultobj = 0;
18454 wxFileType *arg1 = (wxFileType *) 0 ;
18455 wxString *arg2 = 0 ;
18456 wxString const &arg3_defvalue = wxPyEmptyString ;
18457 wxString *arg3 = (wxString *) &arg3_defvalue ;
18458 PyObject *result = 0 ;
18459 void *argp1 = 0 ;
18460 int res1 = 0 ;
18461 bool temp2 = false ;
18462 bool temp3 = false ;
18463 PyObject * obj0 = 0 ;
18464 PyObject * obj1 = 0 ;
18465 PyObject * obj2 = 0 ;
18466 char * kwnames[] = {
18467 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18468 };
18469
18470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18472 if (!SWIG_IsOK(res1)) {
18473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18474 }
18475 arg1 = reinterpret_cast< wxFileType * >(argp1);
18476 {
18477 arg2 = wxString_in_helper(obj1);
18478 if (arg2 == NULL) SWIG_fail;
18479 temp2 = true;
18480 }
18481 if (obj2) {
18482 {
18483 arg3 = wxString_in_helper(obj2);
18484 if (arg3 == NULL) SWIG_fail;
18485 temp3 = true;
18486 }
18487 }
18488 {
18489 PyThreadState* __tstate = wxPyBeginAllowThreads();
18490 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 resultobj = result;
18495 {
18496 if (temp2)
18497 delete arg2;
18498 }
18499 {
18500 if (temp3)
18501 delete arg3;
18502 }
18503 return resultobj;
18504 fail:
18505 {
18506 if (temp2)
18507 delete arg2;
18508 }
18509 {
18510 if (temp3)
18511 delete arg3;
18512 }
18513 return NULL;
18514 }
18515
18516
18517 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18518 PyObject *resultobj = 0;
18519 wxFileType *arg1 = (wxFileType *) 0 ;
18520 wxString *arg2 = 0 ;
18521 wxString *arg3 = 0 ;
18522 bool arg4 = (bool) true ;
18523 bool result;
18524 void *argp1 = 0 ;
18525 int res1 = 0 ;
18526 bool temp2 = false ;
18527 bool temp3 = false ;
18528 bool val4 ;
18529 int ecode4 = 0 ;
18530 PyObject * obj0 = 0 ;
18531 PyObject * obj1 = 0 ;
18532 PyObject * obj2 = 0 ;
18533 PyObject * obj3 = 0 ;
18534 char * kwnames[] = {
18535 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18536 };
18537
18538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18540 if (!SWIG_IsOK(res1)) {
18541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18542 }
18543 arg1 = reinterpret_cast< wxFileType * >(argp1);
18544 {
18545 arg2 = wxString_in_helper(obj1);
18546 if (arg2 == NULL) SWIG_fail;
18547 temp2 = true;
18548 }
18549 {
18550 arg3 = wxString_in_helper(obj2);
18551 if (arg3 == NULL) SWIG_fail;
18552 temp3 = true;
18553 }
18554 if (obj3) {
18555 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18556 if (!SWIG_IsOK(ecode4)) {
18557 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18558 }
18559 arg4 = static_cast< bool >(val4);
18560 }
18561 {
18562 PyThreadState* __tstate = wxPyBeginAllowThreads();
18563 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18564 wxPyEndAllowThreads(__tstate);
18565 if (PyErr_Occurred()) SWIG_fail;
18566 }
18567 {
18568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18569 }
18570 {
18571 if (temp2)
18572 delete arg2;
18573 }
18574 {
18575 if (temp3)
18576 delete arg3;
18577 }
18578 return resultobj;
18579 fail:
18580 {
18581 if (temp2)
18582 delete arg2;
18583 }
18584 {
18585 if (temp3)
18586 delete arg3;
18587 }
18588 return NULL;
18589 }
18590
18591
18592 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18593 PyObject *resultobj = 0;
18594 wxFileType *arg1 = (wxFileType *) 0 ;
18595 wxString const &arg2_defvalue = wxPyEmptyString ;
18596 wxString *arg2 = (wxString *) &arg2_defvalue ;
18597 int arg3 = (int) 0 ;
18598 bool result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 bool temp2 = false ;
18602 int val3 ;
18603 int ecode3 = 0 ;
18604 PyObject * obj0 = 0 ;
18605 PyObject * obj1 = 0 ;
18606 PyObject * obj2 = 0 ;
18607 char * kwnames[] = {
18608 (char *) "self",(char *) "cmd",(char *) "index", NULL
18609 };
18610
18611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18613 if (!SWIG_IsOK(res1)) {
18614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18615 }
18616 arg1 = reinterpret_cast< wxFileType * >(argp1);
18617 if (obj1) {
18618 {
18619 arg2 = wxString_in_helper(obj1);
18620 if (arg2 == NULL) SWIG_fail;
18621 temp2 = true;
18622 }
18623 }
18624 if (obj2) {
18625 ecode3 = SWIG_AsVal_int(obj2, &val3);
18626 if (!SWIG_IsOK(ecode3)) {
18627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18628 }
18629 arg3 = static_cast< int >(val3);
18630 }
18631 {
18632 PyThreadState* __tstate = wxPyBeginAllowThreads();
18633 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18634 wxPyEndAllowThreads(__tstate);
18635 if (PyErr_Occurred()) SWIG_fail;
18636 }
18637 {
18638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18639 }
18640 {
18641 if (temp2)
18642 delete arg2;
18643 }
18644 return resultobj;
18645 fail:
18646 {
18647 if (temp2)
18648 delete arg2;
18649 }
18650 return NULL;
18651 }
18652
18653
18654 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18655 PyObject *resultobj = 0;
18656 wxFileType *arg1 = (wxFileType *) 0 ;
18657 bool result;
18658 void *argp1 = 0 ;
18659 int res1 = 0 ;
18660 PyObject *swig_obj[1] ;
18661
18662 if (!args) SWIG_fail;
18663 swig_obj[0] = args;
18664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18665 if (!SWIG_IsOK(res1)) {
18666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18667 }
18668 arg1 = reinterpret_cast< wxFileType * >(argp1);
18669 {
18670 PyThreadState* __tstate = wxPyBeginAllowThreads();
18671 result = (bool)(arg1)->Unassociate();
18672 wxPyEndAllowThreads(__tstate);
18673 if (PyErr_Occurred()) SWIG_fail;
18674 }
18675 {
18676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18677 }
18678 return resultobj;
18679 fail:
18680 return NULL;
18681 }
18682
18683
18684 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18685 PyObject *resultobj = 0;
18686 wxString *arg1 = 0 ;
18687 wxString *arg2 = 0 ;
18688 wxString const &arg3_defvalue = wxPyEmptyString ;
18689 wxString *arg3 = (wxString *) &arg3_defvalue ;
18690 wxString result;
18691 bool temp1 = false ;
18692 bool temp2 = false ;
18693 bool temp3 = false ;
18694 PyObject * obj0 = 0 ;
18695 PyObject * obj1 = 0 ;
18696 PyObject * obj2 = 0 ;
18697 char * kwnames[] = {
18698 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18699 };
18700
18701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18702 {
18703 arg1 = wxString_in_helper(obj0);
18704 if (arg1 == NULL) SWIG_fail;
18705 temp1 = true;
18706 }
18707 {
18708 arg2 = wxString_in_helper(obj1);
18709 if (arg2 == NULL) SWIG_fail;
18710 temp2 = true;
18711 }
18712 if (obj2) {
18713 {
18714 arg3 = wxString_in_helper(obj2);
18715 if (arg3 == NULL) SWIG_fail;
18716 temp3 = true;
18717 }
18718 }
18719 {
18720 PyThreadState* __tstate = wxPyBeginAllowThreads();
18721 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18722 wxPyEndAllowThreads(__tstate);
18723 if (PyErr_Occurred()) SWIG_fail;
18724 }
18725 {
18726 #if wxUSE_UNICODE
18727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18728 #else
18729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18730 #endif
18731 }
18732 {
18733 if (temp1)
18734 delete arg1;
18735 }
18736 {
18737 if (temp2)
18738 delete arg2;
18739 }
18740 {
18741 if (temp3)
18742 delete arg3;
18743 }
18744 return resultobj;
18745 fail:
18746 {
18747 if (temp1)
18748 delete arg1;
18749 }
18750 {
18751 if (temp2)
18752 delete arg2;
18753 }
18754 {
18755 if (temp3)
18756 delete arg3;
18757 }
18758 return NULL;
18759 }
18760
18761
18762 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18763 PyObject *obj;
18764 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18765 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18766 return SWIG_Py_Void();
18767 }
18768
18769 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18770 return SWIG_Python_InitShadowInstance(args);
18771 }
18772
18773 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18774 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18775 return 1;
18776 }
18777
18778
18779 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18780 PyObject *pyobj = 0;
18781
18782 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18783 return pyobj;
18784 }
18785
18786
18787 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18788 PyObject *resultobj = 0;
18789 wxString *arg1 = 0 ;
18790 wxString *arg2 = 0 ;
18791 bool result;
18792 bool temp1 = false ;
18793 bool temp2 = false ;
18794 PyObject * obj0 = 0 ;
18795 PyObject * obj1 = 0 ;
18796 char * kwnames[] = {
18797 (char *) "mimeType",(char *) "wildcard", NULL
18798 };
18799
18800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18801 {
18802 arg1 = wxString_in_helper(obj0);
18803 if (arg1 == NULL) SWIG_fail;
18804 temp1 = true;
18805 }
18806 {
18807 arg2 = wxString_in_helper(obj1);
18808 if (arg2 == NULL) SWIG_fail;
18809 temp2 = true;
18810 }
18811 {
18812 PyThreadState* __tstate = wxPyBeginAllowThreads();
18813 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18814 wxPyEndAllowThreads(__tstate);
18815 if (PyErr_Occurred()) SWIG_fail;
18816 }
18817 {
18818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18819 }
18820 {
18821 if (temp1)
18822 delete arg1;
18823 }
18824 {
18825 if (temp2)
18826 delete arg2;
18827 }
18828 return resultobj;
18829 fail:
18830 {
18831 if (temp1)
18832 delete arg1;
18833 }
18834 {
18835 if (temp2)
18836 delete arg2;
18837 }
18838 return NULL;
18839 }
18840
18841
18842 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18843 PyObject *resultobj = 0;
18844 wxMimeTypesManager *result = 0 ;
18845
18846 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18861 PyObject *resultobj = 0;
18862 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18863 int arg2 = (int) wxMAILCAP_ALL ;
18864 wxString const &arg3_defvalue = wxPyEmptyString ;
18865 wxString *arg3 = (wxString *) &arg3_defvalue ;
18866 void *argp1 = 0 ;
18867 int res1 = 0 ;
18868 int val2 ;
18869 int ecode2 = 0 ;
18870 bool temp3 = false ;
18871 PyObject * obj0 = 0 ;
18872 PyObject * obj1 = 0 ;
18873 PyObject * obj2 = 0 ;
18874 char * kwnames[] = {
18875 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18876 };
18877
18878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18880 if (!SWIG_IsOK(res1)) {
18881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18882 }
18883 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18884 if (obj1) {
18885 ecode2 = SWIG_AsVal_int(obj1, &val2);
18886 if (!SWIG_IsOK(ecode2)) {
18887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18888 }
18889 arg2 = static_cast< int >(val2);
18890 }
18891 if (obj2) {
18892 {
18893 arg3 = wxString_in_helper(obj2);
18894 if (arg3 == NULL) SWIG_fail;
18895 temp3 = true;
18896 }
18897 }
18898 {
18899 PyThreadState* __tstate = wxPyBeginAllowThreads();
18900 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18901 wxPyEndAllowThreads(__tstate);
18902 if (PyErr_Occurred()) SWIG_fail;
18903 }
18904 resultobj = SWIG_Py_Void();
18905 {
18906 if (temp3)
18907 delete arg3;
18908 }
18909 return resultobj;
18910 fail:
18911 {
18912 if (temp3)
18913 delete arg3;
18914 }
18915 return NULL;
18916 }
18917
18918
18919 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18920 PyObject *resultobj = 0;
18921 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18922 void *argp1 = 0 ;
18923 int res1 = 0 ;
18924 PyObject *swig_obj[1] ;
18925
18926 if (!args) SWIG_fail;
18927 swig_obj[0] = args;
18928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18929 if (!SWIG_IsOK(res1)) {
18930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18931 }
18932 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18933 {
18934 PyThreadState* __tstate = wxPyBeginAllowThreads();
18935 (arg1)->ClearData();
18936 wxPyEndAllowThreads(__tstate);
18937 if (PyErr_Occurred()) SWIG_fail;
18938 }
18939 resultobj = SWIG_Py_Void();
18940 return resultobj;
18941 fail:
18942 return NULL;
18943 }
18944
18945
18946 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18947 PyObject *resultobj = 0;
18948 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18949 wxString *arg2 = 0 ;
18950 wxFileType *result = 0 ;
18951 void *argp1 = 0 ;
18952 int res1 = 0 ;
18953 bool temp2 = false ;
18954 PyObject * obj0 = 0 ;
18955 PyObject * obj1 = 0 ;
18956 char * kwnames[] = {
18957 (char *) "self",(char *) "ext", NULL
18958 };
18959
18960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18962 if (!SWIG_IsOK(res1)) {
18963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18964 }
18965 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18966 {
18967 arg2 = wxString_in_helper(obj1);
18968 if (arg2 == NULL) SWIG_fail;
18969 temp2 = true;
18970 }
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18978 {
18979 if (temp2)
18980 delete arg2;
18981 }
18982 return resultobj;
18983 fail:
18984 {
18985 if (temp2)
18986 delete arg2;
18987 }
18988 return NULL;
18989 }
18990
18991
18992 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18993 PyObject *resultobj = 0;
18994 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18995 wxString *arg2 = 0 ;
18996 wxFileType *result = 0 ;
18997 void *argp1 = 0 ;
18998 int res1 = 0 ;
18999 bool temp2 = false ;
19000 PyObject * obj0 = 0 ;
19001 PyObject * obj1 = 0 ;
19002 char * kwnames[] = {
19003 (char *) "self",(char *) "mimeType", NULL
19004 };
19005
19006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
19007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19008 if (!SWIG_IsOK(res1)) {
19009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19010 }
19011 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19012 {
19013 arg2 = wxString_in_helper(obj1);
19014 if (arg2 == NULL) SWIG_fail;
19015 temp2 = true;
19016 }
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19024 {
19025 if (temp2)
19026 delete arg2;
19027 }
19028 return resultobj;
19029 fail:
19030 {
19031 if (temp2)
19032 delete arg2;
19033 }
19034 return NULL;
19035 }
19036
19037
19038 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19039 PyObject *resultobj = 0;
19040 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19041 wxString *arg2 = 0 ;
19042 bool arg3 = (bool) false ;
19043 bool result;
19044 void *argp1 = 0 ;
19045 int res1 = 0 ;
19046 bool temp2 = false ;
19047 bool val3 ;
19048 int ecode3 = 0 ;
19049 PyObject * obj0 = 0 ;
19050 PyObject * obj1 = 0 ;
19051 PyObject * obj2 = 0 ;
19052 char * kwnames[] = {
19053 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19054 };
19055
19056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19058 if (!SWIG_IsOK(res1)) {
19059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19060 }
19061 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19062 {
19063 arg2 = wxString_in_helper(obj1);
19064 if (arg2 == NULL) SWIG_fail;
19065 temp2 = true;
19066 }
19067 if (obj2) {
19068 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19069 if (!SWIG_IsOK(ecode3)) {
19070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19071 }
19072 arg3 = static_cast< bool >(val3);
19073 }
19074 {
19075 PyThreadState* __tstate = wxPyBeginAllowThreads();
19076 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 {
19081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19082 }
19083 {
19084 if (temp2)
19085 delete arg2;
19086 }
19087 return resultobj;
19088 fail:
19089 {
19090 if (temp2)
19091 delete arg2;
19092 }
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj = 0;
19099 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19100 wxString *arg2 = 0 ;
19101 bool result;
19102 void *argp1 = 0 ;
19103 int res1 = 0 ;
19104 bool temp2 = false ;
19105 PyObject * obj0 = 0 ;
19106 PyObject * obj1 = 0 ;
19107 char * kwnames[] = {
19108 (char *) "self",(char *) "filename", NULL
19109 };
19110
19111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19113 if (!SWIG_IsOK(res1)) {
19114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19115 }
19116 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19117 {
19118 arg2 = wxString_in_helper(obj1);
19119 if (arg2 == NULL) SWIG_fail;
19120 temp2 = true;
19121 }
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 {
19129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19130 }
19131 {
19132 if (temp2)
19133 delete arg2;
19134 }
19135 return resultobj;
19136 fail:
19137 {
19138 if (temp2)
19139 delete arg2;
19140 }
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19146 PyObject *resultobj = 0;
19147 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19148 PyObject *result = 0 ;
19149 void *argp1 = 0 ;
19150 int res1 = 0 ;
19151 PyObject *swig_obj[1] ;
19152
19153 if (!args) SWIG_fail;
19154 swig_obj[0] = args;
19155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19156 if (!SWIG_IsOK(res1)) {
19157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19158 }
19159 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19160 {
19161 PyThreadState* __tstate = wxPyBeginAllowThreads();
19162 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19163 wxPyEndAllowThreads(__tstate);
19164 if (PyErr_Occurred()) SWIG_fail;
19165 }
19166 resultobj = result;
19167 return resultobj;
19168 fail:
19169 return NULL;
19170 }
19171
19172
19173 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19174 PyObject *resultobj = 0;
19175 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19176 wxFileTypeInfo *arg2 = 0 ;
19177 void *argp1 = 0 ;
19178 int res1 = 0 ;
19179 void *argp2 = 0 ;
19180 int res2 = 0 ;
19181 PyObject * obj0 = 0 ;
19182 PyObject * obj1 = 0 ;
19183 char * kwnames[] = {
19184 (char *) "self",(char *) "ft", NULL
19185 };
19186
19187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19189 if (!SWIG_IsOK(res1)) {
19190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19191 }
19192 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19193 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19194 if (!SWIG_IsOK(res2)) {
19195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19196 }
19197 if (!argp2) {
19198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19199 }
19200 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 resultobj = SWIG_Py_Void();
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19215 PyObject *resultobj = 0;
19216 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19217 wxFileTypeInfo *arg2 = 0 ;
19218 wxFileType *result = 0 ;
19219 void *argp1 = 0 ;
19220 int res1 = 0 ;
19221 void *argp2 = 0 ;
19222 int res2 = 0 ;
19223 PyObject * obj0 = 0 ;
19224 PyObject * obj1 = 0 ;
19225 char * kwnames[] = {
19226 (char *) "self",(char *) "ftInfo", NULL
19227 };
19228
19229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19231 if (!SWIG_IsOK(res1)) {
19232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19233 }
19234 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19236 if (!SWIG_IsOK(res2)) {
19237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19238 }
19239 if (!argp2) {
19240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19241 }
19242 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19243 {
19244 PyThreadState* __tstate = wxPyBeginAllowThreads();
19245 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19250 return resultobj;
19251 fail:
19252 return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19257 PyObject *resultobj = 0;
19258 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19259 wxFileType *arg2 = (wxFileType *) 0 ;
19260 bool result;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 void *argp2 = 0 ;
19264 int res2 = 0 ;
19265 PyObject * obj0 = 0 ;
19266 PyObject * obj1 = 0 ;
19267 char * kwnames[] = {
19268 (char *) "self",(char *) "ft", NULL
19269 };
19270
19271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19273 if (!SWIG_IsOK(res1)) {
19274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19275 }
19276 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19278 if (!SWIG_IsOK(res2)) {
19279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19280 }
19281 arg2 = reinterpret_cast< wxFileType * >(argp2);
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 result = (bool)(arg1)->Unassociate(arg2);
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 {
19289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19290 }
19291 return resultobj;
19292 fail:
19293 return NULL;
19294 }
19295
19296
19297 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19298 PyObject *resultobj = 0;
19299 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19300 void *argp1 = 0 ;
19301 int res1 = 0 ;
19302 PyObject *swig_obj[1] ;
19303
19304 if (!args) SWIG_fail;
19305 swig_obj[0] = args;
19306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19307 if (!SWIG_IsOK(res1)) {
19308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19309 }
19310 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 delete arg1;
19314
19315 wxPyEndAllowThreads(__tstate);
19316 if (PyErr_Occurred()) SWIG_fail;
19317 }
19318 resultobj = SWIG_Py_Void();
19319 return resultobj;
19320 fail:
19321 return NULL;
19322 }
19323
19324
19325 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19326 PyObject *obj;
19327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19328 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19329 return SWIG_Py_Void();
19330 }
19331
19332 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 return SWIG_Python_InitShadowInstance(args);
19334 }
19335
19336 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19337 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19338 return 1;
19339 }
19340
19341
19342 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19343 PyObject *pyobj = 0;
19344
19345 {
19346 #if wxUSE_UNICODE
19347 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19348 #else
19349 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19350 #endif
19351 }
19352 return pyobj;
19353 }
19354
19355
19356 SWIGINTERN int ART_MENU_set(PyObject *) {
19357 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19358 return 1;
19359 }
19360
19361
19362 SWIGINTERN PyObject *ART_MENU_get(void) {
19363 PyObject *pyobj = 0;
19364
19365 {
19366 #if wxUSE_UNICODE
19367 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19368 #else
19369 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19370 #endif
19371 }
19372 return pyobj;
19373 }
19374
19375
19376 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19377 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19378 return 1;
19379 }
19380
19381
19382 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19383 PyObject *pyobj = 0;
19384
19385 {
19386 #if wxUSE_UNICODE
19387 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19388 #else
19389 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19390 #endif
19391 }
19392 return pyobj;
19393 }
19394
19395
19396 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19397 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19398 return 1;
19399 }
19400
19401
19402 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19403 PyObject *pyobj = 0;
19404
19405 {
19406 #if wxUSE_UNICODE
19407 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19408 #else
19409 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19410 #endif
19411 }
19412 return pyobj;
19413 }
19414
19415
19416 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19417 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19418 return 1;
19419 }
19420
19421
19422 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19423 PyObject *pyobj = 0;
19424
19425 {
19426 #if wxUSE_UNICODE
19427 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19428 #else
19429 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19430 #endif
19431 }
19432 return pyobj;
19433 }
19434
19435
19436 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19437 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19438 return 1;
19439 }
19440
19441
19442 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19443 PyObject *pyobj = 0;
19444
19445 {
19446 #if wxUSE_UNICODE
19447 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19448 #else
19449 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19450 #endif
19451 }
19452 return pyobj;
19453 }
19454
19455
19456 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19457 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19458 return 1;
19459 }
19460
19461
19462 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19463 PyObject *pyobj = 0;
19464
19465 {
19466 #if wxUSE_UNICODE
19467 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19468 #else
19469 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19470 #endif
19471 }
19472 return pyobj;
19473 }
19474
19475
19476 SWIGINTERN int ART_OTHER_set(PyObject *) {
19477 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19478 return 1;
19479 }
19480
19481
19482 SWIGINTERN PyObject *ART_OTHER_get(void) {
19483 PyObject *pyobj = 0;
19484
19485 {
19486 #if wxUSE_UNICODE
19487 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19488 #else
19489 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19490 #endif
19491 }
19492 return pyobj;
19493 }
19494
19495
19496 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19497 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19498 return 1;
19499 }
19500
19501
19502 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19503 PyObject *pyobj = 0;
19504
19505 {
19506 #if wxUSE_UNICODE
19507 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19508 #else
19509 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19510 #endif
19511 }
19512 return pyobj;
19513 }
19514
19515
19516 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19517 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19518 return 1;
19519 }
19520
19521
19522 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19523 PyObject *pyobj = 0;
19524
19525 {
19526 #if wxUSE_UNICODE
19527 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19528 #else
19529 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19530 #endif
19531 }
19532 return pyobj;
19533 }
19534
19535
19536 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19537 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19538 return 1;
19539 }
19540
19541
19542 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19543 PyObject *pyobj = 0;
19544
19545 {
19546 #if wxUSE_UNICODE
19547 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19548 #else
19549 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19550 #endif
19551 }
19552 return pyobj;
19553 }
19554
19555
19556 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19557 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19558 return 1;
19559 }
19560
19561
19562 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19563 PyObject *pyobj = 0;
19564
19565 {
19566 #if wxUSE_UNICODE
19567 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19568 #else
19569 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19570 #endif
19571 }
19572 return pyobj;
19573 }
19574
19575
19576 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19577 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19578 return 1;
19579 }
19580
19581
19582 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19583 PyObject *pyobj = 0;
19584
19585 {
19586 #if wxUSE_UNICODE
19587 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19588 #else
19589 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19590 #endif
19591 }
19592 return pyobj;
19593 }
19594
19595
19596 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19597 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19598 return 1;
19599 }
19600
19601
19602 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19603 PyObject *pyobj = 0;
19604
19605 {
19606 #if wxUSE_UNICODE
19607 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19608 #else
19609 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19610 #endif
19611 }
19612 return pyobj;
19613 }
19614
19615
19616 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19617 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19618 return 1;
19619 }
19620
19621
19622 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19623 PyObject *pyobj = 0;
19624
19625 {
19626 #if wxUSE_UNICODE
19627 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19628 #else
19629 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19630 #endif
19631 }
19632 return pyobj;
19633 }
19634
19635
19636 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19637 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19638 return 1;
19639 }
19640
19641
19642 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19643 PyObject *pyobj = 0;
19644
19645 {
19646 #if wxUSE_UNICODE
19647 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19648 #else
19649 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19650 #endif
19651 }
19652 return pyobj;
19653 }
19654
19655
19656 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19657 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19658 return 1;
19659 }
19660
19661
19662 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19663 PyObject *pyobj = 0;
19664
19665 {
19666 #if wxUSE_UNICODE
19667 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19668 #else
19669 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19670 #endif
19671 }
19672 return pyobj;
19673 }
19674
19675
19676 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19677 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19678 return 1;
19679 }
19680
19681
19682 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19683 PyObject *pyobj = 0;
19684
19685 {
19686 #if wxUSE_UNICODE
19687 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19688 #else
19689 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19690 #endif
19691 }
19692 return pyobj;
19693 }
19694
19695
19696 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19697 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19698 return 1;
19699 }
19700
19701
19702 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19703 PyObject *pyobj = 0;
19704
19705 {
19706 #if wxUSE_UNICODE
19707 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19708 #else
19709 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19710 #endif
19711 }
19712 return pyobj;
19713 }
19714
19715
19716 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19717 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19718 return 1;
19719 }
19720
19721
19722 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19723 PyObject *pyobj = 0;
19724
19725 {
19726 #if wxUSE_UNICODE
19727 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19728 #else
19729 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19730 #endif
19731 }
19732 return pyobj;
19733 }
19734
19735
19736 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19737 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19738 return 1;
19739 }
19740
19741
19742 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19743 PyObject *pyobj = 0;
19744
19745 {
19746 #if wxUSE_UNICODE
19747 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19748 #else
19749 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19750 #endif
19751 }
19752 return pyobj;
19753 }
19754
19755
19756 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19757 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19758 return 1;
19759 }
19760
19761
19762 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19763 PyObject *pyobj = 0;
19764
19765 {
19766 #if wxUSE_UNICODE
19767 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19768 #else
19769 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19770 #endif
19771 }
19772 return pyobj;
19773 }
19774
19775
19776 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19777 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19778 return 1;
19779 }
19780
19781
19782 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19783 PyObject *pyobj = 0;
19784
19785 {
19786 #if wxUSE_UNICODE
19787 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19788 #else
19789 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19790 #endif
19791 }
19792 return pyobj;
19793 }
19794
19795
19796 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19797 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19798 return 1;
19799 }
19800
19801
19802 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19803 PyObject *pyobj = 0;
19804
19805 {
19806 #if wxUSE_UNICODE
19807 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19808 #else
19809 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19810 #endif
19811 }
19812 return pyobj;
19813 }
19814
19815
19816 SWIGINTERN int ART_PRINT_set(PyObject *) {
19817 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19818 return 1;
19819 }
19820
19821
19822 SWIGINTERN PyObject *ART_PRINT_get(void) {
19823 PyObject *pyobj = 0;
19824
19825 {
19826 #if wxUSE_UNICODE
19827 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19828 #else
19829 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19830 #endif
19831 }
19832 return pyobj;
19833 }
19834
19835
19836 SWIGINTERN int ART_HELP_set(PyObject *) {
19837 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19838 return 1;
19839 }
19840
19841
19842 SWIGINTERN PyObject *ART_HELP_get(void) {
19843 PyObject *pyobj = 0;
19844
19845 {
19846 #if wxUSE_UNICODE
19847 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19848 #else
19849 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19850 #endif
19851 }
19852 return pyobj;
19853 }
19854
19855
19856 SWIGINTERN int ART_TIP_set(PyObject *) {
19857 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19858 return 1;
19859 }
19860
19861
19862 SWIGINTERN PyObject *ART_TIP_get(void) {
19863 PyObject *pyobj = 0;
19864
19865 {
19866 #if wxUSE_UNICODE
19867 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19868 #else
19869 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19870 #endif
19871 }
19872 return pyobj;
19873 }
19874
19875
19876 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19877 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19878 return 1;
19879 }
19880
19881
19882 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19883 PyObject *pyobj = 0;
19884
19885 {
19886 #if wxUSE_UNICODE
19887 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19888 #else
19889 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19890 #endif
19891 }
19892 return pyobj;
19893 }
19894
19895
19896 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19897 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19898 return 1;
19899 }
19900
19901
19902 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19903 PyObject *pyobj = 0;
19904
19905 {
19906 #if wxUSE_UNICODE
19907 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19908 #else
19909 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19910 #endif
19911 }
19912 return pyobj;
19913 }
19914
19915
19916 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19917 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19918 return 1;
19919 }
19920
19921
19922 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19923 PyObject *pyobj = 0;
19924
19925 {
19926 #if wxUSE_UNICODE
19927 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19928 #else
19929 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19930 #endif
19931 }
19932 return pyobj;
19933 }
19934
19935
19936 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19937 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19938 return 1;
19939 }
19940
19941
19942 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19943 PyObject *pyobj = 0;
19944
19945 {
19946 #if wxUSE_UNICODE
19947 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19948 #else
19949 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19950 #endif
19951 }
19952 return pyobj;
19953 }
19954
19955
19956 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19957 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19958 return 1;
19959 }
19960
19961
19962 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19963 PyObject *pyobj = 0;
19964
19965 {
19966 #if wxUSE_UNICODE
19967 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19968 #else
19969 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19970 #endif
19971 }
19972 return pyobj;
19973 }
19974
19975
19976 SWIGINTERN int ART_CDROM_set(PyObject *) {
19977 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19978 return 1;
19979 }
19980
19981
19982 SWIGINTERN PyObject *ART_CDROM_get(void) {
19983 PyObject *pyobj = 0;
19984
19985 {
19986 #if wxUSE_UNICODE
19987 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19988 #else
19989 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19990 #endif
19991 }
19992 return pyobj;
19993 }
19994
19995
19996 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19997 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19998 return 1;
19999 }
20000
20001
20002 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20003 PyObject *pyobj = 0;
20004
20005 {
20006 #if wxUSE_UNICODE
20007 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20008 #else
20009 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20010 #endif
20011 }
20012 return pyobj;
20013 }
20014
20015
20016 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20017 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20018 return 1;
20019 }
20020
20021
20022 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20023 PyObject *pyobj = 0;
20024
20025 {
20026 #if wxUSE_UNICODE
20027 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20028 #else
20029 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20030 #endif
20031 }
20032 return pyobj;
20033 }
20034
20035
20036 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20037 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20038 return 1;
20039 }
20040
20041
20042 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20043 PyObject *pyobj = 0;
20044
20045 {
20046 #if wxUSE_UNICODE
20047 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20048 #else
20049 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20050 #endif
20051 }
20052 return pyobj;
20053 }
20054
20055
20056 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20057 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20058 return 1;
20059 }
20060
20061
20062 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20063 PyObject *pyobj = 0;
20064
20065 {
20066 #if wxUSE_UNICODE
20067 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20068 #else
20069 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20070 #endif
20071 }
20072 return pyobj;
20073 }
20074
20075
20076 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20077 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20078 return 1;
20079 }
20080
20081
20082 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20083 PyObject *pyobj = 0;
20084
20085 {
20086 #if wxUSE_UNICODE
20087 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20088 #else
20089 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20090 #endif
20091 }
20092 return pyobj;
20093 }
20094
20095
20096 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20097 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20098 return 1;
20099 }
20100
20101
20102 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20103 PyObject *pyobj = 0;
20104
20105 {
20106 #if wxUSE_UNICODE
20107 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20108 #else
20109 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20110 #endif
20111 }
20112 return pyobj;
20113 }
20114
20115
20116 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20117 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20118 return 1;
20119 }
20120
20121
20122 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20123 PyObject *pyobj = 0;
20124
20125 {
20126 #if wxUSE_UNICODE
20127 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20128 #else
20129 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20130 #endif
20131 }
20132 return pyobj;
20133 }
20134
20135
20136 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20137 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20138 return 1;
20139 }
20140
20141
20142 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20143 PyObject *pyobj = 0;
20144
20145 {
20146 #if wxUSE_UNICODE
20147 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20148 #else
20149 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20150 #endif
20151 }
20152 return pyobj;
20153 }
20154
20155
20156 SWIGINTERN int ART_ERROR_set(PyObject *) {
20157 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20158 return 1;
20159 }
20160
20161
20162 SWIGINTERN PyObject *ART_ERROR_get(void) {
20163 PyObject *pyobj = 0;
20164
20165 {
20166 #if wxUSE_UNICODE
20167 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20168 #else
20169 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20170 #endif
20171 }
20172 return pyobj;
20173 }
20174
20175
20176 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20177 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20178 return 1;
20179 }
20180
20181
20182 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20183 PyObject *pyobj = 0;
20184
20185 {
20186 #if wxUSE_UNICODE
20187 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20188 #else
20189 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20190 #endif
20191 }
20192 return pyobj;
20193 }
20194
20195
20196 SWIGINTERN int ART_WARNING_set(PyObject *) {
20197 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20198 return 1;
20199 }
20200
20201
20202 SWIGINTERN PyObject *ART_WARNING_get(void) {
20203 PyObject *pyobj = 0;
20204
20205 {
20206 #if wxUSE_UNICODE
20207 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20208 #else
20209 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20210 #endif
20211 }
20212 return pyobj;
20213 }
20214
20215
20216 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20217 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20218 return 1;
20219 }
20220
20221
20222 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20223 PyObject *pyobj = 0;
20224
20225 {
20226 #if wxUSE_UNICODE
20227 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20228 #else
20229 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20230 #endif
20231 }
20232 return pyobj;
20233 }
20234
20235
20236 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20237 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20238 return 1;
20239 }
20240
20241
20242 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20243 PyObject *pyobj = 0;
20244
20245 {
20246 #if wxUSE_UNICODE
20247 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20248 #else
20249 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20250 #endif
20251 }
20252 return pyobj;
20253 }
20254
20255
20256 SWIGINTERN int ART_COPY_set(PyObject *) {
20257 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20258 return 1;
20259 }
20260
20261
20262 SWIGINTERN PyObject *ART_COPY_get(void) {
20263 PyObject *pyobj = 0;
20264
20265 {
20266 #if wxUSE_UNICODE
20267 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20268 #else
20269 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20270 #endif
20271 }
20272 return pyobj;
20273 }
20274
20275
20276 SWIGINTERN int ART_CUT_set(PyObject *) {
20277 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20278 return 1;
20279 }
20280
20281
20282 SWIGINTERN PyObject *ART_CUT_get(void) {
20283 PyObject *pyobj = 0;
20284
20285 {
20286 #if wxUSE_UNICODE
20287 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20288 #else
20289 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20290 #endif
20291 }
20292 return pyobj;
20293 }
20294
20295
20296 SWIGINTERN int ART_PASTE_set(PyObject *) {
20297 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20298 return 1;
20299 }
20300
20301
20302 SWIGINTERN PyObject *ART_PASTE_get(void) {
20303 PyObject *pyobj = 0;
20304
20305 {
20306 #if wxUSE_UNICODE
20307 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20308 #else
20309 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20310 #endif
20311 }
20312 return pyobj;
20313 }
20314
20315
20316 SWIGINTERN int ART_DELETE_set(PyObject *) {
20317 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20318 return 1;
20319 }
20320
20321
20322 SWIGINTERN PyObject *ART_DELETE_get(void) {
20323 PyObject *pyobj = 0;
20324
20325 {
20326 #if wxUSE_UNICODE
20327 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20328 #else
20329 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20330 #endif
20331 }
20332 return pyobj;
20333 }
20334
20335
20336 SWIGINTERN int ART_NEW_set(PyObject *) {
20337 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20338 return 1;
20339 }
20340
20341
20342 SWIGINTERN PyObject *ART_NEW_get(void) {
20343 PyObject *pyobj = 0;
20344
20345 {
20346 #if wxUSE_UNICODE
20347 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20348 #else
20349 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20350 #endif
20351 }
20352 return pyobj;
20353 }
20354
20355
20356 SWIGINTERN int ART_UNDO_set(PyObject *) {
20357 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20358 return 1;
20359 }
20360
20361
20362 SWIGINTERN PyObject *ART_UNDO_get(void) {
20363 PyObject *pyobj = 0;
20364
20365 {
20366 #if wxUSE_UNICODE
20367 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20368 #else
20369 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20370 #endif
20371 }
20372 return pyobj;
20373 }
20374
20375
20376 SWIGINTERN int ART_REDO_set(PyObject *) {
20377 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20378 return 1;
20379 }
20380
20381
20382 SWIGINTERN PyObject *ART_REDO_get(void) {
20383 PyObject *pyobj = 0;
20384
20385 {
20386 #if wxUSE_UNICODE
20387 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20388 #else
20389 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20390 #endif
20391 }
20392 return pyobj;
20393 }
20394
20395
20396 SWIGINTERN int ART_QUIT_set(PyObject *) {
20397 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20398 return 1;
20399 }
20400
20401
20402 SWIGINTERN PyObject *ART_QUIT_get(void) {
20403 PyObject *pyobj = 0;
20404
20405 {
20406 #if wxUSE_UNICODE
20407 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20408 #else
20409 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20410 #endif
20411 }
20412 return pyobj;
20413 }
20414
20415
20416 SWIGINTERN int ART_FIND_set(PyObject *) {
20417 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20418 return 1;
20419 }
20420
20421
20422 SWIGINTERN PyObject *ART_FIND_get(void) {
20423 PyObject *pyobj = 0;
20424
20425 {
20426 #if wxUSE_UNICODE
20427 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20428 #else
20429 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20430 #endif
20431 }
20432 return pyobj;
20433 }
20434
20435
20436 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20437 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20438 return 1;
20439 }
20440
20441
20442 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20443 PyObject *pyobj = 0;
20444
20445 {
20446 #if wxUSE_UNICODE
20447 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20448 #else
20449 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20450 #endif
20451 }
20452 return pyobj;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 PyObject *resultobj = 0;
20458 wxPyArtProvider *result = 0 ;
20459
20460 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20461 {
20462 if (!wxPyCheckForApp()) SWIG_fail;
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 result = (wxPyArtProvider *)new wxPyArtProvider();
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20476 PyObject *resultobj = 0;
20477 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20478 void *argp1 = 0 ;
20479 int res1 = 0 ;
20480 PyObject *swig_obj[1] ;
20481
20482 if (!args) SWIG_fail;
20483 swig_obj[0] = args;
20484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20485 if (!SWIG_IsOK(res1)) {
20486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20487 }
20488 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20489 {
20490 PyThreadState* __tstate = wxPyBeginAllowThreads();
20491 delete arg1;
20492
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 resultobj = SWIG_Py_Void();
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20504 PyObject *resultobj = 0;
20505 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20506 PyObject *arg2 = (PyObject *) 0 ;
20507 PyObject *arg3 = (PyObject *) 0 ;
20508 void *argp1 = 0 ;
20509 int res1 = 0 ;
20510 PyObject * obj0 = 0 ;
20511 PyObject * obj1 = 0 ;
20512 PyObject * obj2 = 0 ;
20513 char * kwnames[] = {
20514 (char *) "self",(char *) "self",(char *) "_class", NULL
20515 };
20516
20517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20519 if (!SWIG_IsOK(res1)) {
20520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20521 }
20522 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20523 arg2 = obj1;
20524 arg3 = obj2;
20525 {
20526 PyThreadState* __tstate = wxPyBeginAllowThreads();
20527 (arg1)->_setCallbackInfo(arg2,arg3);
20528 wxPyEndAllowThreads(__tstate);
20529 if (PyErr_Occurred()) SWIG_fail;
20530 }
20531 resultobj = SWIG_Py_Void();
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20539 PyObject *resultobj = 0;
20540 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20541 int res1 = 0 ;
20542 PyObject * obj0 = 0 ;
20543 char * kwnames[] = {
20544 (char *) "provider", NULL
20545 };
20546
20547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20548 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20549 if (!SWIG_IsOK(res1)) {
20550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20551 }
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 wxPyArtProvider::Push(arg1);
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 resultobj = SWIG_Py_Void();
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj = 0;
20567 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20568 int res1 = 0 ;
20569 PyObject * obj0 = 0 ;
20570 char * kwnames[] = {
20571 (char *) "provider", NULL
20572 };
20573
20574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20575 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20576 if (!SWIG_IsOK(res1)) {
20577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20578 }
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 wxPyArtProvider::Insert(arg1);
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 resultobj = SWIG_Py_Void();
20586 return resultobj;
20587 fail:
20588 return NULL;
20589 }
20590
20591
20592 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20593 PyObject *resultobj = 0;
20594 bool result;
20595
20596 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (bool)wxPyArtProvider::Pop();
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 {
20604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20605 }
20606 return resultobj;
20607 fail:
20608 return NULL;
20609 }
20610
20611
20612 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20613 PyObject *resultobj = 0;
20614 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20615 bool result;
20616 void *argp1 = 0 ;
20617 int res1 = 0 ;
20618 PyObject * obj0 = 0 ;
20619 char * kwnames[] = {
20620 (char *) "provider", NULL
20621 };
20622
20623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20625 if (!SWIG_IsOK(res1)) {
20626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20627 }
20628 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (bool)wxPyArtProvider::Delete(arg1);
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20645 PyObject *resultobj = 0;
20646 wxString *arg1 = 0 ;
20647 wxString const &arg2_defvalue = wxPyART_OTHER ;
20648 wxString *arg2 = (wxString *) &arg2_defvalue ;
20649 wxSize const &arg3_defvalue = wxDefaultSize ;
20650 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20651 wxBitmap result;
20652 bool temp1 = false ;
20653 bool temp2 = false ;
20654 wxSize temp3 ;
20655 PyObject * obj0 = 0 ;
20656 PyObject * obj1 = 0 ;
20657 PyObject * obj2 = 0 ;
20658 char * kwnames[] = {
20659 (char *) "id",(char *) "client",(char *) "size", NULL
20660 };
20661
20662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20663 {
20664 arg1 = wxString_in_helper(obj0);
20665 if (arg1 == NULL) SWIG_fail;
20666 temp1 = true;
20667 }
20668 if (obj1) {
20669 {
20670 arg2 = wxString_in_helper(obj1);
20671 if (arg2 == NULL) SWIG_fail;
20672 temp2 = true;
20673 }
20674 }
20675 if (obj2) {
20676 {
20677 arg3 = &temp3;
20678 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20679 }
20680 }
20681 {
20682 if (!wxPyCheckForApp()) SWIG_fail;
20683 PyThreadState* __tstate = wxPyBeginAllowThreads();
20684 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20689 {
20690 if (temp1)
20691 delete arg1;
20692 }
20693 {
20694 if (temp2)
20695 delete arg2;
20696 }
20697 return resultobj;
20698 fail:
20699 {
20700 if (temp1)
20701 delete arg1;
20702 }
20703 {
20704 if (temp2)
20705 delete arg2;
20706 }
20707 return NULL;
20708 }
20709
20710
20711 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20712 PyObject *resultobj = 0;
20713 wxString *arg1 = 0 ;
20714 wxString const &arg2_defvalue = wxPyART_OTHER ;
20715 wxString *arg2 = (wxString *) &arg2_defvalue ;
20716 wxSize const &arg3_defvalue = wxDefaultSize ;
20717 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20718 wxIcon result;
20719 bool temp1 = false ;
20720 bool temp2 = false ;
20721 wxSize temp3 ;
20722 PyObject * obj0 = 0 ;
20723 PyObject * obj1 = 0 ;
20724 PyObject * obj2 = 0 ;
20725 char * kwnames[] = {
20726 (char *) "id",(char *) "client",(char *) "size", NULL
20727 };
20728
20729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20730 {
20731 arg1 = wxString_in_helper(obj0);
20732 if (arg1 == NULL) SWIG_fail;
20733 temp1 = true;
20734 }
20735 if (obj1) {
20736 {
20737 arg2 = wxString_in_helper(obj1);
20738 if (arg2 == NULL) SWIG_fail;
20739 temp2 = true;
20740 }
20741 }
20742 if (obj2) {
20743 {
20744 arg3 = &temp3;
20745 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20746 }
20747 }
20748 {
20749 if (!wxPyCheckForApp()) SWIG_fail;
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20752 wxPyEndAllowThreads(__tstate);
20753 if (PyErr_Occurred()) SWIG_fail;
20754 }
20755 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20756 {
20757 if (temp1)
20758 delete arg1;
20759 }
20760 {
20761 if (temp2)
20762 delete arg2;
20763 }
20764 return resultobj;
20765 fail:
20766 {
20767 if (temp1)
20768 delete arg1;
20769 }
20770 {
20771 if (temp2)
20772 delete arg2;
20773 }
20774 return NULL;
20775 }
20776
20777
20778 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20779 PyObject *resultobj = 0;
20780 wxString *arg1 = 0 ;
20781 bool arg2 = (bool) false ;
20782 wxSize result;
20783 bool temp1 = false ;
20784 bool val2 ;
20785 int ecode2 = 0 ;
20786 PyObject * obj0 = 0 ;
20787 PyObject * obj1 = 0 ;
20788 char * kwnames[] = {
20789 (char *) "client",(char *) "platform_dependent", NULL
20790 };
20791
20792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20793 {
20794 arg1 = wxString_in_helper(obj0);
20795 if (arg1 == NULL) SWIG_fail;
20796 temp1 = true;
20797 }
20798 if (obj1) {
20799 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20800 if (!SWIG_IsOK(ecode2)) {
20801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20802 }
20803 arg2 = static_cast< bool >(val2);
20804 }
20805 {
20806 PyThreadState* __tstate = wxPyBeginAllowThreads();
20807 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20808 wxPyEndAllowThreads(__tstate);
20809 if (PyErr_Occurred()) SWIG_fail;
20810 }
20811 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20812 {
20813 if (temp1)
20814 delete arg1;
20815 }
20816 return resultobj;
20817 fail:
20818 {
20819 if (temp1)
20820 delete arg1;
20821 }
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 PyObject *resultobj = 0;
20828 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20829 void *argp1 = 0 ;
20830 int res1 = 0 ;
20831 PyObject *swig_obj[1] ;
20832
20833 if (!args) SWIG_fail;
20834 swig_obj[0] = args;
20835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20836 if (!SWIG_IsOK(res1)) {
20837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20838 }
20839 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20840 {
20841 PyThreadState* __tstate = wxPyBeginAllowThreads();
20842 wxPyArtProvider_Destroy(arg1);
20843 wxPyEndAllowThreads(__tstate);
20844 if (PyErr_Occurred()) SWIG_fail;
20845 }
20846 resultobj = SWIG_Py_Void();
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20854 PyObject *obj;
20855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20856 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20857 return SWIG_Py_Void();
20858 }
20859
20860 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20861 return SWIG_Python_InitShadowInstance(args);
20862 }
20863
20864 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20865 PyObject *resultobj = 0;
20866 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20867 void *argp1 = 0 ;
20868 int res1 = 0 ;
20869 PyObject *swig_obj[1] ;
20870
20871 if (!args) SWIG_fail;
20872 swig_obj[0] = args;
20873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20874 if (!SWIG_IsOK(res1)) {
20875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20876 }
20877 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20878 {
20879 PyThreadState* __tstate = wxPyBeginAllowThreads();
20880 delete arg1;
20881
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 resultobj = SWIG_Py_Void();
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20893 PyObject *resultobj = 0;
20894 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20895 wxConfigBase *result = 0 ;
20896 int res1 = 0 ;
20897 PyObject * obj0 = 0 ;
20898 char * kwnames[] = {
20899 (char *) "config", NULL
20900 };
20901
20902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20903 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20904 if (!SWIG_IsOK(res1)) {
20905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20906 }
20907 {
20908 PyThreadState* __tstate = wxPyBeginAllowThreads();
20909 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20921 PyObject *resultobj = 0;
20922 bool arg1 = (bool) true ;
20923 wxConfigBase *result = 0 ;
20924 bool val1 ;
20925 int ecode1 = 0 ;
20926 PyObject * obj0 = 0 ;
20927 char * kwnames[] = {
20928 (char *) "createOnDemand", NULL
20929 };
20930
20931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20932 if (obj0) {
20933 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20934 if (!SWIG_IsOK(ecode1)) {
20935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20936 }
20937 arg1 = static_cast< bool >(val1);
20938 }
20939 {
20940 PyThreadState* __tstate = wxPyBeginAllowThreads();
20941 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20953 PyObject *resultobj = 0;
20954 wxConfigBase *result = 0 ;
20955
20956 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 result = (wxConfigBase *)wxConfigBase::Create();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20971 PyObject *resultobj = 0;
20972
20973 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20974 {
20975 PyThreadState* __tstate = wxPyBeginAllowThreads();
20976 wxConfigBase::DontCreateOnDemand();
20977 wxPyEndAllowThreads(__tstate);
20978 if (PyErr_Occurred()) SWIG_fail;
20979 }
20980 resultobj = SWIG_Py_Void();
20981 return resultobj;
20982 fail:
20983 return NULL;
20984 }
20985
20986
20987 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20988 PyObject *resultobj = 0;
20989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20990 wxString *arg2 = 0 ;
20991 void *argp1 = 0 ;
20992 int res1 = 0 ;
20993 bool temp2 = false ;
20994 PyObject * obj0 = 0 ;
20995 PyObject * obj1 = 0 ;
20996 char * kwnames[] = {
20997 (char *) "self",(char *) "path", NULL
20998 };
20999
21000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21002 if (!SWIG_IsOK(res1)) {
21003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21004 }
21005 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21006 {
21007 arg2 = wxString_in_helper(obj1);
21008 if (arg2 == NULL) SWIG_fail;
21009 temp2 = true;
21010 }
21011 {
21012 PyThreadState* __tstate = wxPyBeginAllowThreads();
21013 (arg1)->SetPath((wxString const &)*arg2);
21014 wxPyEndAllowThreads(__tstate);
21015 if (PyErr_Occurred()) SWIG_fail;
21016 }
21017 resultobj = SWIG_Py_Void();
21018 {
21019 if (temp2)
21020 delete arg2;
21021 }
21022 return resultobj;
21023 fail:
21024 {
21025 if (temp2)
21026 delete arg2;
21027 }
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21033 PyObject *resultobj = 0;
21034 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21035 wxString *result = 0 ;
21036 void *argp1 = 0 ;
21037 int res1 = 0 ;
21038 PyObject *swig_obj[1] ;
21039
21040 if (!args) SWIG_fail;
21041 swig_obj[0] = args;
21042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21043 if (!SWIG_IsOK(res1)) {
21044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21045 }
21046 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21047 {
21048 PyThreadState* __tstate = wxPyBeginAllowThreads();
21049 {
21050 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21051 result = (wxString *) &_result_ref;
21052 }
21053 wxPyEndAllowThreads(__tstate);
21054 if (PyErr_Occurred()) SWIG_fail;
21055 }
21056 {
21057 #if wxUSE_UNICODE
21058 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21059 #else
21060 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21061 #endif
21062 }
21063 return resultobj;
21064 fail:
21065 return NULL;
21066 }
21067
21068
21069 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21070 PyObject *resultobj = 0;
21071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21072 PyObject *result = 0 ;
21073 void *argp1 = 0 ;
21074 int res1 = 0 ;
21075 PyObject *swig_obj[1] ;
21076
21077 if (!args) SWIG_fail;
21078 swig_obj[0] = args;
21079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21080 if (!SWIG_IsOK(res1)) {
21081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21082 }
21083 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21087 wxPyEndAllowThreads(__tstate);
21088 if (PyErr_Occurred()) SWIG_fail;
21089 }
21090 resultobj = result;
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21098 PyObject *resultobj = 0;
21099 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21100 long arg2 ;
21101 PyObject *result = 0 ;
21102 void *argp1 = 0 ;
21103 int res1 = 0 ;
21104 long val2 ;
21105 int ecode2 = 0 ;
21106 PyObject * obj0 = 0 ;
21107 PyObject * obj1 = 0 ;
21108 char * kwnames[] = {
21109 (char *) "self",(char *) "index", NULL
21110 };
21111
21112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21116 }
21117 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21118 ecode2 = SWIG_AsVal_long(obj1, &val2);
21119 if (!SWIG_IsOK(ecode2)) {
21120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21121 }
21122 arg2 = static_cast< long >(val2);
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 resultobj = result;
21130 return resultobj;
21131 fail:
21132 return NULL;
21133 }
21134
21135
21136 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21137 PyObject *resultobj = 0;
21138 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21139 PyObject *result = 0 ;
21140 void *argp1 = 0 ;
21141 int res1 = 0 ;
21142 PyObject *swig_obj[1] ;
21143
21144 if (!args) SWIG_fail;
21145 swig_obj[0] = args;
21146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21147 if (!SWIG_IsOK(res1)) {
21148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21149 }
21150 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 resultobj = result;
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj = 0;
21166 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21167 long arg2 ;
21168 PyObject *result = 0 ;
21169 void *argp1 = 0 ;
21170 int res1 = 0 ;
21171 long val2 ;
21172 int ecode2 = 0 ;
21173 PyObject * obj0 = 0 ;
21174 PyObject * obj1 = 0 ;
21175 char * kwnames[] = {
21176 (char *) "self",(char *) "index", NULL
21177 };
21178
21179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21181 if (!SWIG_IsOK(res1)) {
21182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21183 }
21184 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21185 ecode2 = SWIG_AsVal_long(obj1, &val2);
21186 if (!SWIG_IsOK(ecode2)) {
21187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21188 }
21189 arg2 = static_cast< long >(val2);
21190 {
21191 PyThreadState* __tstate = wxPyBeginAllowThreads();
21192 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 resultobj = result;
21197 return resultobj;
21198 fail:
21199 return NULL;
21200 }
21201
21202
21203 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21204 PyObject *resultobj = 0;
21205 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21206 bool arg2 = (bool) false ;
21207 size_t result;
21208 void *argp1 = 0 ;
21209 int res1 = 0 ;
21210 bool val2 ;
21211 int ecode2 = 0 ;
21212 PyObject * obj0 = 0 ;
21213 PyObject * obj1 = 0 ;
21214 char * kwnames[] = {
21215 (char *) "self",(char *) "recursive", NULL
21216 };
21217
21218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21222 }
21223 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21224 if (obj1) {
21225 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21226 if (!SWIG_IsOK(ecode2)) {
21227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21228 }
21229 arg2 = static_cast< bool >(val2);
21230 }
21231 {
21232 PyThreadState* __tstate = wxPyBeginAllowThreads();
21233 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21234 wxPyEndAllowThreads(__tstate);
21235 if (PyErr_Occurred()) SWIG_fail;
21236 }
21237 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21238 return resultobj;
21239 fail:
21240 return NULL;
21241 }
21242
21243
21244 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21245 PyObject *resultobj = 0;
21246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21247 bool arg2 = (bool) false ;
21248 size_t result;
21249 void *argp1 = 0 ;
21250 int res1 = 0 ;
21251 bool val2 ;
21252 int ecode2 = 0 ;
21253 PyObject * obj0 = 0 ;
21254 PyObject * obj1 = 0 ;
21255 char * kwnames[] = {
21256 (char *) "self",(char *) "recursive", NULL
21257 };
21258
21259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21261 if (!SWIG_IsOK(res1)) {
21262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21263 }
21264 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21265 if (obj1) {
21266 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21267 if (!SWIG_IsOK(ecode2)) {
21268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21269 }
21270 arg2 = static_cast< bool >(val2);
21271 }
21272 {
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21279 return resultobj;
21280 fail:
21281 return NULL;
21282 }
21283
21284
21285 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21286 PyObject *resultobj = 0;
21287 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21288 wxString *arg2 = 0 ;
21289 bool result;
21290 void *argp1 = 0 ;
21291 int res1 = 0 ;
21292 bool temp2 = false ;
21293 PyObject * obj0 = 0 ;
21294 PyObject * obj1 = 0 ;
21295 char * kwnames[] = {
21296 (char *) "self",(char *) "name", NULL
21297 };
21298
21299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21303 }
21304 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21305 {
21306 arg2 = wxString_in_helper(obj1);
21307 if (arg2 == NULL) SWIG_fail;
21308 temp2 = true;
21309 }
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 {
21317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21318 }
21319 {
21320 if (temp2)
21321 delete arg2;
21322 }
21323 return resultobj;
21324 fail:
21325 {
21326 if (temp2)
21327 delete arg2;
21328 }
21329 return NULL;
21330 }
21331
21332
21333 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21334 PyObject *resultobj = 0;
21335 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21336 wxString *arg2 = 0 ;
21337 bool result;
21338 void *argp1 = 0 ;
21339 int res1 = 0 ;
21340 bool temp2 = false ;
21341 PyObject * obj0 = 0 ;
21342 PyObject * obj1 = 0 ;
21343 char * kwnames[] = {
21344 (char *) "self",(char *) "name", NULL
21345 };
21346
21347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21349 if (!SWIG_IsOK(res1)) {
21350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21351 }
21352 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21353 {
21354 arg2 = wxString_in_helper(obj1);
21355 if (arg2 == NULL) SWIG_fail;
21356 temp2 = true;
21357 }
21358 {
21359 PyThreadState* __tstate = wxPyBeginAllowThreads();
21360 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21361 wxPyEndAllowThreads(__tstate);
21362 if (PyErr_Occurred()) SWIG_fail;
21363 }
21364 {
21365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21366 }
21367 {
21368 if (temp2)
21369 delete arg2;
21370 }
21371 return resultobj;
21372 fail:
21373 {
21374 if (temp2)
21375 delete arg2;
21376 }
21377 return NULL;
21378 }
21379
21380
21381 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21382 PyObject *resultobj = 0;
21383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21384 wxString *arg2 = 0 ;
21385 bool result;
21386 void *argp1 = 0 ;
21387 int res1 = 0 ;
21388 bool temp2 = false ;
21389 PyObject * obj0 = 0 ;
21390 PyObject * obj1 = 0 ;
21391 char * kwnames[] = {
21392 (char *) "self",(char *) "name", NULL
21393 };
21394
21395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21397 if (!SWIG_IsOK(res1)) {
21398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21399 }
21400 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21401 {
21402 arg2 = wxString_in_helper(obj1);
21403 if (arg2 == NULL) SWIG_fail;
21404 temp2 = true;
21405 }
21406 {
21407 PyThreadState* __tstate = wxPyBeginAllowThreads();
21408 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21409 wxPyEndAllowThreads(__tstate);
21410 if (PyErr_Occurred()) SWIG_fail;
21411 }
21412 {
21413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21414 }
21415 {
21416 if (temp2)
21417 delete arg2;
21418 }
21419 return resultobj;
21420 fail:
21421 {
21422 if (temp2)
21423 delete arg2;
21424 }
21425 return NULL;
21426 }
21427
21428
21429 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21430 PyObject *resultobj = 0;
21431 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21432 wxString *arg2 = 0 ;
21433 wxConfigBase::EntryType result;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 bool temp2 = false ;
21437 PyObject * obj0 = 0 ;
21438 PyObject * obj1 = 0 ;
21439 char * kwnames[] = {
21440 (char *) "self",(char *) "name", NULL
21441 };
21442
21443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21445 if (!SWIG_IsOK(res1)) {
21446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21447 }
21448 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21449 {
21450 arg2 = wxString_in_helper(obj1);
21451 if (arg2 == NULL) SWIG_fail;
21452 temp2 = true;
21453 }
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 resultobj = SWIG_From_int(static_cast< int >(result));
21461 {
21462 if (temp2)
21463 delete arg2;
21464 }
21465 return resultobj;
21466 fail:
21467 {
21468 if (temp2)
21469 delete arg2;
21470 }
21471 return NULL;
21472 }
21473
21474
21475 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21476 PyObject *resultobj = 0;
21477 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21478 wxString *arg2 = 0 ;
21479 wxString const &arg3_defvalue = wxPyEmptyString ;
21480 wxString *arg3 = (wxString *) &arg3_defvalue ;
21481 wxString result;
21482 void *argp1 = 0 ;
21483 int res1 = 0 ;
21484 bool temp2 = false ;
21485 bool temp3 = false ;
21486 PyObject * obj0 = 0 ;
21487 PyObject * obj1 = 0 ;
21488 PyObject * obj2 = 0 ;
21489 char * kwnames[] = {
21490 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21491 };
21492
21493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21495 if (!SWIG_IsOK(res1)) {
21496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21497 }
21498 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21499 {
21500 arg2 = wxString_in_helper(obj1);
21501 if (arg2 == NULL) SWIG_fail;
21502 temp2 = true;
21503 }
21504 if (obj2) {
21505 {
21506 arg3 = wxString_in_helper(obj2);
21507 if (arg3 == NULL) SWIG_fail;
21508 temp3 = true;
21509 }
21510 }
21511 {
21512 PyThreadState* __tstate = wxPyBeginAllowThreads();
21513 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21514 wxPyEndAllowThreads(__tstate);
21515 if (PyErr_Occurred()) SWIG_fail;
21516 }
21517 {
21518 #if wxUSE_UNICODE
21519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21520 #else
21521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21522 #endif
21523 }
21524 {
21525 if (temp2)
21526 delete arg2;
21527 }
21528 {
21529 if (temp3)
21530 delete arg3;
21531 }
21532 return resultobj;
21533 fail:
21534 {
21535 if (temp2)
21536 delete arg2;
21537 }
21538 {
21539 if (temp3)
21540 delete arg3;
21541 }
21542 return NULL;
21543 }
21544
21545
21546 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21547 PyObject *resultobj = 0;
21548 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21549 wxString *arg2 = 0 ;
21550 long arg3 = (long) 0 ;
21551 long result;
21552 void *argp1 = 0 ;
21553 int res1 = 0 ;
21554 bool temp2 = false ;
21555 long val3 ;
21556 int ecode3 = 0 ;
21557 PyObject * obj0 = 0 ;
21558 PyObject * obj1 = 0 ;
21559 PyObject * obj2 = 0 ;
21560 char * kwnames[] = {
21561 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21562 };
21563
21564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21566 if (!SWIG_IsOK(res1)) {
21567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21568 }
21569 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21570 {
21571 arg2 = wxString_in_helper(obj1);
21572 if (arg2 == NULL) SWIG_fail;
21573 temp2 = true;
21574 }
21575 if (obj2) {
21576 ecode3 = SWIG_AsVal_long(obj2, &val3);
21577 if (!SWIG_IsOK(ecode3)) {
21578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21579 }
21580 arg3 = static_cast< long >(val3);
21581 }
21582 {
21583 PyThreadState* __tstate = wxPyBeginAllowThreads();
21584 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21585 wxPyEndAllowThreads(__tstate);
21586 if (PyErr_Occurred()) SWIG_fail;
21587 }
21588 resultobj = SWIG_From_long(static_cast< long >(result));
21589 {
21590 if (temp2)
21591 delete arg2;
21592 }
21593 return resultobj;
21594 fail:
21595 {
21596 if (temp2)
21597 delete arg2;
21598 }
21599 return NULL;
21600 }
21601
21602
21603 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21604 PyObject *resultobj = 0;
21605 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21606 wxString *arg2 = 0 ;
21607 double arg3 = (double) 0.0 ;
21608 double result;
21609 void *argp1 = 0 ;
21610 int res1 = 0 ;
21611 bool temp2 = false ;
21612 double val3 ;
21613 int ecode3 = 0 ;
21614 PyObject * obj0 = 0 ;
21615 PyObject * obj1 = 0 ;
21616 PyObject * obj2 = 0 ;
21617 char * kwnames[] = {
21618 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21619 };
21620
21621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21625 }
21626 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21627 {
21628 arg2 = wxString_in_helper(obj1);
21629 if (arg2 == NULL) SWIG_fail;
21630 temp2 = true;
21631 }
21632 if (obj2) {
21633 ecode3 = SWIG_AsVal_double(obj2, &val3);
21634 if (!SWIG_IsOK(ecode3)) {
21635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21636 }
21637 arg3 = static_cast< double >(val3);
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21642 wxPyEndAllowThreads(__tstate);
21643 if (PyErr_Occurred()) SWIG_fail;
21644 }
21645 resultobj = SWIG_From_double(static_cast< double >(result));
21646 {
21647 if (temp2)
21648 delete arg2;
21649 }
21650 return resultobj;
21651 fail:
21652 {
21653 if (temp2)
21654 delete arg2;
21655 }
21656 return NULL;
21657 }
21658
21659
21660 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21661 PyObject *resultobj = 0;
21662 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21663 wxString *arg2 = 0 ;
21664 bool arg3 = (bool) false ;
21665 bool result;
21666 void *argp1 = 0 ;
21667 int res1 = 0 ;
21668 bool temp2 = false ;
21669 bool val3 ;
21670 int ecode3 = 0 ;
21671 PyObject * obj0 = 0 ;
21672 PyObject * obj1 = 0 ;
21673 PyObject * obj2 = 0 ;
21674 char * kwnames[] = {
21675 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21676 };
21677
21678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21680 if (!SWIG_IsOK(res1)) {
21681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21682 }
21683 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21684 {
21685 arg2 = wxString_in_helper(obj1);
21686 if (arg2 == NULL) SWIG_fail;
21687 temp2 = true;
21688 }
21689 if (obj2) {
21690 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21691 if (!SWIG_IsOK(ecode3)) {
21692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21693 }
21694 arg3 = static_cast< bool >(val3);
21695 }
21696 {
21697 PyThreadState* __tstate = wxPyBeginAllowThreads();
21698 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21699 wxPyEndAllowThreads(__tstate);
21700 if (PyErr_Occurred()) SWIG_fail;
21701 }
21702 {
21703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21704 }
21705 {
21706 if (temp2)
21707 delete arg2;
21708 }
21709 return resultobj;
21710 fail:
21711 {
21712 if (temp2)
21713 delete arg2;
21714 }
21715 return NULL;
21716 }
21717
21718
21719 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21720 PyObject *resultobj = 0;
21721 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21722 wxString *arg2 = 0 ;
21723 wxString *arg3 = 0 ;
21724 bool result;
21725 void *argp1 = 0 ;
21726 int res1 = 0 ;
21727 bool temp2 = false ;
21728 bool temp3 = false ;
21729 PyObject * obj0 = 0 ;
21730 PyObject * obj1 = 0 ;
21731 PyObject * obj2 = 0 ;
21732 char * kwnames[] = {
21733 (char *) "self",(char *) "key",(char *) "value", NULL
21734 };
21735
21736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21738 if (!SWIG_IsOK(res1)) {
21739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21740 }
21741 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21742 {
21743 arg2 = wxString_in_helper(obj1);
21744 if (arg2 == NULL) SWIG_fail;
21745 temp2 = true;
21746 }
21747 {
21748 arg3 = wxString_in_helper(obj2);
21749 if (arg3 == NULL) SWIG_fail;
21750 temp3 = true;
21751 }
21752 {
21753 PyThreadState* __tstate = wxPyBeginAllowThreads();
21754 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21755 wxPyEndAllowThreads(__tstate);
21756 if (PyErr_Occurred()) SWIG_fail;
21757 }
21758 {
21759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21760 }
21761 {
21762 if (temp2)
21763 delete arg2;
21764 }
21765 {
21766 if (temp3)
21767 delete arg3;
21768 }
21769 return resultobj;
21770 fail:
21771 {
21772 if (temp2)
21773 delete arg2;
21774 }
21775 {
21776 if (temp3)
21777 delete arg3;
21778 }
21779 return NULL;
21780 }
21781
21782
21783 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21784 PyObject *resultobj = 0;
21785 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21786 wxString *arg2 = 0 ;
21787 long arg3 ;
21788 bool result;
21789 void *argp1 = 0 ;
21790 int res1 = 0 ;
21791 bool temp2 = false ;
21792 long val3 ;
21793 int ecode3 = 0 ;
21794 PyObject * obj0 = 0 ;
21795 PyObject * obj1 = 0 ;
21796 PyObject * obj2 = 0 ;
21797 char * kwnames[] = {
21798 (char *) "self",(char *) "key",(char *) "value", NULL
21799 };
21800
21801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21803 if (!SWIG_IsOK(res1)) {
21804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21805 }
21806 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21807 {
21808 arg2 = wxString_in_helper(obj1);
21809 if (arg2 == NULL) SWIG_fail;
21810 temp2 = true;
21811 }
21812 ecode3 = SWIG_AsVal_long(obj2, &val3);
21813 if (!SWIG_IsOK(ecode3)) {
21814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21815 }
21816 arg3 = static_cast< long >(val3);
21817 {
21818 PyThreadState* __tstate = wxPyBeginAllowThreads();
21819 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 {
21824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21825 }
21826 {
21827 if (temp2)
21828 delete arg2;
21829 }
21830 return resultobj;
21831 fail:
21832 {
21833 if (temp2)
21834 delete arg2;
21835 }
21836 return NULL;
21837 }
21838
21839
21840 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21841 PyObject *resultobj = 0;
21842 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21843 wxString *arg2 = 0 ;
21844 double arg3 ;
21845 bool result;
21846 void *argp1 = 0 ;
21847 int res1 = 0 ;
21848 bool temp2 = false ;
21849 double val3 ;
21850 int ecode3 = 0 ;
21851 PyObject * obj0 = 0 ;
21852 PyObject * obj1 = 0 ;
21853 PyObject * obj2 = 0 ;
21854 char * kwnames[] = {
21855 (char *) "self",(char *) "key",(char *) "value", NULL
21856 };
21857
21858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21860 if (!SWIG_IsOK(res1)) {
21861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21862 }
21863 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21864 {
21865 arg2 = wxString_in_helper(obj1);
21866 if (arg2 == NULL) SWIG_fail;
21867 temp2 = true;
21868 }
21869 ecode3 = SWIG_AsVal_double(obj2, &val3);
21870 if (!SWIG_IsOK(ecode3)) {
21871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21872 }
21873 arg3 = static_cast< double >(val3);
21874 {
21875 PyThreadState* __tstate = wxPyBeginAllowThreads();
21876 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 {
21881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21882 }
21883 {
21884 if (temp2)
21885 delete arg2;
21886 }
21887 return resultobj;
21888 fail:
21889 {
21890 if (temp2)
21891 delete arg2;
21892 }
21893 return NULL;
21894 }
21895
21896
21897 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21898 PyObject *resultobj = 0;
21899 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21900 wxString *arg2 = 0 ;
21901 bool arg3 ;
21902 bool result;
21903 void *argp1 = 0 ;
21904 int res1 = 0 ;
21905 bool temp2 = false ;
21906 bool val3 ;
21907 int ecode3 = 0 ;
21908 PyObject * obj0 = 0 ;
21909 PyObject * obj1 = 0 ;
21910 PyObject * obj2 = 0 ;
21911 char * kwnames[] = {
21912 (char *) "self",(char *) "key",(char *) "value", NULL
21913 };
21914
21915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21917 if (!SWIG_IsOK(res1)) {
21918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21919 }
21920 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21921 {
21922 arg2 = wxString_in_helper(obj1);
21923 if (arg2 == NULL) SWIG_fail;
21924 temp2 = true;
21925 }
21926 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21927 if (!SWIG_IsOK(ecode3)) {
21928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21929 }
21930 arg3 = static_cast< bool >(val3);
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21939 }
21940 {
21941 if (temp2)
21942 delete arg2;
21943 }
21944 return resultobj;
21945 fail:
21946 {
21947 if (temp2)
21948 delete arg2;
21949 }
21950 return NULL;
21951 }
21952
21953
21954 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21955 PyObject *resultobj = 0;
21956 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21957 bool arg2 = (bool) false ;
21958 bool result;
21959 void *argp1 = 0 ;
21960 int res1 = 0 ;
21961 bool val2 ;
21962 int ecode2 = 0 ;
21963 PyObject * obj0 = 0 ;
21964 PyObject * obj1 = 0 ;
21965 char * kwnames[] = {
21966 (char *) "self",(char *) "currentOnly", NULL
21967 };
21968
21969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21971 if (!SWIG_IsOK(res1)) {
21972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21973 }
21974 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21975 if (obj1) {
21976 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21977 if (!SWIG_IsOK(ecode2)) {
21978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21979 }
21980 arg2 = static_cast< bool >(val2);
21981 }
21982 {
21983 PyThreadState* __tstate = wxPyBeginAllowThreads();
21984 result = (bool)(arg1)->Flush(arg2);
21985 wxPyEndAllowThreads(__tstate);
21986 if (PyErr_Occurred()) SWIG_fail;
21987 }
21988 {
21989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21990 }
21991 return resultobj;
21992 fail:
21993 return NULL;
21994 }
21995
21996
21997 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21998 PyObject *resultobj = 0;
21999 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22000 wxString *arg2 = 0 ;
22001 wxString *arg3 = 0 ;
22002 bool result;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 bool temp2 = false ;
22006 bool temp3 = false ;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 PyObject * obj2 = 0 ;
22010 char * kwnames[] = {
22011 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22012 };
22013
22014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22016 if (!SWIG_IsOK(res1)) {
22017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22018 }
22019 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22020 {
22021 arg2 = wxString_in_helper(obj1);
22022 if (arg2 == NULL) SWIG_fail;
22023 temp2 = true;
22024 }
22025 {
22026 arg3 = wxString_in_helper(obj2);
22027 if (arg3 == NULL) SWIG_fail;
22028 temp3 = true;
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 {
22037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22038 }
22039 {
22040 if (temp2)
22041 delete arg2;
22042 }
22043 {
22044 if (temp3)
22045 delete arg3;
22046 }
22047 return resultobj;
22048 fail:
22049 {
22050 if (temp2)
22051 delete arg2;
22052 }
22053 {
22054 if (temp3)
22055 delete arg3;
22056 }
22057 return NULL;
22058 }
22059
22060
22061 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22062 PyObject *resultobj = 0;
22063 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22064 wxString *arg2 = 0 ;
22065 wxString *arg3 = 0 ;
22066 bool result;
22067 void *argp1 = 0 ;
22068 int res1 = 0 ;
22069 bool temp2 = false ;
22070 bool temp3 = false ;
22071 PyObject * obj0 = 0 ;
22072 PyObject * obj1 = 0 ;
22073 PyObject * obj2 = 0 ;
22074 char * kwnames[] = {
22075 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22076 };
22077
22078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22082 }
22083 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22084 {
22085 arg2 = wxString_in_helper(obj1);
22086 if (arg2 == NULL) SWIG_fail;
22087 temp2 = true;
22088 }
22089 {
22090 arg3 = wxString_in_helper(obj2);
22091 if (arg3 == NULL) SWIG_fail;
22092 temp3 = true;
22093 }
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 {
22101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22102 }
22103 {
22104 if (temp2)
22105 delete arg2;
22106 }
22107 {
22108 if (temp3)
22109 delete arg3;
22110 }
22111 return resultobj;
22112 fail:
22113 {
22114 if (temp2)
22115 delete arg2;
22116 }
22117 {
22118 if (temp3)
22119 delete arg3;
22120 }
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22126 PyObject *resultobj = 0;
22127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22128 wxString *arg2 = 0 ;
22129 bool arg3 = (bool) true ;
22130 bool result;
22131 void *argp1 = 0 ;
22132 int res1 = 0 ;
22133 bool temp2 = false ;
22134 bool val3 ;
22135 int ecode3 = 0 ;
22136 PyObject * obj0 = 0 ;
22137 PyObject * obj1 = 0 ;
22138 PyObject * obj2 = 0 ;
22139 char * kwnames[] = {
22140 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22141 };
22142
22143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22145 if (!SWIG_IsOK(res1)) {
22146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22147 }
22148 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22149 {
22150 arg2 = wxString_in_helper(obj1);
22151 if (arg2 == NULL) SWIG_fail;
22152 temp2 = true;
22153 }
22154 if (obj2) {
22155 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22156 if (!SWIG_IsOK(ecode3)) {
22157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22158 }
22159 arg3 = static_cast< bool >(val3);
22160 }
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22164 wxPyEndAllowThreads(__tstate);
22165 if (PyErr_Occurred()) SWIG_fail;
22166 }
22167 {
22168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22169 }
22170 {
22171 if (temp2)
22172 delete arg2;
22173 }
22174 return resultobj;
22175 fail:
22176 {
22177 if (temp2)
22178 delete arg2;
22179 }
22180 return NULL;
22181 }
22182
22183
22184 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22185 PyObject *resultobj = 0;
22186 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22187 wxString *arg2 = 0 ;
22188 bool result;
22189 void *argp1 = 0 ;
22190 int res1 = 0 ;
22191 bool temp2 = false ;
22192 PyObject * obj0 = 0 ;
22193 PyObject * obj1 = 0 ;
22194 char * kwnames[] = {
22195 (char *) "self",(char *) "key", NULL
22196 };
22197
22198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22200 if (!SWIG_IsOK(res1)) {
22201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22202 }
22203 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22204 {
22205 arg2 = wxString_in_helper(obj1);
22206 if (arg2 == NULL) SWIG_fail;
22207 temp2 = true;
22208 }
22209 {
22210 PyThreadState* __tstate = wxPyBeginAllowThreads();
22211 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 {
22216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22217 }
22218 {
22219 if (temp2)
22220 delete arg2;
22221 }
22222 return resultobj;
22223 fail:
22224 {
22225 if (temp2)
22226 delete arg2;
22227 }
22228 return NULL;
22229 }
22230
22231
22232 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22233 PyObject *resultobj = 0;
22234 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22235 bool result;
22236 void *argp1 = 0 ;
22237 int res1 = 0 ;
22238 PyObject *swig_obj[1] ;
22239
22240 if (!args) SWIG_fail;
22241 swig_obj[0] = args;
22242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22243 if (!SWIG_IsOK(res1)) {
22244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22245 }
22246 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 result = (bool)(arg1)->DeleteAll();
22250 wxPyEndAllowThreads(__tstate);
22251 if (PyErr_Occurred()) SWIG_fail;
22252 }
22253 {
22254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22255 }
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj = 0;
22264 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22265 bool arg2 = (bool) true ;
22266 void *argp1 = 0 ;
22267 int res1 = 0 ;
22268 bool val2 ;
22269 int ecode2 = 0 ;
22270 PyObject * obj0 = 0 ;
22271 PyObject * obj1 = 0 ;
22272 char * kwnames[] = {
22273 (char *) "self",(char *) "doIt", NULL
22274 };
22275
22276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22278 if (!SWIG_IsOK(res1)) {
22279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22280 }
22281 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22282 if (obj1) {
22283 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22284 if (!SWIG_IsOK(ecode2)) {
22285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22286 }
22287 arg2 = static_cast< bool >(val2);
22288 }
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 (arg1)->SetExpandEnvVars(arg2);
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 resultobj = SWIG_Py_Void();
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22303 PyObject *resultobj = 0;
22304 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22305 bool result;
22306 void *argp1 = 0 ;
22307 int res1 = 0 ;
22308 PyObject *swig_obj[1] ;
22309
22310 if (!args) SWIG_fail;
22311 swig_obj[0] = args;
22312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22313 if (!SWIG_IsOK(res1)) {
22314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22315 }
22316 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22317 {
22318 PyThreadState* __tstate = wxPyBeginAllowThreads();
22319 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 {
22324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22325 }
22326 return resultobj;
22327 fail:
22328 return NULL;
22329 }
22330
22331
22332 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22333 PyObject *resultobj = 0;
22334 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22335 bool arg2 = (bool) true ;
22336 void *argp1 = 0 ;
22337 int res1 = 0 ;
22338 bool val2 ;
22339 int ecode2 = 0 ;
22340 PyObject * obj0 = 0 ;
22341 PyObject * obj1 = 0 ;
22342 char * kwnames[] = {
22343 (char *) "self",(char *) "doIt", NULL
22344 };
22345
22346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22348 if (!SWIG_IsOK(res1)) {
22349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22350 }
22351 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22352 if (obj1) {
22353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22354 if (!SWIG_IsOK(ecode2)) {
22355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22356 }
22357 arg2 = static_cast< bool >(val2);
22358 }
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 (arg1)->SetRecordDefaults(arg2);
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 resultobj = SWIG_Py_Void();
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22373 PyObject *resultobj = 0;
22374 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22375 bool result;
22376 void *argp1 = 0 ;
22377 int res1 = 0 ;
22378 PyObject *swig_obj[1] ;
22379
22380 if (!args) SWIG_fail;
22381 swig_obj[0] = args;
22382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22383 if (!SWIG_IsOK(res1)) {
22384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22385 }
22386 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22387 {
22388 PyThreadState* __tstate = wxPyBeginAllowThreads();
22389 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22390 wxPyEndAllowThreads(__tstate);
22391 if (PyErr_Occurred()) SWIG_fail;
22392 }
22393 {
22394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22395 }
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22403 PyObject *resultobj = 0;
22404 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22405 wxString *arg2 = 0 ;
22406 wxString result;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 bool temp2 = false ;
22410 PyObject * obj0 = 0 ;
22411 PyObject * obj1 = 0 ;
22412 char * kwnames[] = {
22413 (char *) "self",(char *) "str", NULL
22414 };
22415
22416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22418 if (!SWIG_IsOK(res1)) {
22419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22420 }
22421 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22422 {
22423 arg2 = wxString_in_helper(obj1);
22424 if (arg2 == NULL) SWIG_fail;
22425 temp2 = true;
22426 }
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 {
22434 #if wxUSE_UNICODE
22435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22436 #else
22437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22438 #endif
22439 }
22440 {
22441 if (temp2)
22442 delete arg2;
22443 }
22444 return resultobj;
22445 fail:
22446 {
22447 if (temp2)
22448 delete arg2;
22449 }
22450 return NULL;
22451 }
22452
22453
22454 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22455 PyObject *resultobj = 0;
22456 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22457 wxString result;
22458 void *argp1 = 0 ;
22459 int res1 = 0 ;
22460 PyObject *swig_obj[1] ;
22461
22462 if (!args) SWIG_fail;
22463 swig_obj[0] = args;
22464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22465 if (!SWIG_IsOK(res1)) {
22466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22467 }
22468 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22469 {
22470 PyThreadState* __tstate = wxPyBeginAllowThreads();
22471 result = ((wxConfigBase const *)arg1)->GetAppName();
22472 wxPyEndAllowThreads(__tstate);
22473 if (PyErr_Occurred()) SWIG_fail;
22474 }
22475 {
22476 #if wxUSE_UNICODE
22477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22478 #else
22479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22480 #endif
22481 }
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22489 PyObject *resultobj = 0;
22490 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22491 wxString result;
22492 void *argp1 = 0 ;
22493 int res1 = 0 ;
22494 PyObject *swig_obj[1] ;
22495
22496 if (!args) SWIG_fail;
22497 swig_obj[0] = args;
22498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22499 if (!SWIG_IsOK(res1)) {
22500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22501 }
22502 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22503 {
22504 PyThreadState* __tstate = wxPyBeginAllowThreads();
22505 result = ((wxConfigBase const *)arg1)->GetVendorName();
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 {
22510 #if wxUSE_UNICODE
22511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22512 #else
22513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22514 #endif
22515 }
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22523 PyObject *resultobj = 0;
22524 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22525 wxString *arg2 = 0 ;
22526 void *argp1 = 0 ;
22527 int res1 = 0 ;
22528 bool temp2 = false ;
22529 PyObject * obj0 = 0 ;
22530 PyObject * obj1 = 0 ;
22531 char * kwnames[] = {
22532 (char *) "self",(char *) "appName", NULL
22533 };
22534
22535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22539 }
22540 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22541 {
22542 arg2 = wxString_in_helper(obj1);
22543 if (arg2 == NULL) SWIG_fail;
22544 temp2 = true;
22545 }
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 (arg1)->SetAppName((wxString const &)*arg2);
22549 wxPyEndAllowThreads(__tstate);
22550 if (PyErr_Occurred()) SWIG_fail;
22551 }
22552 resultobj = SWIG_Py_Void();
22553 {
22554 if (temp2)
22555 delete arg2;
22556 }
22557 return resultobj;
22558 fail:
22559 {
22560 if (temp2)
22561 delete arg2;
22562 }
22563 return NULL;
22564 }
22565
22566
22567 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22568 PyObject *resultobj = 0;
22569 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22570 wxString *arg2 = 0 ;
22571 void *argp1 = 0 ;
22572 int res1 = 0 ;
22573 bool temp2 = false ;
22574 PyObject * obj0 = 0 ;
22575 PyObject * obj1 = 0 ;
22576 char * kwnames[] = {
22577 (char *) "self",(char *) "vendorName", NULL
22578 };
22579
22580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22582 if (!SWIG_IsOK(res1)) {
22583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22584 }
22585 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22586 {
22587 arg2 = wxString_in_helper(obj1);
22588 if (arg2 == NULL) SWIG_fail;
22589 temp2 = true;
22590 }
22591 {
22592 PyThreadState* __tstate = wxPyBeginAllowThreads();
22593 (arg1)->SetVendorName((wxString const &)*arg2);
22594 wxPyEndAllowThreads(__tstate);
22595 if (PyErr_Occurred()) SWIG_fail;
22596 }
22597 resultobj = SWIG_Py_Void();
22598 {
22599 if (temp2)
22600 delete arg2;
22601 }
22602 return resultobj;
22603 fail:
22604 {
22605 if (temp2)
22606 delete arg2;
22607 }
22608 return NULL;
22609 }
22610
22611
22612 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22613 PyObject *resultobj = 0;
22614 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22615 long arg2 ;
22616 void *argp1 = 0 ;
22617 int res1 = 0 ;
22618 long val2 ;
22619 int ecode2 = 0 ;
22620 PyObject * obj0 = 0 ;
22621 PyObject * obj1 = 0 ;
22622 char * kwnames[] = {
22623 (char *) "self",(char *) "style", NULL
22624 };
22625
22626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22628 if (!SWIG_IsOK(res1)) {
22629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22630 }
22631 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22632 ecode2 = SWIG_AsVal_long(obj1, &val2);
22633 if (!SWIG_IsOK(ecode2)) {
22634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22635 }
22636 arg2 = static_cast< long >(val2);
22637 {
22638 PyThreadState* __tstate = wxPyBeginAllowThreads();
22639 (arg1)->SetStyle(arg2);
22640 wxPyEndAllowThreads(__tstate);
22641 if (PyErr_Occurred()) SWIG_fail;
22642 }
22643 resultobj = SWIG_Py_Void();
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22651 PyObject *resultobj = 0;
22652 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22653 long result;
22654 void *argp1 = 0 ;
22655 int res1 = 0 ;
22656 PyObject *swig_obj[1] ;
22657
22658 if (!args) SWIG_fail;
22659 swig_obj[0] = args;
22660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22661 if (!SWIG_IsOK(res1)) {
22662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22663 }
22664 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22665 {
22666 PyThreadState* __tstate = wxPyBeginAllowThreads();
22667 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 resultobj = SWIG_From_long(static_cast< long >(result));
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22679 PyObject *obj;
22680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22681 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22682 return SWIG_Py_Void();
22683 }
22684
22685 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22686 PyObject *resultobj = 0;
22687 wxString const &arg1_defvalue = wxPyEmptyString ;
22688 wxString *arg1 = (wxString *) &arg1_defvalue ;
22689 wxString const &arg2_defvalue = wxPyEmptyString ;
22690 wxString *arg2 = (wxString *) &arg2_defvalue ;
22691 wxString const &arg3_defvalue = wxPyEmptyString ;
22692 wxString *arg3 = (wxString *) &arg3_defvalue ;
22693 wxString const &arg4_defvalue = wxPyEmptyString ;
22694 wxString *arg4 = (wxString *) &arg4_defvalue ;
22695 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22696 wxConfig *result = 0 ;
22697 bool temp1 = false ;
22698 bool temp2 = false ;
22699 bool temp3 = false ;
22700 bool temp4 = false ;
22701 long val5 ;
22702 int ecode5 = 0 ;
22703 PyObject * obj0 = 0 ;
22704 PyObject * obj1 = 0 ;
22705 PyObject * obj2 = 0 ;
22706 PyObject * obj3 = 0 ;
22707 PyObject * obj4 = 0 ;
22708 char * kwnames[] = {
22709 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22710 };
22711
22712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22713 if (obj0) {
22714 {
22715 arg1 = wxString_in_helper(obj0);
22716 if (arg1 == NULL) SWIG_fail;
22717 temp1 = true;
22718 }
22719 }
22720 if (obj1) {
22721 {
22722 arg2 = wxString_in_helper(obj1);
22723 if (arg2 == NULL) SWIG_fail;
22724 temp2 = true;
22725 }
22726 }
22727 if (obj2) {
22728 {
22729 arg3 = wxString_in_helper(obj2);
22730 if (arg3 == NULL) SWIG_fail;
22731 temp3 = true;
22732 }
22733 }
22734 if (obj3) {
22735 {
22736 arg4 = wxString_in_helper(obj3);
22737 if (arg4 == NULL) SWIG_fail;
22738 temp4 = true;
22739 }
22740 }
22741 if (obj4) {
22742 ecode5 = SWIG_AsVal_long(obj4, &val5);
22743 if (!SWIG_IsOK(ecode5)) {
22744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22745 }
22746 arg5 = static_cast< long >(val5);
22747 }
22748 {
22749 PyThreadState* __tstate = wxPyBeginAllowThreads();
22750 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22755 {
22756 if (temp1)
22757 delete arg1;
22758 }
22759 {
22760 if (temp2)
22761 delete arg2;
22762 }
22763 {
22764 if (temp3)
22765 delete arg3;
22766 }
22767 {
22768 if (temp4)
22769 delete arg4;
22770 }
22771 return resultobj;
22772 fail:
22773 {
22774 if (temp1)
22775 delete arg1;
22776 }
22777 {
22778 if (temp2)
22779 delete arg2;
22780 }
22781 {
22782 if (temp3)
22783 delete arg3;
22784 }
22785 {
22786 if (temp4)
22787 delete arg4;
22788 }
22789 return NULL;
22790 }
22791
22792
22793 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22794 PyObject *resultobj = 0;
22795 wxConfig *arg1 = (wxConfig *) 0 ;
22796 void *argp1 = 0 ;
22797 int res1 = 0 ;
22798 PyObject *swig_obj[1] ;
22799
22800 if (!args) SWIG_fail;
22801 swig_obj[0] = args;
22802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22803 if (!SWIG_IsOK(res1)) {
22804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22805 }
22806 arg1 = reinterpret_cast< wxConfig * >(argp1);
22807 {
22808 PyThreadState* __tstate = wxPyBeginAllowThreads();
22809 delete arg1;
22810
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 resultobj = SWIG_Py_Void();
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22822 PyObject *obj;
22823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22824 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22825 return SWIG_Py_Void();
22826 }
22827
22828 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22829 return SWIG_Python_InitShadowInstance(args);
22830 }
22831
22832 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22833 PyObject *resultobj = 0;
22834 wxString const &arg1_defvalue = wxPyEmptyString ;
22835 wxString *arg1 = (wxString *) &arg1_defvalue ;
22836 wxString const &arg2_defvalue = wxPyEmptyString ;
22837 wxString *arg2 = (wxString *) &arg2_defvalue ;
22838 wxString const &arg3_defvalue = wxPyEmptyString ;
22839 wxString *arg3 = (wxString *) &arg3_defvalue ;
22840 wxString const &arg4_defvalue = wxPyEmptyString ;
22841 wxString *arg4 = (wxString *) &arg4_defvalue ;
22842 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22843 wxFileConfig *result = 0 ;
22844 bool temp1 = false ;
22845 bool temp2 = false ;
22846 bool temp3 = false ;
22847 bool temp4 = false ;
22848 long val5 ;
22849 int ecode5 = 0 ;
22850 PyObject * obj0 = 0 ;
22851 PyObject * obj1 = 0 ;
22852 PyObject * obj2 = 0 ;
22853 PyObject * obj3 = 0 ;
22854 PyObject * obj4 = 0 ;
22855 char * kwnames[] = {
22856 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22857 };
22858
22859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22860 if (obj0) {
22861 {
22862 arg1 = wxString_in_helper(obj0);
22863 if (arg1 == NULL) SWIG_fail;
22864 temp1 = true;
22865 }
22866 }
22867 if (obj1) {
22868 {
22869 arg2 = wxString_in_helper(obj1);
22870 if (arg2 == NULL) SWIG_fail;
22871 temp2 = true;
22872 }
22873 }
22874 if (obj2) {
22875 {
22876 arg3 = wxString_in_helper(obj2);
22877 if (arg3 == NULL) SWIG_fail;
22878 temp3 = true;
22879 }
22880 }
22881 if (obj3) {
22882 {
22883 arg4 = wxString_in_helper(obj3);
22884 if (arg4 == NULL) SWIG_fail;
22885 temp4 = true;
22886 }
22887 }
22888 if (obj4) {
22889 ecode5 = SWIG_AsVal_long(obj4, &val5);
22890 if (!SWIG_IsOK(ecode5)) {
22891 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22892 }
22893 arg5 = static_cast< long >(val5);
22894 }
22895 {
22896 PyThreadState* __tstate = wxPyBeginAllowThreads();
22897 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22898 wxPyEndAllowThreads(__tstate);
22899 if (PyErr_Occurred()) SWIG_fail;
22900 }
22901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22902 {
22903 if (temp1)
22904 delete arg1;
22905 }
22906 {
22907 if (temp2)
22908 delete arg2;
22909 }
22910 {
22911 if (temp3)
22912 delete arg3;
22913 }
22914 {
22915 if (temp4)
22916 delete arg4;
22917 }
22918 return resultobj;
22919 fail:
22920 {
22921 if (temp1)
22922 delete arg1;
22923 }
22924 {
22925 if (temp2)
22926 delete arg2;
22927 }
22928 {
22929 if (temp3)
22930 delete arg3;
22931 }
22932 {
22933 if (temp4)
22934 delete arg4;
22935 }
22936 return NULL;
22937 }
22938
22939
22940 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22941 PyObject *resultobj = 0;
22942 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22943 void *argp1 = 0 ;
22944 int res1 = 0 ;
22945 PyObject *swig_obj[1] ;
22946
22947 if (!args) SWIG_fail;
22948 swig_obj[0] = args;
22949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22950 if (!SWIG_IsOK(res1)) {
22951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22952 }
22953 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 delete arg1;
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 resultobj = SWIG_Py_Void();
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22969 PyObject *obj;
22970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22971 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22972 return SWIG_Py_Void();
22973 }
22974
22975 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22976 return SWIG_Python_InitShadowInstance(args);
22977 }
22978
22979 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22980 PyObject *resultobj = 0;
22981 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22982 wxString *arg2 = 0 ;
22983 wxConfigPathChanger *result = 0 ;
22984 void *argp1 = 0 ;
22985 int res1 = 0 ;
22986 bool temp2 = false ;
22987 PyObject * obj0 = 0 ;
22988 PyObject * obj1 = 0 ;
22989 char * kwnames[] = {
22990 (char *) "config",(char *) "entry", NULL
22991 };
22992
22993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22997 }
22998 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22999 {
23000 arg2 = wxString_in_helper(obj1);
23001 if (arg2 == NULL) SWIG_fail;
23002 temp2 = true;
23003 }
23004 {
23005 PyThreadState* __tstate = wxPyBeginAllowThreads();
23006 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23007 wxPyEndAllowThreads(__tstate);
23008 if (PyErr_Occurred()) SWIG_fail;
23009 }
23010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23011 {
23012 if (temp2)
23013 delete arg2;
23014 }
23015 return resultobj;
23016 fail:
23017 {
23018 if (temp2)
23019 delete arg2;
23020 }
23021 return NULL;
23022 }
23023
23024
23025 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23026 PyObject *resultobj = 0;
23027 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23028 void *argp1 = 0 ;
23029 int res1 = 0 ;
23030 PyObject *swig_obj[1] ;
23031
23032 if (!args) SWIG_fail;
23033 swig_obj[0] = args;
23034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23035 if (!SWIG_IsOK(res1)) {
23036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23037 }
23038 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23039 {
23040 PyThreadState* __tstate = wxPyBeginAllowThreads();
23041 delete arg1;
23042
23043 wxPyEndAllowThreads(__tstate);
23044 if (PyErr_Occurred()) SWIG_fail;
23045 }
23046 resultobj = SWIG_Py_Void();
23047 return resultobj;
23048 fail:
23049 return NULL;
23050 }
23051
23052
23053 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23054 PyObject *resultobj = 0;
23055 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23056 wxString *result = 0 ;
23057 void *argp1 = 0 ;
23058 int res1 = 0 ;
23059 PyObject *swig_obj[1] ;
23060
23061 if (!args) SWIG_fail;
23062 swig_obj[0] = args;
23063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23064 if (!SWIG_IsOK(res1)) {
23065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23066 }
23067 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 {
23071 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23072 result = (wxString *) &_result_ref;
23073 }
23074 wxPyEndAllowThreads(__tstate);
23075 if (PyErr_Occurred()) SWIG_fail;
23076 }
23077 {
23078 #if wxUSE_UNICODE
23079 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23080 #else
23081 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23082 #endif
23083 }
23084 return resultobj;
23085 fail:
23086 return NULL;
23087 }
23088
23089
23090 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23091 PyObject *obj;
23092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23093 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23094 return SWIG_Py_Void();
23095 }
23096
23097 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 return SWIG_Python_InitShadowInstance(args);
23099 }
23100
23101 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23102 PyObject *resultobj = 0;
23103 wxString *arg1 = 0 ;
23104 wxString result;
23105 bool temp1 = false ;
23106 PyObject * obj0 = 0 ;
23107 char * kwnames[] = {
23108 (char *) "sz", NULL
23109 };
23110
23111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23112 {
23113 arg1 = wxString_in_helper(obj0);
23114 if (arg1 == NULL) SWIG_fail;
23115 temp1 = true;
23116 }
23117 {
23118 PyThreadState* __tstate = wxPyBeginAllowThreads();
23119 result = wxExpandEnvVars((wxString const &)*arg1);
23120 wxPyEndAllowThreads(__tstate);
23121 if (PyErr_Occurred()) SWIG_fail;
23122 }
23123 {
23124 #if wxUSE_UNICODE
23125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23126 #else
23127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23128 #endif
23129 }
23130 {
23131 if (temp1)
23132 delete arg1;
23133 }
23134 return resultobj;
23135 fail:
23136 {
23137 if (temp1)
23138 delete arg1;
23139 }
23140 return NULL;
23141 }
23142
23143
23144 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23145 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23146 return 1;
23147 }
23148
23149
23150 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23151 PyObject *pyobj = 0;
23152
23153 {
23154 #if wxUSE_UNICODE
23155 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23156 #else
23157 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23158 #endif
23159 }
23160 return pyobj;
23161 }
23162
23163
23164 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23165 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23166 return 1;
23167 }
23168
23169
23170 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23171 PyObject *pyobj = 0;
23172
23173 {
23174 #if wxUSE_UNICODE
23175 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23176 #else
23177 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23178 #endif
23179 }
23180 return pyobj;
23181 }
23182
23183
23184 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23185 PyObject *resultobj = 0;
23186 wxDateTime::Country arg1 ;
23187 int val1 ;
23188 int ecode1 = 0 ;
23189 PyObject * obj0 = 0 ;
23190 char * kwnames[] = {
23191 (char *) "country", NULL
23192 };
23193
23194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23195 ecode1 = SWIG_AsVal_int(obj0, &val1);
23196 if (!SWIG_IsOK(ecode1)) {
23197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23198 }
23199 arg1 = static_cast< wxDateTime::Country >(val1);
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 wxDateTime::SetCountry(arg1);
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 resultobj = SWIG_Py_Void();
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23214 PyObject *resultobj = 0;
23215 wxDateTime::Country result;
23216
23217 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23218 {
23219 PyThreadState* __tstate = wxPyBeginAllowThreads();
23220 result = (wxDateTime::Country)wxDateTime::GetCountry();
23221 wxPyEndAllowThreads(__tstate);
23222 if (PyErr_Occurred()) SWIG_fail;
23223 }
23224 resultobj = SWIG_From_int(static_cast< int >(result));
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23232 PyObject *resultobj = 0;
23233 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23234 bool result;
23235 int val1 ;
23236 int ecode1 = 0 ;
23237 PyObject * obj0 = 0 ;
23238 char * kwnames[] = {
23239 (char *) "country", NULL
23240 };
23241
23242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23243 if (obj0) {
23244 ecode1 = SWIG_AsVal_int(obj0, &val1);
23245 if (!SWIG_IsOK(ecode1)) {
23246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23247 }
23248 arg1 = static_cast< wxDateTime::Country >(val1);
23249 }
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 {
23257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23258 }
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23266 PyObject *resultobj = 0;
23267 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23268 int result;
23269 int val1 ;
23270 int ecode1 = 0 ;
23271 PyObject * obj0 = 0 ;
23272 char * kwnames[] = {
23273 (char *) "cal", NULL
23274 };
23275
23276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23277 if (obj0) {
23278 ecode1 = SWIG_AsVal_int(obj0, &val1);
23279 if (!SWIG_IsOK(ecode1)) {
23280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23281 }
23282 arg1 = static_cast< wxDateTime::Calendar >(val1);
23283 }
23284 {
23285 PyThreadState* __tstate = wxPyBeginAllowThreads();
23286 result = (int)wxDateTime::GetCurrentYear(arg1);
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 resultobj = SWIG_From_int(static_cast< int >(result));
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj = 0;
23299 int arg1 ;
23300 int result;
23301 int val1 ;
23302 int ecode1 = 0 ;
23303 PyObject * obj0 = 0 ;
23304 char * kwnames[] = {
23305 (char *) "year", NULL
23306 };
23307
23308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23309 ecode1 = SWIG_AsVal_int(obj0, &val1);
23310 if (!SWIG_IsOK(ecode1)) {
23311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23312 }
23313 arg1 = static_cast< int >(val1);
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 result = (int)wxDateTime::ConvertYearToBC(arg1);
23317 wxPyEndAllowThreads(__tstate);
23318 if (PyErr_Occurred()) SWIG_fail;
23319 }
23320 resultobj = SWIG_From_int(static_cast< int >(result));
23321 return resultobj;
23322 fail:
23323 return NULL;
23324 }
23325
23326
23327 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23328 PyObject *resultobj = 0;
23329 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23330 wxDateTime::Month result;
23331 int val1 ;
23332 int ecode1 = 0 ;
23333 PyObject * obj0 = 0 ;
23334 char * kwnames[] = {
23335 (char *) "cal", NULL
23336 };
23337
23338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23339 if (obj0) {
23340 ecode1 = SWIG_AsVal_int(obj0, &val1);
23341 if (!SWIG_IsOK(ecode1)) {
23342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23343 }
23344 arg1 = static_cast< wxDateTime::Calendar >(val1);
23345 }
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_From_int(static_cast< int >(result));
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj = 0;
23361 int arg1 = (int) wxDateTime::Inv_Year ;
23362 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23363 bool result;
23364 int val1 ;
23365 int ecode1 = 0 ;
23366 int val2 ;
23367 int ecode2 = 0 ;
23368 PyObject * obj0 = 0 ;
23369 PyObject * obj1 = 0 ;
23370 char * kwnames[] = {
23371 (char *) "year",(char *) "cal", NULL
23372 };
23373
23374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23375 if (obj0) {
23376 ecode1 = SWIG_AsVal_int(obj0, &val1);
23377 if (!SWIG_IsOK(ecode1)) {
23378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23379 }
23380 arg1 = static_cast< int >(val1);
23381 }
23382 if (obj1) {
23383 ecode2 = SWIG_AsVal_int(obj1, &val2);
23384 if (!SWIG_IsOK(ecode2)) {
23385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23386 }
23387 arg2 = static_cast< wxDateTime::Calendar >(val2);
23388 }
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 {
23396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23397 }
23398 return resultobj;
23399 fail:
23400 return NULL;
23401 }
23402
23403
23404 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23405 PyObject *resultobj = 0;
23406 int arg1 = (int) wxDateTime::Inv_Year ;
23407 int result;
23408 int val1 ;
23409 int ecode1 = 0 ;
23410 PyObject * obj0 = 0 ;
23411 char * kwnames[] = {
23412 (char *) "year", NULL
23413 };
23414
23415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23416 if (obj0) {
23417 ecode1 = SWIG_AsVal_int(obj0, &val1);
23418 if (!SWIG_IsOK(ecode1)) {
23419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23420 }
23421 arg1 = static_cast< int >(val1);
23422 }
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = (int)wxDateTime::GetCentury(arg1);
23426 wxPyEndAllowThreads(__tstate);
23427 if (PyErr_Occurred()) SWIG_fail;
23428 }
23429 resultobj = SWIG_From_int(static_cast< int >(result));
23430 return resultobj;
23431 fail:
23432 return NULL;
23433 }
23434
23435
23436 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23437 PyObject *resultobj = 0;
23438 int arg1 ;
23439 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23440 int result;
23441 int val1 ;
23442 int ecode1 = 0 ;
23443 int val2 ;
23444 int ecode2 = 0 ;
23445 PyObject * obj0 = 0 ;
23446 PyObject * obj1 = 0 ;
23447 char * kwnames[] = {
23448 (char *) "year",(char *) "cal", NULL
23449 };
23450
23451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23452 ecode1 = SWIG_AsVal_int(obj0, &val1);
23453 if (!SWIG_IsOK(ecode1)) {
23454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23455 }
23456 arg1 = static_cast< int >(val1);
23457 if (obj1) {
23458 ecode2 = SWIG_AsVal_int(obj1, &val2);
23459 if (!SWIG_IsOK(ecode2)) {
23460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23461 }
23462 arg2 = static_cast< wxDateTime::Calendar >(val2);
23463 }
23464 {
23465 PyThreadState* __tstate = wxPyBeginAllowThreads();
23466 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23467 wxPyEndAllowThreads(__tstate);
23468 if (PyErr_Occurred()) SWIG_fail;
23469 }
23470 resultobj = SWIG_From_int(static_cast< int >(result));
23471 return resultobj;
23472 fail:
23473 return NULL;
23474 }
23475
23476
23477 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj = 0;
23479 wxDateTime::Month arg1 ;
23480 int arg2 = (int) wxDateTime::Inv_Year ;
23481 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23482 int result;
23483 int val1 ;
23484 int ecode1 = 0 ;
23485 int val2 ;
23486 int ecode2 = 0 ;
23487 int val3 ;
23488 int ecode3 = 0 ;
23489 PyObject * obj0 = 0 ;
23490 PyObject * obj1 = 0 ;
23491 PyObject * obj2 = 0 ;
23492 char * kwnames[] = {
23493 (char *) "month",(char *) "year",(char *) "cal", NULL
23494 };
23495
23496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23497 ecode1 = SWIG_AsVal_int(obj0, &val1);
23498 if (!SWIG_IsOK(ecode1)) {
23499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23500 }
23501 arg1 = static_cast< wxDateTime::Month >(val1);
23502 if (obj1) {
23503 ecode2 = SWIG_AsVal_int(obj1, &val2);
23504 if (!SWIG_IsOK(ecode2)) {
23505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23506 }
23507 arg2 = static_cast< int >(val2);
23508 }
23509 if (obj2) {
23510 ecode3 = SWIG_AsVal_int(obj2, &val3);
23511 if (!SWIG_IsOK(ecode3)) {
23512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23513 }
23514 arg3 = static_cast< wxDateTime::Calendar >(val3);
23515 }
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23519 wxPyEndAllowThreads(__tstate);
23520 if (PyErr_Occurred()) SWIG_fail;
23521 }
23522 resultobj = SWIG_From_int(static_cast< int >(result));
23523 return resultobj;
23524 fail:
23525 return NULL;
23526 }
23527
23528
23529 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23530 PyObject *resultobj = 0;
23531 wxDateTime::Month arg1 ;
23532 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23533 wxString result;
23534 int val1 ;
23535 int ecode1 = 0 ;
23536 int val2 ;
23537 int ecode2 = 0 ;
23538 PyObject * obj0 = 0 ;
23539 PyObject * obj1 = 0 ;
23540 char * kwnames[] = {
23541 (char *) "month",(char *) "flags", NULL
23542 };
23543
23544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23545 ecode1 = SWIG_AsVal_int(obj0, &val1);
23546 if (!SWIG_IsOK(ecode1)) {
23547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23548 }
23549 arg1 = static_cast< wxDateTime::Month >(val1);
23550 if (obj1) {
23551 ecode2 = SWIG_AsVal_int(obj1, &val2);
23552 if (!SWIG_IsOK(ecode2)) {
23553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23554 }
23555 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23556 }
23557 {
23558 PyThreadState* __tstate = wxPyBeginAllowThreads();
23559 result = wxDateTime::GetMonthName(arg1,arg2);
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 {
23564 #if wxUSE_UNICODE
23565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23566 #else
23567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23568 #endif
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = 0;
23578 wxDateTime::WeekDay arg1 ;
23579 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23580 wxString result;
23581 int val1 ;
23582 int ecode1 = 0 ;
23583 int val2 ;
23584 int ecode2 = 0 ;
23585 PyObject * obj0 = 0 ;
23586 PyObject * obj1 = 0 ;
23587 char * kwnames[] = {
23588 (char *) "weekday",(char *) "flags", NULL
23589 };
23590
23591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23592 ecode1 = SWIG_AsVal_int(obj0, &val1);
23593 if (!SWIG_IsOK(ecode1)) {
23594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23595 }
23596 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23597 if (obj1) {
23598 ecode2 = SWIG_AsVal_int(obj1, &val2);
23599 if (!SWIG_IsOK(ecode2)) {
23600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23601 }
23602 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23603 }
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = wxDateTime::GetWeekDayName(arg1,arg2);
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 {
23611 #if wxUSE_UNICODE
23612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23613 #else
23614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23615 #endif
23616 }
23617 return resultobj;
23618 fail:
23619 return NULL;
23620 }
23621
23622
23623 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23624 PyObject *resultobj = 0;
23625 PyObject *result = 0 ;
23626
23627 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = (PyObject *)wxDateTime_GetAmPmStrings();
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = result;
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj = 0;
23643 int arg1 = (int) wxDateTime::Inv_Year ;
23644 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23645 bool result;
23646 int val1 ;
23647 int ecode1 = 0 ;
23648 int val2 ;
23649 int ecode2 = 0 ;
23650 PyObject * obj0 = 0 ;
23651 PyObject * obj1 = 0 ;
23652 char * kwnames[] = {
23653 (char *) "year",(char *) "country", NULL
23654 };
23655
23656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23657 if (obj0) {
23658 ecode1 = SWIG_AsVal_int(obj0, &val1);
23659 if (!SWIG_IsOK(ecode1)) {
23660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23661 }
23662 arg1 = static_cast< int >(val1);
23663 }
23664 if (obj1) {
23665 ecode2 = SWIG_AsVal_int(obj1, &val2);
23666 if (!SWIG_IsOK(ecode2)) {
23667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23668 }
23669 arg2 = static_cast< wxDateTime::Country >(val2);
23670 }
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj = 0;
23688 int arg1 = (int) wxDateTime::Inv_Year ;
23689 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23690 wxDateTime result;
23691 int val1 ;
23692 int ecode1 = 0 ;
23693 int val2 ;
23694 int ecode2 = 0 ;
23695 PyObject * obj0 = 0 ;
23696 PyObject * obj1 = 0 ;
23697 char * kwnames[] = {
23698 (char *) "year",(char *) "country", NULL
23699 };
23700
23701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23702 if (obj0) {
23703 ecode1 = SWIG_AsVal_int(obj0, &val1);
23704 if (!SWIG_IsOK(ecode1)) {
23705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23706 }
23707 arg1 = static_cast< int >(val1);
23708 }
23709 if (obj1) {
23710 ecode2 = SWIG_AsVal_int(obj1, &val2);
23711 if (!SWIG_IsOK(ecode2)) {
23712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23713 }
23714 arg2 = static_cast< wxDateTime::Country >(val2);
23715 }
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 result = wxDateTime::GetBeginDST(arg1,arg2);
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23723 return resultobj;
23724 fail:
23725 return NULL;
23726 }
23727
23728
23729 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23730 PyObject *resultobj = 0;
23731 int arg1 = (int) wxDateTime::Inv_Year ;
23732 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23733 wxDateTime result;
23734 int val1 ;
23735 int ecode1 = 0 ;
23736 int val2 ;
23737 int ecode2 = 0 ;
23738 PyObject * obj0 = 0 ;
23739 PyObject * obj1 = 0 ;
23740 char * kwnames[] = {
23741 (char *) "year",(char *) "country", NULL
23742 };
23743
23744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23745 if (obj0) {
23746 ecode1 = SWIG_AsVal_int(obj0, &val1);
23747 if (!SWIG_IsOK(ecode1)) {
23748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23749 }
23750 arg1 = static_cast< int >(val1);
23751 }
23752 if (obj1) {
23753 ecode2 = SWIG_AsVal_int(obj1, &val2);
23754 if (!SWIG_IsOK(ecode2)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23756 }
23757 arg2 = static_cast< wxDateTime::Country >(val2);
23758 }
23759 {
23760 PyThreadState* __tstate = wxPyBeginAllowThreads();
23761 result = wxDateTime::GetEndDST(arg1,arg2);
23762 wxPyEndAllowThreads(__tstate);
23763 if (PyErr_Occurred()) SWIG_fail;
23764 }
23765 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23766 return resultobj;
23767 fail:
23768 return NULL;
23769 }
23770
23771
23772 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23773 PyObject *resultobj = 0;
23774 wxDateTime result;
23775
23776 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = wxDateTime::Now();
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23791 PyObject *resultobj = 0;
23792 wxDateTime result;
23793
23794 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 result = wxDateTime::UNow();
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *resultobj = 0;
23810 wxDateTime result;
23811
23812 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23813 {
23814 PyThreadState* __tstate = wxPyBeginAllowThreads();
23815 result = wxDateTime::Today();
23816 wxPyEndAllowThreads(__tstate);
23817 if (PyErr_Occurred()) SWIG_fail;
23818 }
23819 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23827 PyObject *resultobj = 0;
23828 wxDateTime *result = 0 ;
23829
23830 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23831 {
23832 PyThreadState* __tstate = wxPyBeginAllowThreads();
23833 result = (wxDateTime *)new wxDateTime();
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23838 return resultobj;
23839 fail:
23840 return NULL;
23841 }
23842
23843
23844 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23845 PyObject *resultobj = 0;
23846 time_t arg1 ;
23847 wxDateTime *result = 0 ;
23848 unsigned int val1 ;
23849 int ecode1 = 0 ;
23850 PyObject * obj0 = 0 ;
23851 char * kwnames[] = {
23852 (char *) "timet", NULL
23853 };
23854
23855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23856 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23857 if (!SWIG_IsOK(ecode1)) {
23858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23859 }
23860 arg1 = static_cast< time_t >(val1);
23861 {
23862 PyThreadState* __tstate = wxPyBeginAllowThreads();
23863 result = (wxDateTime *)new wxDateTime(arg1);
23864 wxPyEndAllowThreads(__tstate);
23865 if (PyErr_Occurred()) SWIG_fail;
23866 }
23867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23868 return resultobj;
23869 fail:
23870 return NULL;
23871 }
23872
23873
23874 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj = 0;
23876 double arg1 ;
23877 wxDateTime *result = 0 ;
23878 double val1 ;
23879 int ecode1 = 0 ;
23880 PyObject * obj0 = 0 ;
23881 char * kwnames[] = {
23882 (char *) "jdn", NULL
23883 };
23884
23885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23886 ecode1 = SWIG_AsVal_double(obj0, &val1);
23887 if (!SWIG_IsOK(ecode1)) {
23888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23889 }
23890 arg1 = static_cast< double >(val1);
23891 {
23892 PyThreadState* __tstate = wxPyBeginAllowThreads();
23893 result = (wxDateTime *)new wxDateTime(arg1);
23894 wxPyEndAllowThreads(__tstate);
23895 if (PyErr_Occurred()) SWIG_fail;
23896 }
23897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23898 return resultobj;
23899 fail:
23900 return NULL;
23901 }
23902
23903
23904 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23905 PyObject *resultobj = 0;
23906 int arg1 ;
23907 int arg2 = (int) 0 ;
23908 int arg3 = (int) 0 ;
23909 int arg4 = (int) 0 ;
23910 wxDateTime *result = 0 ;
23911 int val1 ;
23912 int ecode1 = 0 ;
23913 int val2 ;
23914 int ecode2 = 0 ;
23915 int val3 ;
23916 int ecode3 = 0 ;
23917 int val4 ;
23918 int ecode4 = 0 ;
23919 PyObject * obj0 = 0 ;
23920 PyObject * obj1 = 0 ;
23921 PyObject * obj2 = 0 ;
23922 PyObject * obj3 = 0 ;
23923 char * kwnames[] = {
23924 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23925 };
23926
23927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23928 ecode1 = SWIG_AsVal_int(obj0, &val1);
23929 if (!SWIG_IsOK(ecode1)) {
23930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23931 }
23932 arg1 = static_cast< int >(val1);
23933 if (obj1) {
23934 ecode2 = SWIG_AsVal_int(obj1, &val2);
23935 if (!SWIG_IsOK(ecode2)) {
23936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23937 }
23938 arg2 = static_cast< int >(val2);
23939 }
23940 if (obj2) {
23941 ecode3 = SWIG_AsVal_int(obj2, &val3);
23942 if (!SWIG_IsOK(ecode3)) {
23943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23944 }
23945 arg3 = static_cast< int >(val3);
23946 }
23947 if (obj3) {
23948 ecode4 = SWIG_AsVal_int(obj3, &val4);
23949 if (!SWIG_IsOK(ecode4)) {
23950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23951 }
23952 arg4 = static_cast< int >(val4);
23953 }
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 int arg1 ;
23970 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23971 int arg3 = (int) wxDateTime::Inv_Year ;
23972 int arg4 = (int) 0 ;
23973 int arg5 = (int) 0 ;
23974 int arg6 = (int) 0 ;
23975 int arg7 = (int) 0 ;
23976 wxDateTime *result = 0 ;
23977 int val1 ;
23978 int ecode1 = 0 ;
23979 int val2 ;
23980 int ecode2 = 0 ;
23981 int val3 ;
23982 int ecode3 = 0 ;
23983 int val4 ;
23984 int ecode4 = 0 ;
23985 int val5 ;
23986 int ecode5 = 0 ;
23987 int val6 ;
23988 int ecode6 = 0 ;
23989 int val7 ;
23990 int ecode7 = 0 ;
23991 PyObject * obj0 = 0 ;
23992 PyObject * obj1 = 0 ;
23993 PyObject * obj2 = 0 ;
23994 PyObject * obj3 = 0 ;
23995 PyObject * obj4 = 0 ;
23996 PyObject * obj5 = 0 ;
23997 PyObject * obj6 = 0 ;
23998 char * kwnames[] = {
23999 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24000 };
24001
24002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24003 ecode1 = SWIG_AsVal_int(obj0, &val1);
24004 if (!SWIG_IsOK(ecode1)) {
24005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24006 }
24007 arg1 = static_cast< int >(val1);
24008 if (obj1) {
24009 ecode2 = SWIG_AsVal_int(obj1, &val2);
24010 if (!SWIG_IsOK(ecode2)) {
24011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24012 }
24013 arg2 = static_cast< wxDateTime::Month >(val2);
24014 }
24015 if (obj2) {
24016 ecode3 = SWIG_AsVal_int(obj2, &val3);
24017 if (!SWIG_IsOK(ecode3)) {
24018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24019 }
24020 arg3 = static_cast< int >(val3);
24021 }
24022 if (obj3) {
24023 ecode4 = SWIG_AsVal_int(obj3, &val4);
24024 if (!SWIG_IsOK(ecode4)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24026 }
24027 arg4 = static_cast< int >(val4);
24028 }
24029 if (obj4) {
24030 ecode5 = SWIG_AsVal_int(obj4, &val5);
24031 if (!SWIG_IsOK(ecode5)) {
24032 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24033 }
24034 arg5 = static_cast< int >(val5);
24035 }
24036 if (obj5) {
24037 ecode6 = SWIG_AsVal_int(obj5, &val6);
24038 if (!SWIG_IsOK(ecode6)) {
24039 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24040 }
24041 arg6 = static_cast< int >(val6);
24042 }
24043 if (obj6) {
24044 ecode7 = SWIG_AsVal_int(obj6, &val7);
24045 if (!SWIG_IsOK(ecode7)) {
24046 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24047 }
24048 arg7 = static_cast< int >(val7);
24049 }
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24064 PyObject *resultobj = 0;
24065 wxDateTime *arg1 = 0 ;
24066 wxDateTime *result = 0 ;
24067 void *argp1 = 0 ;
24068 int res1 = 0 ;
24069 PyObject * obj0 = 0 ;
24070 char * kwnames[] = {
24071 (char *) "date", NULL
24072 };
24073
24074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24075 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24076 if (!SWIG_IsOK(res1)) {
24077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24078 }
24079 if (!argp1) {
24080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24081 }
24082 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24097 PyObject *resultobj = 0;
24098 wxDateTime *arg1 = (wxDateTime *) 0 ;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 PyObject *swig_obj[1] ;
24102
24103 if (!args) SWIG_fail;
24104 swig_obj[0] = args;
24105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24106 if (!SWIG_IsOK(res1)) {
24107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24108 }
24109 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24110 {
24111 PyThreadState* __tstate = wxPyBeginAllowThreads();
24112 delete arg1;
24113
24114 wxPyEndAllowThreads(__tstate);
24115 if (PyErr_Occurred()) SWIG_fail;
24116 }
24117 resultobj = SWIG_Py_Void();
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24125 PyObject *resultobj = 0;
24126 wxDateTime *arg1 = (wxDateTime *) 0 ;
24127 wxDateTime *result = 0 ;
24128 void *argp1 = 0 ;
24129 int res1 = 0 ;
24130 PyObject *swig_obj[1] ;
24131
24132 if (!args) SWIG_fail;
24133 swig_obj[0] = args;
24134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24135 if (!SWIG_IsOK(res1)) {
24136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24137 }
24138 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 {
24142 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24143 result = (wxDateTime *) &_result_ref;
24144 }
24145 wxPyEndAllowThreads(__tstate);
24146 if (PyErr_Occurred()) SWIG_fail;
24147 }
24148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24156 PyObject *resultobj = 0;
24157 wxDateTime *arg1 = (wxDateTime *) 0 ;
24158 time_t arg2 ;
24159 wxDateTime *result = 0 ;
24160 void *argp1 = 0 ;
24161 int res1 = 0 ;
24162 unsigned int val2 ;
24163 int ecode2 = 0 ;
24164 PyObject * obj0 = 0 ;
24165 PyObject * obj1 = 0 ;
24166 char * kwnames[] = {
24167 (char *) "self",(char *) "timet", NULL
24168 };
24169
24170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24172 if (!SWIG_IsOK(res1)) {
24173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24174 }
24175 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24176 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24177 if (!SWIG_IsOK(ecode2)) {
24178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24179 }
24180 arg2 = static_cast< time_t >(val2);
24181 {
24182 PyThreadState* __tstate = wxPyBeginAllowThreads();
24183 {
24184 wxDateTime &_result_ref = (arg1)->Set(arg2);
24185 result = (wxDateTime *) &_result_ref;
24186 }
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj = 0;
24199 wxDateTime *arg1 = (wxDateTime *) 0 ;
24200 double arg2 ;
24201 wxDateTime *result = 0 ;
24202 void *argp1 = 0 ;
24203 int res1 = 0 ;
24204 double val2 ;
24205 int ecode2 = 0 ;
24206 PyObject * obj0 = 0 ;
24207 PyObject * obj1 = 0 ;
24208 char * kwnames[] = {
24209 (char *) "self",(char *) "jdn", NULL
24210 };
24211
24212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24214 if (!SWIG_IsOK(res1)) {
24215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24216 }
24217 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24218 ecode2 = SWIG_AsVal_double(obj1, &val2);
24219 if (!SWIG_IsOK(ecode2)) {
24220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24221 }
24222 arg2 = static_cast< double >(val2);
24223 {
24224 PyThreadState* __tstate = wxPyBeginAllowThreads();
24225 {
24226 wxDateTime &_result_ref = (arg1)->Set(arg2);
24227 result = (wxDateTime *) &_result_ref;
24228 }
24229 wxPyEndAllowThreads(__tstate);
24230 if (PyErr_Occurred()) SWIG_fail;
24231 }
24232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24240 PyObject *resultobj = 0;
24241 wxDateTime *arg1 = (wxDateTime *) 0 ;
24242 int arg2 ;
24243 int arg3 = (int) 0 ;
24244 int arg4 = (int) 0 ;
24245 int arg5 = (int) 0 ;
24246 wxDateTime *result = 0 ;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 int val2 ;
24250 int ecode2 = 0 ;
24251 int val3 ;
24252 int ecode3 = 0 ;
24253 int val4 ;
24254 int ecode4 = 0 ;
24255 int val5 ;
24256 int ecode5 = 0 ;
24257 PyObject * obj0 = 0 ;
24258 PyObject * obj1 = 0 ;
24259 PyObject * obj2 = 0 ;
24260 PyObject * obj3 = 0 ;
24261 PyObject * obj4 = 0 ;
24262 char * kwnames[] = {
24263 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24264 };
24265
24266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24268 if (!SWIG_IsOK(res1)) {
24269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24270 }
24271 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24272 ecode2 = SWIG_AsVal_int(obj1, &val2);
24273 if (!SWIG_IsOK(ecode2)) {
24274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24275 }
24276 arg2 = static_cast< int >(val2);
24277 if (obj2) {
24278 ecode3 = SWIG_AsVal_int(obj2, &val3);
24279 if (!SWIG_IsOK(ecode3)) {
24280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24281 }
24282 arg3 = static_cast< int >(val3);
24283 }
24284 if (obj3) {
24285 ecode4 = SWIG_AsVal_int(obj3, &val4);
24286 if (!SWIG_IsOK(ecode4)) {
24287 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24288 }
24289 arg4 = static_cast< int >(val4);
24290 }
24291 if (obj4) {
24292 ecode5 = SWIG_AsVal_int(obj4, &val5);
24293 if (!SWIG_IsOK(ecode5)) {
24294 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24295 }
24296 arg5 = static_cast< int >(val5);
24297 }
24298 {
24299 PyThreadState* __tstate = wxPyBeginAllowThreads();
24300 {
24301 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24302 result = (wxDateTime *) &_result_ref;
24303 }
24304 wxPyEndAllowThreads(__tstate);
24305 if (PyErr_Occurred()) SWIG_fail;
24306 }
24307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24308 return resultobj;
24309 fail:
24310 return NULL;
24311 }
24312
24313
24314 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24315 PyObject *resultobj = 0;
24316 wxDateTime *arg1 = (wxDateTime *) 0 ;
24317 int arg2 ;
24318 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24319 int arg4 = (int) wxDateTime::Inv_Year ;
24320 int arg5 = (int) 0 ;
24321 int arg6 = (int) 0 ;
24322 int arg7 = (int) 0 ;
24323 int arg8 = (int) 0 ;
24324 wxDateTime *result = 0 ;
24325 void *argp1 = 0 ;
24326 int res1 = 0 ;
24327 int val2 ;
24328 int ecode2 = 0 ;
24329 int val3 ;
24330 int ecode3 = 0 ;
24331 int val4 ;
24332 int ecode4 = 0 ;
24333 int val5 ;
24334 int ecode5 = 0 ;
24335 int val6 ;
24336 int ecode6 = 0 ;
24337 int val7 ;
24338 int ecode7 = 0 ;
24339 int val8 ;
24340 int ecode8 = 0 ;
24341 PyObject * obj0 = 0 ;
24342 PyObject * obj1 = 0 ;
24343 PyObject * obj2 = 0 ;
24344 PyObject * obj3 = 0 ;
24345 PyObject * obj4 = 0 ;
24346 PyObject * obj5 = 0 ;
24347 PyObject * obj6 = 0 ;
24348 PyObject * obj7 = 0 ;
24349 char * kwnames[] = {
24350 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24351 };
24352
24353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24355 if (!SWIG_IsOK(res1)) {
24356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24357 }
24358 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24359 ecode2 = SWIG_AsVal_int(obj1, &val2);
24360 if (!SWIG_IsOK(ecode2)) {
24361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24362 }
24363 arg2 = static_cast< int >(val2);
24364 if (obj2) {
24365 ecode3 = SWIG_AsVal_int(obj2, &val3);
24366 if (!SWIG_IsOK(ecode3)) {
24367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24368 }
24369 arg3 = static_cast< wxDateTime::Month >(val3);
24370 }
24371 if (obj3) {
24372 ecode4 = SWIG_AsVal_int(obj3, &val4);
24373 if (!SWIG_IsOK(ecode4)) {
24374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24375 }
24376 arg4 = static_cast< int >(val4);
24377 }
24378 if (obj4) {
24379 ecode5 = SWIG_AsVal_int(obj4, &val5);
24380 if (!SWIG_IsOK(ecode5)) {
24381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24382 }
24383 arg5 = static_cast< int >(val5);
24384 }
24385 if (obj5) {
24386 ecode6 = SWIG_AsVal_int(obj5, &val6);
24387 if (!SWIG_IsOK(ecode6)) {
24388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24389 }
24390 arg6 = static_cast< int >(val6);
24391 }
24392 if (obj6) {
24393 ecode7 = SWIG_AsVal_int(obj6, &val7);
24394 if (!SWIG_IsOK(ecode7)) {
24395 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24396 }
24397 arg7 = static_cast< int >(val7);
24398 }
24399 if (obj7) {
24400 ecode8 = SWIG_AsVal_int(obj7, &val8);
24401 if (!SWIG_IsOK(ecode8)) {
24402 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24403 }
24404 arg8 = static_cast< int >(val8);
24405 }
24406 {
24407 PyThreadState* __tstate = wxPyBeginAllowThreads();
24408 {
24409 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24410 result = (wxDateTime *) &_result_ref;
24411 }
24412 wxPyEndAllowThreads(__tstate);
24413 if (PyErr_Occurred()) SWIG_fail;
24414 }
24415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24416 return resultobj;
24417 fail:
24418 return NULL;
24419 }
24420
24421
24422 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24423 PyObject *resultobj = 0;
24424 wxDateTime *arg1 = (wxDateTime *) 0 ;
24425 wxDateTime *result = 0 ;
24426 void *argp1 = 0 ;
24427 int res1 = 0 ;
24428 PyObject *swig_obj[1] ;
24429
24430 if (!args) SWIG_fail;
24431 swig_obj[0] = args;
24432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24433 if (!SWIG_IsOK(res1)) {
24434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24435 }
24436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24437 {
24438 PyThreadState* __tstate = wxPyBeginAllowThreads();
24439 {
24440 wxDateTime &_result_ref = (arg1)->ResetTime();
24441 result = (wxDateTime *) &_result_ref;
24442 }
24443 wxPyEndAllowThreads(__tstate);
24444 if (PyErr_Occurred()) SWIG_fail;
24445 }
24446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24447 return resultobj;
24448 fail:
24449 return NULL;
24450 }
24451
24452
24453 SWIGINTERN PyObject *_wrap_DateTime_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24454 PyObject *resultobj = 0;
24455 wxDateTime *arg1 = (wxDateTime *) 0 ;
24456 wxDateTime result;
24457 void *argp1 = 0 ;
24458 int res1 = 0 ;
24459 PyObject *swig_obj[1] ;
24460
24461 if (!args) SWIG_fail;
24462 swig_obj[0] = args;
24463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24464 if (!SWIG_IsOK(res1)) {
24465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24466 }
24467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24468 {
24469 PyThreadState* __tstate = wxPyBeginAllowThreads();
24470 result = ((wxDateTime const *)arg1)->GetDateOnly();
24471 wxPyEndAllowThreads(__tstate);
24472 if (PyErr_Occurred()) SWIG_fail;
24473 }
24474 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24475 return resultobj;
24476 fail:
24477 return NULL;
24478 }
24479
24480
24481 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj = 0;
24483 wxDateTime *arg1 = (wxDateTime *) 0 ;
24484 int arg2 ;
24485 wxDateTime *result = 0 ;
24486 void *argp1 = 0 ;
24487 int res1 = 0 ;
24488 int val2 ;
24489 int ecode2 = 0 ;
24490 PyObject * obj0 = 0 ;
24491 PyObject * obj1 = 0 ;
24492 char * kwnames[] = {
24493 (char *) "self",(char *) "year", NULL
24494 };
24495
24496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24498 if (!SWIG_IsOK(res1)) {
24499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24500 }
24501 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24502 ecode2 = SWIG_AsVal_int(obj1, &val2);
24503 if (!SWIG_IsOK(ecode2)) {
24504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24505 }
24506 arg2 = static_cast< int >(val2);
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 {
24510 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24511 result = (wxDateTime *) &_result_ref;
24512 }
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj = 0;
24525 wxDateTime *arg1 = (wxDateTime *) 0 ;
24526 wxDateTime::Month arg2 ;
24527 wxDateTime *result = 0 ;
24528 void *argp1 = 0 ;
24529 int res1 = 0 ;
24530 int val2 ;
24531 int ecode2 = 0 ;
24532 PyObject * obj0 = 0 ;
24533 PyObject * obj1 = 0 ;
24534 char * kwnames[] = {
24535 (char *) "self",(char *) "month", NULL
24536 };
24537
24538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24540 if (!SWIG_IsOK(res1)) {
24541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24542 }
24543 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24544 ecode2 = SWIG_AsVal_int(obj1, &val2);
24545 if (!SWIG_IsOK(ecode2)) {
24546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24547 }
24548 arg2 = static_cast< wxDateTime::Month >(val2);
24549 {
24550 PyThreadState* __tstate = wxPyBeginAllowThreads();
24551 {
24552 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24553 result = (wxDateTime *) &_result_ref;
24554 }
24555 wxPyEndAllowThreads(__tstate);
24556 if (PyErr_Occurred()) SWIG_fail;
24557 }
24558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24559 return resultobj;
24560 fail:
24561 return NULL;
24562 }
24563
24564
24565 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24566 PyObject *resultobj = 0;
24567 wxDateTime *arg1 = (wxDateTime *) 0 ;
24568 int arg2 ;
24569 wxDateTime *result = 0 ;
24570 void *argp1 = 0 ;
24571 int res1 = 0 ;
24572 int val2 ;
24573 int ecode2 = 0 ;
24574 PyObject * obj0 = 0 ;
24575 PyObject * obj1 = 0 ;
24576 char * kwnames[] = {
24577 (char *) "self",(char *) "day", NULL
24578 };
24579
24580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24582 if (!SWIG_IsOK(res1)) {
24583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24584 }
24585 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24586 ecode2 = SWIG_AsVal_int(obj1, &val2);
24587 if (!SWIG_IsOK(ecode2)) {
24588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24589 }
24590 arg2 = static_cast< int >(val2);
24591 {
24592 PyThreadState* __tstate = wxPyBeginAllowThreads();
24593 {
24594 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24595 result = (wxDateTime *) &_result_ref;
24596 }
24597 wxPyEndAllowThreads(__tstate);
24598 if (PyErr_Occurred()) SWIG_fail;
24599 }
24600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24601 return resultobj;
24602 fail:
24603 return NULL;
24604 }
24605
24606
24607 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24608 PyObject *resultobj = 0;
24609 wxDateTime *arg1 = (wxDateTime *) 0 ;
24610 int arg2 ;
24611 wxDateTime *result = 0 ;
24612 void *argp1 = 0 ;
24613 int res1 = 0 ;
24614 int val2 ;
24615 int ecode2 = 0 ;
24616 PyObject * obj0 = 0 ;
24617 PyObject * obj1 = 0 ;
24618 char * kwnames[] = {
24619 (char *) "self",(char *) "hour", NULL
24620 };
24621
24622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24624 if (!SWIG_IsOK(res1)) {
24625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24626 }
24627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24628 ecode2 = SWIG_AsVal_int(obj1, &val2);
24629 if (!SWIG_IsOK(ecode2)) {
24630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24631 }
24632 arg2 = static_cast< int >(val2);
24633 {
24634 PyThreadState* __tstate = wxPyBeginAllowThreads();
24635 {
24636 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24637 result = (wxDateTime *) &_result_ref;
24638 }
24639 wxPyEndAllowThreads(__tstate);
24640 if (PyErr_Occurred()) SWIG_fail;
24641 }
24642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24643 return resultobj;
24644 fail:
24645 return NULL;
24646 }
24647
24648
24649 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24650 PyObject *resultobj = 0;
24651 wxDateTime *arg1 = (wxDateTime *) 0 ;
24652 int arg2 ;
24653 wxDateTime *result = 0 ;
24654 void *argp1 = 0 ;
24655 int res1 = 0 ;
24656 int val2 ;
24657 int ecode2 = 0 ;
24658 PyObject * obj0 = 0 ;
24659 PyObject * obj1 = 0 ;
24660 char * kwnames[] = {
24661 (char *) "self",(char *) "minute", NULL
24662 };
24663
24664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24666 if (!SWIG_IsOK(res1)) {
24667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24668 }
24669 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24670 ecode2 = SWIG_AsVal_int(obj1, &val2);
24671 if (!SWIG_IsOK(ecode2)) {
24672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24673 }
24674 arg2 = static_cast< int >(val2);
24675 {
24676 PyThreadState* __tstate = wxPyBeginAllowThreads();
24677 {
24678 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24679 result = (wxDateTime *) &_result_ref;
24680 }
24681 wxPyEndAllowThreads(__tstate);
24682 if (PyErr_Occurred()) SWIG_fail;
24683 }
24684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24685 return resultobj;
24686 fail:
24687 return NULL;
24688 }
24689
24690
24691 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24692 PyObject *resultobj = 0;
24693 wxDateTime *arg1 = (wxDateTime *) 0 ;
24694 int arg2 ;
24695 wxDateTime *result = 0 ;
24696 void *argp1 = 0 ;
24697 int res1 = 0 ;
24698 int val2 ;
24699 int ecode2 = 0 ;
24700 PyObject * obj0 = 0 ;
24701 PyObject * obj1 = 0 ;
24702 char * kwnames[] = {
24703 (char *) "self",(char *) "second", NULL
24704 };
24705
24706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24708 if (!SWIG_IsOK(res1)) {
24709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24710 }
24711 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24712 ecode2 = SWIG_AsVal_int(obj1, &val2);
24713 if (!SWIG_IsOK(ecode2)) {
24714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24715 }
24716 arg2 = static_cast< int >(val2);
24717 {
24718 PyThreadState* __tstate = wxPyBeginAllowThreads();
24719 {
24720 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24721 result = (wxDateTime *) &_result_ref;
24722 }
24723 wxPyEndAllowThreads(__tstate);
24724 if (PyErr_Occurred()) SWIG_fail;
24725 }
24726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24727 return resultobj;
24728 fail:
24729 return NULL;
24730 }
24731
24732
24733 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24734 PyObject *resultobj = 0;
24735 wxDateTime *arg1 = (wxDateTime *) 0 ;
24736 int arg2 ;
24737 wxDateTime *result = 0 ;
24738 void *argp1 = 0 ;
24739 int res1 = 0 ;
24740 int val2 ;
24741 int ecode2 = 0 ;
24742 PyObject * obj0 = 0 ;
24743 PyObject * obj1 = 0 ;
24744 char * kwnames[] = {
24745 (char *) "self",(char *) "millisecond", NULL
24746 };
24747
24748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24752 }
24753 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24754 ecode2 = SWIG_AsVal_int(obj1, &val2);
24755 if (!SWIG_IsOK(ecode2)) {
24756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24757 }
24758 arg2 = static_cast< int >(val2);
24759 {
24760 PyThreadState* __tstate = wxPyBeginAllowThreads();
24761 {
24762 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24763 result = (wxDateTime *) &_result_ref;
24764 }
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj = 0;
24777 wxDateTime *arg1 = (wxDateTime *) 0 ;
24778 wxDateTime::WeekDay arg2 ;
24779 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24780 wxDateTime *result = 0 ;
24781 void *argp1 = 0 ;
24782 int res1 = 0 ;
24783 int val2 ;
24784 int ecode2 = 0 ;
24785 int val3 ;
24786 int ecode3 = 0 ;
24787 PyObject * obj0 = 0 ;
24788 PyObject * obj1 = 0 ;
24789 PyObject * obj2 = 0 ;
24790 char * kwnames[] = {
24791 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24792 };
24793
24794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24796 if (!SWIG_IsOK(res1)) {
24797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24798 }
24799 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24800 ecode2 = SWIG_AsVal_int(obj1, &val2);
24801 if (!SWIG_IsOK(ecode2)) {
24802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24803 }
24804 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24805 if (obj2) {
24806 ecode3 = SWIG_AsVal_int(obj2, &val3);
24807 if (!SWIG_IsOK(ecode3)) {
24808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24809 }
24810 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24811 }
24812 {
24813 PyThreadState* __tstate = wxPyBeginAllowThreads();
24814 {
24815 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24816 result = (wxDateTime *) &_result_ref;
24817 }
24818 wxPyEndAllowThreads(__tstate);
24819 if (PyErr_Occurred()) SWIG_fail;
24820 }
24821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24822 return resultobj;
24823 fail:
24824 return NULL;
24825 }
24826
24827
24828 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24829 PyObject *resultobj = 0;
24830 wxDateTime *arg1 = (wxDateTime *) 0 ;
24831 wxDateTime::WeekDay arg2 ;
24832 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24833 wxDateTime result;
24834 void *argp1 = 0 ;
24835 int res1 = 0 ;
24836 int val2 ;
24837 int ecode2 = 0 ;
24838 int val3 ;
24839 int ecode3 = 0 ;
24840 PyObject * obj0 = 0 ;
24841 PyObject * obj1 = 0 ;
24842 PyObject * obj2 = 0 ;
24843 char * kwnames[] = {
24844 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24845 };
24846
24847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24849 if (!SWIG_IsOK(res1)) {
24850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24851 }
24852 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24853 ecode2 = SWIG_AsVal_int(obj1, &val2);
24854 if (!SWIG_IsOK(ecode2)) {
24855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24856 }
24857 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24858 if (obj2) {
24859 ecode3 = SWIG_AsVal_int(obj2, &val3);
24860 if (!SWIG_IsOK(ecode3)) {
24861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24862 }
24863 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24864 }
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj = 0;
24880 wxDateTime *arg1 = (wxDateTime *) 0 ;
24881 wxDateTime::WeekDay 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 *) "weekday", NULL
24891 };
24892
24893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",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_SetToNextWeekDay" "', 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_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24902 }
24903 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 {
24907 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(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_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj = 0;
24922 wxDateTime *arg1 = (wxDateTime *) 0 ;
24923 wxDateTime::WeekDay arg2 ;
24924 wxDateTime result;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 int val2 ;
24928 int ecode2 = 0 ;
24929 PyObject * obj0 = 0 ;
24930 PyObject * obj1 = 0 ;
24931 char * kwnames[] = {
24932 (char *) "self",(char *) "weekday", NULL
24933 };
24934
24935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24937 if (!SWIG_IsOK(res1)) {
24938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24939 }
24940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24941 ecode2 = SWIG_AsVal_int(obj1, &val2);
24942 if (!SWIG_IsOK(ecode2)) {
24943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24944 }
24945 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24946 {
24947 PyThreadState* __tstate = wxPyBeginAllowThreads();
24948 result = (arg1)->GetNextWeekDay(arg2);
24949 wxPyEndAllowThreads(__tstate);
24950 if (PyErr_Occurred()) SWIG_fail;
24951 }
24952 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24953 return resultobj;
24954 fail:
24955 return NULL;
24956 }
24957
24958
24959 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24960 PyObject *resultobj = 0;
24961 wxDateTime *arg1 = (wxDateTime *) 0 ;
24962 wxDateTime::WeekDay arg2 ;
24963 wxDateTime *result = 0 ;
24964 void *argp1 = 0 ;
24965 int res1 = 0 ;
24966 int val2 ;
24967 int ecode2 = 0 ;
24968 PyObject * obj0 = 0 ;
24969 PyObject * obj1 = 0 ;
24970 char * kwnames[] = {
24971 (char *) "self",(char *) "weekday", NULL
24972 };
24973
24974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24976 if (!SWIG_IsOK(res1)) {
24977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24978 }
24979 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24980 ecode2 = SWIG_AsVal_int(obj1, &val2);
24981 if (!SWIG_IsOK(ecode2)) {
24982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24983 }
24984 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 {
24988 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24989 result = (wxDateTime *) &_result_ref;
24990 }
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj = 0;
25003 wxDateTime *arg1 = (wxDateTime *) 0 ;
25004 wxDateTime::WeekDay arg2 ;
25005 wxDateTime result;
25006 void *argp1 = 0 ;
25007 int res1 = 0 ;
25008 int val2 ;
25009 int ecode2 = 0 ;
25010 PyObject * obj0 = 0 ;
25011 PyObject * obj1 = 0 ;
25012 char * kwnames[] = {
25013 (char *) "self",(char *) "weekday", NULL
25014 };
25015
25016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25018 if (!SWIG_IsOK(res1)) {
25019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25020 }
25021 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25022 ecode2 = SWIG_AsVal_int(obj1, &val2);
25023 if (!SWIG_IsOK(ecode2)) {
25024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25025 }
25026 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = (arg1)->GetPrevWeekDay(arg2);
25030 wxPyEndAllowThreads(__tstate);
25031 if (PyErr_Occurred()) SWIG_fail;
25032 }
25033 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25041 PyObject *resultobj = 0;
25042 wxDateTime *arg1 = (wxDateTime *) 0 ;
25043 wxDateTime::WeekDay arg2 ;
25044 int arg3 = (int) 1 ;
25045 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25046 int arg5 = (int) wxDateTime::Inv_Year ;
25047 bool result;
25048 void *argp1 = 0 ;
25049 int res1 = 0 ;
25050 int val2 ;
25051 int ecode2 = 0 ;
25052 int val3 ;
25053 int ecode3 = 0 ;
25054 int val4 ;
25055 int ecode4 = 0 ;
25056 int val5 ;
25057 int ecode5 = 0 ;
25058 PyObject * obj0 = 0 ;
25059 PyObject * obj1 = 0 ;
25060 PyObject * obj2 = 0 ;
25061 PyObject * obj3 = 0 ;
25062 PyObject * obj4 = 0 ;
25063 char * kwnames[] = {
25064 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25065 };
25066
25067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25069 if (!SWIG_IsOK(res1)) {
25070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25071 }
25072 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25073 ecode2 = SWIG_AsVal_int(obj1, &val2);
25074 if (!SWIG_IsOK(ecode2)) {
25075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25076 }
25077 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25078 if (obj2) {
25079 ecode3 = SWIG_AsVal_int(obj2, &val3);
25080 if (!SWIG_IsOK(ecode3)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25082 }
25083 arg3 = static_cast< int >(val3);
25084 }
25085 if (obj3) {
25086 ecode4 = SWIG_AsVal_int(obj3, &val4);
25087 if (!SWIG_IsOK(ecode4)) {
25088 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25089 }
25090 arg4 = static_cast< wxDateTime::Month >(val4);
25091 }
25092 if (obj4) {
25093 ecode5 = SWIG_AsVal_int(obj4, &val5);
25094 if (!SWIG_IsOK(ecode5)) {
25095 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25096 }
25097 arg5 = static_cast< int >(val5);
25098 }
25099 {
25100 PyThreadState* __tstate = wxPyBeginAllowThreads();
25101 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 {
25106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25107 }
25108 return resultobj;
25109 fail:
25110 return NULL;
25111 }
25112
25113
25114 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj = 0;
25116 wxDateTime *arg1 = (wxDateTime *) 0 ;
25117 wxDateTime::WeekDay arg2 ;
25118 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25119 int arg4 = (int) wxDateTime::Inv_Year ;
25120 bool result;
25121 void *argp1 = 0 ;
25122 int res1 = 0 ;
25123 int val2 ;
25124 int ecode2 = 0 ;
25125 int val3 ;
25126 int ecode3 = 0 ;
25127 int val4 ;
25128 int ecode4 = 0 ;
25129 PyObject * obj0 = 0 ;
25130 PyObject * obj1 = 0 ;
25131 PyObject * obj2 = 0 ;
25132 PyObject * obj3 = 0 ;
25133 char * kwnames[] = {
25134 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25135 };
25136
25137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25139 if (!SWIG_IsOK(res1)) {
25140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25141 }
25142 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25143 ecode2 = SWIG_AsVal_int(obj1, &val2);
25144 if (!SWIG_IsOK(ecode2)) {
25145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25146 }
25147 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25148 if (obj2) {
25149 ecode3 = SWIG_AsVal_int(obj2, &val3);
25150 if (!SWIG_IsOK(ecode3)) {
25151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25152 }
25153 arg3 = static_cast< wxDateTime::Month >(val3);
25154 }
25155 if (obj3) {
25156 ecode4 = SWIG_AsVal_int(obj3, &val4);
25157 if (!SWIG_IsOK(ecode4)) {
25158 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25159 }
25160 arg4 = static_cast< int >(val4);
25161 }
25162 {
25163 PyThreadState* __tstate = wxPyBeginAllowThreads();
25164 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25165 wxPyEndAllowThreads(__tstate);
25166 if (PyErr_Occurred()) SWIG_fail;
25167 }
25168 {
25169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25170 }
25171 return resultobj;
25172 fail:
25173 return NULL;
25174 }
25175
25176
25177 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25178 PyObject *resultobj = 0;
25179 wxDateTime *arg1 = (wxDateTime *) 0 ;
25180 wxDateTime::WeekDay arg2 ;
25181 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25182 int arg4 = (int) wxDateTime::Inv_Year ;
25183 wxDateTime result;
25184 void *argp1 = 0 ;
25185 int res1 = 0 ;
25186 int val2 ;
25187 int ecode2 = 0 ;
25188 int val3 ;
25189 int ecode3 = 0 ;
25190 int val4 ;
25191 int ecode4 = 0 ;
25192 PyObject * obj0 = 0 ;
25193 PyObject * obj1 = 0 ;
25194 PyObject * obj2 = 0 ;
25195 PyObject * obj3 = 0 ;
25196 char * kwnames[] = {
25197 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25198 };
25199
25200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25202 if (!SWIG_IsOK(res1)) {
25203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25204 }
25205 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25206 ecode2 = SWIG_AsVal_int(obj1, &val2);
25207 if (!SWIG_IsOK(ecode2)) {
25208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25209 }
25210 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25211 if (obj2) {
25212 ecode3 = SWIG_AsVal_int(obj2, &val3);
25213 if (!SWIG_IsOK(ecode3)) {
25214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25215 }
25216 arg3 = static_cast< wxDateTime::Month >(val3);
25217 }
25218 if (obj3) {
25219 ecode4 = SWIG_AsVal_int(obj3, &val4);
25220 if (!SWIG_IsOK(ecode4)) {
25221 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25222 }
25223 arg4 = static_cast< int >(val4);
25224 }
25225 {
25226 PyThreadState* __tstate = wxPyBeginAllowThreads();
25227 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25232 return resultobj;
25233 fail:
25234 return NULL;
25235 }
25236
25237
25238 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25239 PyObject *resultobj = 0;
25240 wxDateTime *arg1 = (wxDateTime *) 0 ;
25241 int arg2 ;
25242 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25243 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25244 bool result;
25245 void *argp1 = 0 ;
25246 int res1 = 0 ;
25247 int val2 ;
25248 int ecode2 = 0 ;
25249 int val3 ;
25250 int ecode3 = 0 ;
25251 int val4 ;
25252 int ecode4 = 0 ;
25253 PyObject * obj0 = 0 ;
25254 PyObject * obj1 = 0 ;
25255 PyObject * obj2 = 0 ;
25256 PyObject * obj3 = 0 ;
25257 char * kwnames[] = {
25258 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25259 };
25260
25261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25263 if (!SWIG_IsOK(res1)) {
25264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25265 }
25266 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25267 ecode2 = SWIG_AsVal_int(obj1, &val2);
25268 if (!SWIG_IsOK(ecode2)) {
25269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25270 }
25271 arg2 = static_cast< int >(val2);
25272 if (obj2) {
25273 ecode3 = SWIG_AsVal_int(obj2, &val3);
25274 if (!SWIG_IsOK(ecode3)) {
25275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25276 }
25277 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25278 }
25279 if (obj3) {
25280 ecode4 = SWIG_AsVal_int(obj3, &val4);
25281 if (!SWIG_IsOK(ecode4)) {
25282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25283 }
25284 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25285 }
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25289 wxPyEndAllowThreads(__tstate);
25290 if (PyErr_Occurred()) SWIG_fail;
25291 }
25292 {
25293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25294 }
25295 return resultobj;
25296 fail:
25297 return NULL;
25298 }
25299
25300
25301 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25302 PyObject *resultobj = 0;
25303 wxDateTime *arg1 = (wxDateTime *) 0 ;
25304 int arg2 ;
25305 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25306 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25307 wxDateTime result;
25308 void *argp1 = 0 ;
25309 int res1 = 0 ;
25310 int val2 ;
25311 int ecode2 = 0 ;
25312 int val3 ;
25313 int ecode3 = 0 ;
25314 int val4 ;
25315 int ecode4 = 0 ;
25316 PyObject * obj0 = 0 ;
25317 PyObject * obj1 = 0 ;
25318 PyObject * obj2 = 0 ;
25319 PyObject * obj3 = 0 ;
25320 char * kwnames[] = {
25321 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25322 };
25323
25324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25326 if (!SWIG_IsOK(res1)) {
25327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25328 }
25329 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25330 ecode2 = SWIG_AsVal_int(obj1, &val2);
25331 if (!SWIG_IsOK(ecode2)) {
25332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25333 }
25334 arg2 = static_cast< int >(val2);
25335 if (obj2) {
25336 ecode3 = SWIG_AsVal_int(obj2, &val3);
25337 if (!SWIG_IsOK(ecode3)) {
25338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25339 }
25340 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25341 }
25342 if (obj3) {
25343 ecode4 = SWIG_AsVal_int(obj3, &val4);
25344 if (!SWIG_IsOK(ecode4)) {
25345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25346 }
25347 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25348 }
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 result = (arg1)->GetWeek(arg2,arg3,arg4);
25352 wxPyEndAllowThreads(__tstate);
25353 if (PyErr_Occurred()) SWIG_fail;
25354 }
25355 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25356 return resultobj;
25357 fail:
25358 return NULL;
25359 }
25360
25361
25362 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25363 PyObject *resultobj = 0;
25364 int arg1 ;
25365 int arg2 ;
25366 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25367 wxDateTime result;
25368 int val1 ;
25369 int ecode1 = 0 ;
25370 int val2 ;
25371 int ecode2 = 0 ;
25372 int val3 ;
25373 int ecode3 = 0 ;
25374 PyObject * obj0 = 0 ;
25375 PyObject * obj1 = 0 ;
25376 PyObject * obj2 = 0 ;
25377 char * kwnames[] = {
25378 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25379 };
25380
25381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25382 ecode1 = SWIG_AsVal_int(obj0, &val1);
25383 if (!SWIG_IsOK(ecode1)) {
25384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25385 }
25386 arg1 = static_cast< int >(val1);
25387 ecode2 = SWIG_AsVal_int(obj1, &val2);
25388 if (!SWIG_IsOK(ecode2)) {
25389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25390 }
25391 arg2 = static_cast< int >(val2);
25392 if (obj2) {
25393 ecode3 = SWIG_AsVal_int(obj2, &val3);
25394 if (!SWIG_IsOK(ecode3)) {
25395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25396 }
25397 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25398 }
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25402 wxPyEndAllowThreads(__tstate);
25403 if (PyErr_Occurred()) SWIG_fail;
25404 }
25405 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25406 return resultobj;
25407 fail:
25408 return NULL;
25409 }
25410
25411
25412 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25413 PyObject *resultobj = 0;
25414 wxDateTime *arg1 = (wxDateTime *) 0 ;
25415 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25416 int arg3 = (int) wxDateTime::Inv_Year ;
25417 wxDateTime *result = 0 ;
25418 void *argp1 = 0 ;
25419 int res1 = 0 ;
25420 int val2 ;
25421 int ecode2 = 0 ;
25422 int val3 ;
25423 int ecode3 = 0 ;
25424 PyObject * obj0 = 0 ;
25425 PyObject * obj1 = 0 ;
25426 PyObject * obj2 = 0 ;
25427 char * kwnames[] = {
25428 (char *) "self",(char *) "month",(char *) "year", NULL
25429 };
25430
25431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25433 if (!SWIG_IsOK(res1)) {
25434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25435 }
25436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25437 if (obj1) {
25438 ecode2 = SWIG_AsVal_int(obj1, &val2);
25439 if (!SWIG_IsOK(ecode2)) {
25440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25441 }
25442 arg2 = static_cast< wxDateTime::Month >(val2);
25443 }
25444 if (obj2) {
25445 ecode3 = SWIG_AsVal_int(obj2, &val3);
25446 if (!SWIG_IsOK(ecode3)) {
25447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25448 }
25449 arg3 = static_cast< int >(val3);
25450 }
25451 {
25452 PyThreadState* __tstate = wxPyBeginAllowThreads();
25453 {
25454 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25455 result = (wxDateTime *) &_result_ref;
25456 }
25457 wxPyEndAllowThreads(__tstate);
25458 if (PyErr_Occurred()) SWIG_fail;
25459 }
25460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25461 return resultobj;
25462 fail:
25463 return NULL;
25464 }
25465
25466
25467 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25468 PyObject *resultobj = 0;
25469 wxDateTime *arg1 = (wxDateTime *) 0 ;
25470 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25471 int arg3 = (int) wxDateTime::Inv_Year ;
25472 wxDateTime result;
25473 void *argp1 = 0 ;
25474 int res1 = 0 ;
25475 int val2 ;
25476 int ecode2 = 0 ;
25477 int val3 ;
25478 int ecode3 = 0 ;
25479 PyObject * obj0 = 0 ;
25480 PyObject * obj1 = 0 ;
25481 PyObject * obj2 = 0 ;
25482 char * kwnames[] = {
25483 (char *) "self",(char *) "month",(char *) "year", NULL
25484 };
25485
25486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25488 if (!SWIG_IsOK(res1)) {
25489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25490 }
25491 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25492 if (obj1) {
25493 ecode2 = SWIG_AsVal_int(obj1, &val2);
25494 if (!SWIG_IsOK(ecode2)) {
25495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25496 }
25497 arg2 = static_cast< wxDateTime::Month >(val2);
25498 }
25499 if (obj2) {
25500 ecode3 = SWIG_AsVal_int(obj2, &val3);
25501 if (!SWIG_IsOK(ecode3)) {
25502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25503 }
25504 arg3 = static_cast< int >(val3);
25505 }
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 result = (arg1)->GetLastMonthDay(arg2,arg3);
25509 wxPyEndAllowThreads(__tstate);
25510 if (PyErr_Occurred()) SWIG_fail;
25511 }
25512 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25513 return resultobj;
25514 fail:
25515 return NULL;
25516 }
25517
25518
25519 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25520 PyObject *resultobj = 0;
25521 wxDateTime *arg1 = (wxDateTime *) 0 ;
25522 int arg2 ;
25523 wxDateTime *result = 0 ;
25524 void *argp1 = 0 ;
25525 int res1 = 0 ;
25526 int val2 ;
25527 int ecode2 = 0 ;
25528 PyObject * obj0 = 0 ;
25529 PyObject * obj1 = 0 ;
25530 char * kwnames[] = {
25531 (char *) "self",(char *) "yday", NULL
25532 };
25533
25534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25536 if (!SWIG_IsOK(res1)) {
25537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25538 }
25539 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25540 ecode2 = SWIG_AsVal_int(obj1, &val2);
25541 if (!SWIG_IsOK(ecode2)) {
25542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25543 }
25544 arg2 = static_cast< int >(val2);
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 {
25548 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25549 result = (wxDateTime *) &_result_ref;
25550 }
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25562 PyObject *resultobj = 0;
25563 wxDateTime *arg1 = (wxDateTime *) 0 ;
25564 int arg2 ;
25565 wxDateTime result;
25566 void *argp1 = 0 ;
25567 int res1 = 0 ;
25568 int val2 ;
25569 int ecode2 = 0 ;
25570 PyObject * obj0 = 0 ;
25571 PyObject * obj1 = 0 ;
25572 char * kwnames[] = {
25573 (char *) "self",(char *) "yday", NULL
25574 };
25575
25576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25578 if (!SWIG_IsOK(res1)) {
25579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25580 }
25581 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25582 ecode2 = SWIG_AsVal_int(obj1, &val2);
25583 if (!SWIG_IsOK(ecode2)) {
25584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25585 }
25586 arg2 = static_cast< int >(val2);
25587 {
25588 PyThreadState* __tstate = wxPyBeginAllowThreads();
25589 result = (arg1)->GetYearDay(arg2);
25590 wxPyEndAllowThreads(__tstate);
25591 if (PyErr_Occurred()) SWIG_fail;
25592 }
25593 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25594 return resultobj;
25595 fail:
25596 return NULL;
25597 }
25598
25599
25600 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25601 PyObject *resultobj = 0;
25602 wxDateTime *arg1 = (wxDateTime *) 0 ;
25603 double result;
25604 void *argp1 = 0 ;
25605 int res1 = 0 ;
25606 PyObject *swig_obj[1] ;
25607
25608 if (!args) SWIG_fail;
25609 swig_obj[0] = args;
25610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25611 if (!SWIG_IsOK(res1)) {
25612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25613 }
25614 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 result = (double)(arg1)->GetJulianDayNumber();
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 resultobj = SWIG_From_double(static_cast< double >(result));
25622 return resultobj;
25623 fail:
25624 return NULL;
25625 }
25626
25627
25628 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629 PyObject *resultobj = 0;
25630 wxDateTime *arg1 = (wxDateTime *) 0 ;
25631 double result;
25632 void *argp1 = 0 ;
25633 int res1 = 0 ;
25634 PyObject *swig_obj[1] ;
25635
25636 if (!args) SWIG_fail;
25637 swig_obj[0] = args;
25638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25639 if (!SWIG_IsOK(res1)) {
25640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25641 }
25642 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = (double)(arg1)->GetJDN();
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 resultobj = SWIG_From_double(static_cast< double >(result));
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25657 PyObject *resultobj = 0;
25658 wxDateTime *arg1 = (wxDateTime *) 0 ;
25659 double result;
25660 void *argp1 = 0 ;
25661 int res1 = 0 ;
25662 PyObject *swig_obj[1] ;
25663
25664 if (!args) SWIG_fail;
25665 swig_obj[0] = args;
25666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25667 if (!SWIG_IsOK(res1)) {
25668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25669 }
25670 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25671 {
25672 PyThreadState* __tstate = wxPyBeginAllowThreads();
25673 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 resultobj = SWIG_From_double(static_cast< double >(result));
25678 return resultobj;
25679 fail:
25680 return NULL;
25681 }
25682
25683
25684 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25685 PyObject *resultobj = 0;
25686 wxDateTime *arg1 = (wxDateTime *) 0 ;
25687 double result;
25688 void *argp1 = 0 ;
25689 int res1 = 0 ;
25690 PyObject *swig_obj[1] ;
25691
25692 if (!args) SWIG_fail;
25693 swig_obj[0] = args;
25694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25695 if (!SWIG_IsOK(res1)) {
25696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25697 }
25698 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25699 {
25700 PyThreadState* __tstate = wxPyBeginAllowThreads();
25701 result = (double)(arg1)->GetMJD();
25702 wxPyEndAllowThreads(__tstate);
25703 if (PyErr_Occurred()) SWIG_fail;
25704 }
25705 resultobj = SWIG_From_double(static_cast< double >(result));
25706 return resultobj;
25707 fail:
25708 return NULL;
25709 }
25710
25711
25712 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25713 PyObject *resultobj = 0;
25714 wxDateTime *arg1 = (wxDateTime *) 0 ;
25715 double result;
25716 void *argp1 = 0 ;
25717 int res1 = 0 ;
25718 PyObject *swig_obj[1] ;
25719
25720 if (!args) SWIG_fail;
25721 swig_obj[0] = args;
25722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25723 if (!SWIG_IsOK(res1)) {
25724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25725 }
25726 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25727 {
25728 PyThreadState* __tstate = wxPyBeginAllowThreads();
25729 result = (double)(arg1)->GetRataDie();
25730 wxPyEndAllowThreads(__tstate);
25731 if (PyErr_Occurred()) SWIG_fail;
25732 }
25733 resultobj = SWIG_From_double(static_cast< double >(result));
25734 return resultobj;
25735 fail:
25736 return NULL;
25737 }
25738
25739
25740 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25741 PyObject *resultobj = 0;
25742 wxDateTime *arg1 = (wxDateTime *) 0 ;
25743 wxDateTime::TimeZone *arg2 = 0 ;
25744 bool arg3 = (bool) false ;
25745 wxDateTime result;
25746 void *argp1 = 0 ;
25747 int res1 = 0 ;
25748 bool temp2 = false ;
25749 bool val3 ;
25750 int ecode3 = 0 ;
25751 PyObject * obj0 = 0 ;
25752 PyObject * obj1 = 0 ;
25753 PyObject * obj2 = 0 ;
25754 char * kwnames[] = {
25755 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25756 };
25757
25758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25762 }
25763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25764 {
25765 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25766 temp2 = true;
25767 }
25768 if (obj2) {
25769 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25770 if (!SWIG_IsOK(ecode3)) {
25771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25772 }
25773 arg3 = static_cast< bool >(val3);
25774 }
25775 {
25776 PyThreadState* __tstate = wxPyBeginAllowThreads();
25777 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25778 wxPyEndAllowThreads(__tstate);
25779 if (PyErr_Occurred()) SWIG_fail;
25780 }
25781 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25782 {
25783 if (temp2) delete arg2;
25784 }
25785 return resultobj;
25786 fail:
25787 {
25788 if (temp2) delete arg2;
25789 }
25790 return NULL;
25791 }
25792
25793
25794 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj = 0;
25796 wxDateTime *arg1 = (wxDateTime *) 0 ;
25797 wxDateTime::TimeZone *arg2 = 0 ;
25798 bool arg3 = (bool) false ;
25799 wxDateTime *result = 0 ;
25800 void *argp1 = 0 ;
25801 int res1 = 0 ;
25802 bool temp2 = false ;
25803 bool val3 ;
25804 int ecode3 = 0 ;
25805 PyObject * obj0 = 0 ;
25806 PyObject * obj1 = 0 ;
25807 PyObject * obj2 = 0 ;
25808 char * kwnames[] = {
25809 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25810 };
25811
25812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25814 if (!SWIG_IsOK(res1)) {
25815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25816 }
25817 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25818 {
25819 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25820 temp2 = true;
25821 }
25822 if (obj2) {
25823 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25824 if (!SWIG_IsOK(ecode3)) {
25825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25826 }
25827 arg3 = static_cast< bool >(val3);
25828 }
25829 {
25830 PyThreadState* __tstate = wxPyBeginAllowThreads();
25831 {
25832 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25833 result = (wxDateTime *) &_result_ref;
25834 }
25835 wxPyEndAllowThreads(__tstate);
25836 if (PyErr_Occurred()) SWIG_fail;
25837 }
25838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25839 {
25840 if (temp2) delete arg2;
25841 }
25842 return resultobj;
25843 fail:
25844 {
25845 if (temp2) delete arg2;
25846 }
25847 return NULL;
25848 }
25849
25850
25851 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25852 PyObject *resultobj = 0;
25853 wxDateTime *arg1 = (wxDateTime *) 0 ;
25854 wxDateTime::TimeZone *arg2 = 0 ;
25855 bool arg3 = (bool) false ;
25856 wxDateTime result;
25857 void *argp1 = 0 ;
25858 int res1 = 0 ;
25859 bool temp2 = false ;
25860 bool val3 ;
25861 int ecode3 = 0 ;
25862 PyObject * obj0 = 0 ;
25863 PyObject * obj1 = 0 ;
25864 PyObject * obj2 = 0 ;
25865 char * kwnames[] = {
25866 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25867 };
25868
25869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25871 if (!SWIG_IsOK(res1)) {
25872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25873 }
25874 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25875 {
25876 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25877 temp2 = true;
25878 }
25879 if (obj2) {
25880 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25881 if (!SWIG_IsOK(ecode3)) {
25882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25883 }
25884 arg3 = static_cast< bool >(val3);
25885 }
25886 {
25887 PyThreadState* __tstate = wxPyBeginAllowThreads();
25888 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25889 wxPyEndAllowThreads(__tstate);
25890 if (PyErr_Occurred()) SWIG_fail;
25891 }
25892 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25893 {
25894 if (temp2) delete arg2;
25895 }
25896 return resultobj;
25897 fail:
25898 {
25899 if (temp2) delete arg2;
25900 }
25901 return NULL;
25902 }
25903
25904
25905 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25906 PyObject *resultobj = 0;
25907 wxDateTime *arg1 = (wxDateTime *) 0 ;
25908 wxDateTime::TimeZone *arg2 = 0 ;
25909 bool arg3 = (bool) false ;
25910 wxDateTime *result = 0 ;
25911 void *argp1 = 0 ;
25912 int res1 = 0 ;
25913 bool temp2 = false ;
25914 bool val3 ;
25915 int ecode3 = 0 ;
25916 PyObject * obj0 = 0 ;
25917 PyObject * obj1 = 0 ;
25918 PyObject * obj2 = 0 ;
25919 char * kwnames[] = {
25920 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25921 };
25922
25923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25925 if (!SWIG_IsOK(res1)) {
25926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25927 }
25928 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25929 {
25930 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25931 temp2 = true;
25932 }
25933 if (obj2) {
25934 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25935 if (!SWIG_IsOK(ecode3)) {
25936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25937 }
25938 arg3 = static_cast< bool >(val3);
25939 }
25940 {
25941 PyThreadState* __tstate = wxPyBeginAllowThreads();
25942 {
25943 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25944 result = (wxDateTime *) &_result_ref;
25945 }
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25950 {
25951 if (temp2) delete arg2;
25952 }
25953 return resultobj;
25954 fail:
25955 {
25956 if (temp2) delete arg2;
25957 }
25958 return NULL;
25959 }
25960
25961
25962 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25963 PyObject *resultobj = 0;
25964 wxDateTime *arg1 = (wxDateTime *) 0 ;
25965 bool arg2 = (bool) false ;
25966 wxDateTime result;
25967 void *argp1 = 0 ;
25968 int res1 = 0 ;
25969 bool val2 ;
25970 int ecode2 = 0 ;
25971 PyObject * obj0 = 0 ;
25972 PyObject * obj1 = 0 ;
25973 char * kwnames[] = {
25974 (char *) "self",(char *) "noDST", NULL
25975 };
25976
25977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25979 if (!SWIG_IsOK(res1)) {
25980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25981 }
25982 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25983 if (obj1) {
25984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25985 if (!SWIG_IsOK(ecode2)) {
25986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25987 }
25988 arg2 = static_cast< bool >(val2);
25989 }
25990 {
25991 PyThreadState* __tstate = wxPyBeginAllowThreads();
25992 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25993 wxPyEndAllowThreads(__tstate);
25994 if (PyErr_Occurred()) SWIG_fail;
25995 }
25996 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25997 return resultobj;
25998 fail:
25999 return NULL;
26000 }
26001
26002
26003 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26004 PyObject *resultobj = 0;
26005 wxDateTime *arg1 = (wxDateTime *) 0 ;
26006 bool arg2 = (bool) false ;
26007 wxDateTime *result = 0 ;
26008 void *argp1 = 0 ;
26009 int res1 = 0 ;
26010 bool val2 ;
26011 int ecode2 = 0 ;
26012 PyObject * obj0 = 0 ;
26013 PyObject * obj1 = 0 ;
26014 char * kwnames[] = {
26015 (char *) "self",(char *) "noDST", NULL
26016 };
26017
26018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26020 if (!SWIG_IsOK(res1)) {
26021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26022 }
26023 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26024 if (obj1) {
26025 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26026 if (!SWIG_IsOK(ecode2)) {
26027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26028 }
26029 arg2 = static_cast< bool >(val2);
26030 }
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 {
26034 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26035 result = (wxDateTime *) &_result_ref;
26036 }
26037 wxPyEndAllowThreads(__tstate);
26038 if (PyErr_Occurred()) SWIG_fail;
26039 }
26040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26041 return resultobj;
26042 fail:
26043 return NULL;
26044 }
26045
26046
26047 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26048 PyObject *resultobj = 0;
26049 wxDateTime *arg1 = (wxDateTime *) 0 ;
26050 bool arg2 = (bool) false ;
26051 wxDateTime result;
26052 void *argp1 = 0 ;
26053 int res1 = 0 ;
26054 bool val2 ;
26055 int ecode2 = 0 ;
26056 PyObject * obj0 = 0 ;
26057 PyObject * obj1 = 0 ;
26058 char * kwnames[] = {
26059 (char *) "self",(char *) "noDST", NULL
26060 };
26061
26062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26064 if (!SWIG_IsOK(res1)) {
26065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26066 }
26067 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26068 if (obj1) {
26069 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26070 if (!SWIG_IsOK(ecode2)) {
26071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26072 }
26073 arg2 = static_cast< bool >(val2);
26074 }
26075 {
26076 PyThreadState* __tstate = wxPyBeginAllowThreads();
26077 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26078 wxPyEndAllowThreads(__tstate);
26079 if (PyErr_Occurred()) SWIG_fail;
26080 }
26081 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj = 0;
26090 wxDateTime *arg1 = (wxDateTime *) 0 ;
26091 bool arg2 = (bool) false ;
26092 wxDateTime *result = 0 ;
26093 void *argp1 = 0 ;
26094 int res1 = 0 ;
26095 bool val2 ;
26096 int ecode2 = 0 ;
26097 PyObject * obj0 = 0 ;
26098 PyObject * obj1 = 0 ;
26099 char * kwnames[] = {
26100 (char *) "self",(char *) "noDST", NULL
26101 };
26102
26103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26105 if (!SWIG_IsOK(res1)) {
26106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26107 }
26108 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26109 if (obj1) {
26110 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26111 if (!SWIG_IsOK(ecode2)) {
26112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26113 }
26114 arg2 = static_cast< bool >(val2);
26115 }
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 {
26119 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26120 result = (wxDateTime *) &_result_ref;
26121 }
26122 wxPyEndAllowThreads(__tstate);
26123 if (PyErr_Occurred()) SWIG_fail;
26124 }
26125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj = 0;
26134 wxDateTime *arg1 = (wxDateTime *) 0 ;
26135 bool arg2 = (bool) false ;
26136 wxDateTime result;
26137 void *argp1 = 0 ;
26138 int res1 = 0 ;
26139 bool val2 ;
26140 int ecode2 = 0 ;
26141 PyObject * obj0 = 0 ;
26142 PyObject * obj1 = 0 ;
26143 char * kwnames[] = {
26144 (char *) "self",(char *) "noDST", NULL
26145 };
26146
26147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26149 if (!SWIG_IsOK(res1)) {
26150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26151 }
26152 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26153 if (obj1) {
26154 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26155 if (!SWIG_IsOK(ecode2)) {
26156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26157 }
26158 arg2 = static_cast< bool >(val2);
26159 }
26160 {
26161 PyThreadState* __tstate = wxPyBeginAllowThreads();
26162 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26167 return resultobj;
26168 fail:
26169 return NULL;
26170 }
26171
26172
26173 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26174 PyObject *resultobj = 0;
26175 wxDateTime *arg1 = (wxDateTime *) 0 ;
26176 bool arg2 = (bool) false ;
26177 wxDateTime *result = 0 ;
26178 void *argp1 = 0 ;
26179 int res1 = 0 ;
26180 bool val2 ;
26181 int ecode2 = 0 ;
26182 PyObject * obj0 = 0 ;
26183 PyObject * obj1 = 0 ;
26184 char * kwnames[] = {
26185 (char *) "self",(char *) "noDST", NULL
26186 };
26187
26188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26190 if (!SWIG_IsOK(res1)) {
26191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26192 }
26193 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26194 if (obj1) {
26195 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26196 if (!SWIG_IsOK(ecode2)) {
26197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26198 }
26199 arg2 = static_cast< bool >(val2);
26200 }
26201 {
26202 PyThreadState* __tstate = wxPyBeginAllowThreads();
26203 {
26204 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26205 result = (wxDateTime *) &_result_ref;
26206 }
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26211 return resultobj;
26212 fail:
26213 return NULL;
26214 }
26215
26216
26217 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26218 PyObject *resultobj = 0;
26219 wxDateTime *arg1 = (wxDateTime *) 0 ;
26220 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26221 int result;
26222 void *argp1 = 0 ;
26223 int res1 = 0 ;
26224 int val2 ;
26225 int ecode2 = 0 ;
26226 PyObject * obj0 = 0 ;
26227 PyObject * obj1 = 0 ;
26228 char * kwnames[] = {
26229 (char *) "self",(char *) "country", NULL
26230 };
26231
26232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26234 if (!SWIG_IsOK(res1)) {
26235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26236 }
26237 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26238 if (obj1) {
26239 ecode2 = SWIG_AsVal_int(obj1, &val2);
26240 if (!SWIG_IsOK(ecode2)) {
26241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26242 }
26243 arg2 = static_cast< wxDateTime::Country >(val2);
26244 }
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 result = (int)(arg1)->IsDST(arg2);
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 resultobj = SWIG_From_int(static_cast< int >(result));
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26259 PyObject *resultobj = 0;
26260 wxDateTime *arg1 = (wxDateTime *) 0 ;
26261 bool result;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 PyObject *swig_obj[1] ;
26265
26266 if (!args) SWIG_fail;
26267 swig_obj[0] = args;
26268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26271 }
26272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26273 {
26274 PyThreadState* __tstate = wxPyBeginAllowThreads();
26275 result = (bool)((wxDateTime const *)arg1)->IsValid();
26276 wxPyEndAllowThreads(__tstate);
26277 if (PyErr_Occurred()) SWIG_fail;
26278 }
26279 {
26280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26281 }
26282 return resultobj;
26283 fail:
26284 return NULL;
26285 }
26286
26287
26288 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26289 PyObject *resultobj = 0;
26290 wxDateTime *arg1 = (wxDateTime *) 0 ;
26291 time_t result;
26292 void *argp1 = 0 ;
26293 int res1 = 0 ;
26294 PyObject *swig_obj[1] ;
26295
26296 if (!args) SWIG_fail;
26297 swig_obj[0] = args;
26298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26299 if (!SWIG_IsOK(res1)) {
26300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26301 }
26302 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26303 {
26304 PyThreadState* __tstate = wxPyBeginAllowThreads();
26305 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26306 wxPyEndAllowThreads(__tstate);
26307 if (PyErr_Occurred()) SWIG_fail;
26308 }
26309 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26310 return resultobj;
26311 fail:
26312 return NULL;
26313 }
26314
26315
26316 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26317 PyObject *resultobj = 0;
26318 wxDateTime *arg1 = (wxDateTime *) 0 ;
26319 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26320 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26321 int result;
26322 void *argp1 = 0 ;
26323 int res1 = 0 ;
26324 bool temp2 = false ;
26325 PyObject * obj0 = 0 ;
26326 PyObject * obj1 = 0 ;
26327 char * kwnames[] = {
26328 (char *) "self",(char *) "tz", NULL
26329 };
26330
26331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26333 if (!SWIG_IsOK(res1)) {
26334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26335 }
26336 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26337 if (obj1) {
26338 {
26339 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26340 temp2 = true;
26341 }
26342 }
26343 {
26344 PyThreadState* __tstate = wxPyBeginAllowThreads();
26345 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 resultobj = SWIG_From_int(static_cast< int >(result));
26350 {
26351 if (temp2) delete arg2;
26352 }
26353 return resultobj;
26354 fail:
26355 {
26356 if (temp2) delete arg2;
26357 }
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26363 PyObject *resultobj = 0;
26364 wxDateTime *arg1 = (wxDateTime *) 0 ;
26365 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26366 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26367 wxDateTime::Month result;
26368 void *argp1 = 0 ;
26369 int res1 = 0 ;
26370 bool temp2 = false ;
26371 PyObject * obj0 = 0 ;
26372 PyObject * obj1 = 0 ;
26373 char * kwnames[] = {
26374 (char *) "self",(char *) "tz", NULL
26375 };
26376
26377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26379 if (!SWIG_IsOK(res1)) {
26380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26381 }
26382 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26383 if (obj1) {
26384 {
26385 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26386 temp2 = true;
26387 }
26388 }
26389 {
26390 PyThreadState* __tstate = wxPyBeginAllowThreads();
26391 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26392 wxPyEndAllowThreads(__tstate);
26393 if (PyErr_Occurred()) SWIG_fail;
26394 }
26395 resultobj = SWIG_From_int(static_cast< int >(result));
26396 {
26397 if (temp2) delete arg2;
26398 }
26399 return resultobj;
26400 fail:
26401 {
26402 if (temp2) delete arg2;
26403 }
26404 return NULL;
26405 }
26406
26407
26408 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26409 PyObject *resultobj = 0;
26410 wxDateTime *arg1 = (wxDateTime *) 0 ;
26411 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26412 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26413 int result;
26414 void *argp1 = 0 ;
26415 int res1 = 0 ;
26416 bool temp2 = false ;
26417 PyObject * obj0 = 0 ;
26418 PyObject * obj1 = 0 ;
26419 char * kwnames[] = {
26420 (char *) "self",(char *) "tz", NULL
26421 };
26422
26423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26425 if (!SWIG_IsOK(res1)) {
26426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26427 }
26428 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26429 if (obj1) {
26430 {
26431 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26432 temp2 = true;
26433 }
26434 }
26435 {
26436 PyThreadState* __tstate = wxPyBeginAllowThreads();
26437 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 resultobj = SWIG_From_int(static_cast< int >(result));
26442 {
26443 if (temp2) delete arg2;
26444 }
26445 return resultobj;
26446 fail:
26447 {
26448 if (temp2) delete arg2;
26449 }
26450 return NULL;
26451 }
26452
26453
26454 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26455 PyObject *resultobj = 0;
26456 wxDateTime *arg1 = (wxDateTime *) 0 ;
26457 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26458 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26459 wxDateTime::WeekDay result;
26460 void *argp1 = 0 ;
26461 int res1 = 0 ;
26462 bool temp2 = false ;
26463 PyObject * obj0 = 0 ;
26464 PyObject * obj1 = 0 ;
26465 char * kwnames[] = {
26466 (char *) "self",(char *) "tz", NULL
26467 };
26468
26469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26471 if (!SWIG_IsOK(res1)) {
26472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26473 }
26474 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26475 if (obj1) {
26476 {
26477 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26478 temp2 = true;
26479 }
26480 }
26481 {
26482 PyThreadState* __tstate = wxPyBeginAllowThreads();
26483 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 resultobj = SWIG_From_int(static_cast< int >(result));
26488 {
26489 if (temp2) delete arg2;
26490 }
26491 return resultobj;
26492 fail:
26493 {
26494 if (temp2) delete arg2;
26495 }
26496 return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26501 PyObject *resultobj = 0;
26502 wxDateTime *arg1 = (wxDateTime *) 0 ;
26503 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26504 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26505 int result;
26506 void *argp1 = 0 ;
26507 int res1 = 0 ;
26508 bool temp2 = false ;
26509 PyObject * obj0 = 0 ;
26510 PyObject * obj1 = 0 ;
26511 char * kwnames[] = {
26512 (char *) "self",(char *) "tz", NULL
26513 };
26514
26515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26517 if (!SWIG_IsOK(res1)) {
26518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26519 }
26520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26521 if (obj1) {
26522 {
26523 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26524 temp2 = true;
26525 }
26526 }
26527 {
26528 PyThreadState* __tstate = wxPyBeginAllowThreads();
26529 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26530 wxPyEndAllowThreads(__tstate);
26531 if (PyErr_Occurred()) SWIG_fail;
26532 }
26533 resultobj = SWIG_From_int(static_cast< int >(result));
26534 {
26535 if (temp2) delete arg2;
26536 }
26537 return resultobj;
26538 fail:
26539 {
26540 if (temp2) delete arg2;
26541 }
26542 return NULL;
26543 }
26544
26545
26546 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26547 PyObject *resultobj = 0;
26548 wxDateTime *arg1 = (wxDateTime *) 0 ;
26549 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26550 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26551 int result;
26552 void *argp1 = 0 ;
26553 int res1 = 0 ;
26554 bool temp2 = false ;
26555 PyObject * obj0 = 0 ;
26556 PyObject * obj1 = 0 ;
26557 char * kwnames[] = {
26558 (char *) "self",(char *) "tz", NULL
26559 };
26560
26561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26563 if (!SWIG_IsOK(res1)) {
26564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26565 }
26566 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26567 if (obj1) {
26568 {
26569 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26570 temp2 = true;
26571 }
26572 }
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 resultobj = SWIG_From_int(static_cast< int >(result));
26580 {
26581 if (temp2) delete arg2;
26582 }
26583 return resultobj;
26584 fail:
26585 {
26586 if (temp2) delete arg2;
26587 }
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj = 0;
26594 wxDateTime *arg1 = (wxDateTime *) 0 ;
26595 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26596 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26597 int result;
26598 void *argp1 = 0 ;
26599 int res1 = 0 ;
26600 bool temp2 = false ;
26601 PyObject * obj0 = 0 ;
26602 PyObject * obj1 = 0 ;
26603 char * kwnames[] = {
26604 (char *) "self",(char *) "tz", NULL
26605 };
26606
26607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26609 if (!SWIG_IsOK(res1)) {
26610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26611 }
26612 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26613 if (obj1) {
26614 {
26615 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26616 temp2 = true;
26617 }
26618 }
26619 {
26620 PyThreadState* __tstate = wxPyBeginAllowThreads();
26621 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26622 wxPyEndAllowThreads(__tstate);
26623 if (PyErr_Occurred()) SWIG_fail;
26624 }
26625 resultobj = SWIG_From_int(static_cast< int >(result));
26626 {
26627 if (temp2) delete arg2;
26628 }
26629 return resultobj;
26630 fail:
26631 {
26632 if (temp2) delete arg2;
26633 }
26634 return NULL;
26635 }
26636
26637
26638 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26639 PyObject *resultobj = 0;
26640 wxDateTime *arg1 = (wxDateTime *) 0 ;
26641 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26642 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26643 int result;
26644 void *argp1 = 0 ;
26645 int res1 = 0 ;
26646 bool temp2 = false ;
26647 PyObject * obj0 = 0 ;
26648 PyObject * obj1 = 0 ;
26649 char * kwnames[] = {
26650 (char *) "self",(char *) "tz", NULL
26651 };
26652
26653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26655 if (!SWIG_IsOK(res1)) {
26656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26657 }
26658 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26659 if (obj1) {
26660 {
26661 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26662 temp2 = true;
26663 }
26664 }
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 resultobj = SWIG_From_int(static_cast< int >(result));
26672 {
26673 if (temp2) delete arg2;
26674 }
26675 return resultobj;
26676 fail:
26677 {
26678 if (temp2) delete arg2;
26679 }
26680 return NULL;
26681 }
26682
26683
26684 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26685 PyObject *resultobj = 0;
26686 wxDateTime *arg1 = (wxDateTime *) 0 ;
26687 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26688 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26689 int result;
26690 void *argp1 = 0 ;
26691 int res1 = 0 ;
26692 bool temp2 = false ;
26693 PyObject * obj0 = 0 ;
26694 PyObject * obj1 = 0 ;
26695 char * kwnames[] = {
26696 (char *) "self",(char *) "tz", NULL
26697 };
26698
26699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26701 if (!SWIG_IsOK(res1)) {
26702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26703 }
26704 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26705 if (obj1) {
26706 {
26707 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26708 temp2 = true;
26709 }
26710 }
26711 {
26712 PyThreadState* __tstate = wxPyBeginAllowThreads();
26713 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26714 wxPyEndAllowThreads(__tstate);
26715 if (PyErr_Occurred()) SWIG_fail;
26716 }
26717 resultobj = SWIG_From_int(static_cast< int >(result));
26718 {
26719 if (temp2) delete arg2;
26720 }
26721 return resultobj;
26722 fail:
26723 {
26724 if (temp2) delete arg2;
26725 }
26726 return NULL;
26727 }
26728
26729
26730 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26731 PyObject *resultobj = 0;
26732 wxDateTime *arg1 = (wxDateTime *) 0 ;
26733 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26734 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26735 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26736 int result;
26737 void *argp1 = 0 ;
26738 int res1 = 0 ;
26739 int val2 ;
26740 int ecode2 = 0 ;
26741 bool temp3 = false ;
26742 PyObject * obj0 = 0 ;
26743 PyObject * obj1 = 0 ;
26744 PyObject * obj2 = 0 ;
26745 char * kwnames[] = {
26746 (char *) "self",(char *) "flags",(char *) "tz", NULL
26747 };
26748
26749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26751 if (!SWIG_IsOK(res1)) {
26752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26753 }
26754 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26755 if (obj1) {
26756 ecode2 = SWIG_AsVal_int(obj1, &val2);
26757 if (!SWIG_IsOK(ecode2)) {
26758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26759 }
26760 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26761 }
26762 if (obj2) {
26763 {
26764 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26765 temp3 = true;
26766 }
26767 }
26768 {
26769 PyThreadState* __tstate = wxPyBeginAllowThreads();
26770 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26771 wxPyEndAllowThreads(__tstate);
26772 if (PyErr_Occurred()) SWIG_fail;
26773 }
26774 resultobj = SWIG_From_int(static_cast< int >(result));
26775 {
26776 if (temp3) delete arg3;
26777 }
26778 return resultobj;
26779 fail:
26780 {
26781 if (temp3) delete arg3;
26782 }
26783 return NULL;
26784 }
26785
26786
26787 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26788 PyObject *resultobj = 0;
26789 wxDateTime *arg1 = (wxDateTime *) 0 ;
26790 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26791 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26792 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26793 int result;
26794 void *argp1 = 0 ;
26795 int res1 = 0 ;
26796 int val2 ;
26797 int ecode2 = 0 ;
26798 bool temp3 = false ;
26799 PyObject * obj0 = 0 ;
26800 PyObject * obj1 = 0 ;
26801 PyObject * obj2 = 0 ;
26802 char * kwnames[] = {
26803 (char *) "self",(char *) "flags",(char *) "tz", NULL
26804 };
26805
26806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26808 if (!SWIG_IsOK(res1)) {
26809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26810 }
26811 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26812 if (obj1) {
26813 ecode2 = SWIG_AsVal_int(obj1, &val2);
26814 if (!SWIG_IsOK(ecode2)) {
26815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26816 }
26817 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26818 }
26819 if (obj2) {
26820 {
26821 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26822 temp3 = true;
26823 }
26824 }
26825 {
26826 PyThreadState* __tstate = wxPyBeginAllowThreads();
26827 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26828 wxPyEndAllowThreads(__tstate);
26829 if (PyErr_Occurred()) SWIG_fail;
26830 }
26831 resultobj = SWIG_From_int(static_cast< int >(result));
26832 {
26833 if (temp3) delete arg3;
26834 }
26835 return resultobj;
26836 fail:
26837 {
26838 if (temp3) delete arg3;
26839 }
26840 return NULL;
26841 }
26842
26843
26844 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj = 0;
26846 wxDateTime *arg1 = (wxDateTime *) 0 ;
26847 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26848 bool result;
26849 void *argp1 = 0 ;
26850 int res1 = 0 ;
26851 int val2 ;
26852 int ecode2 = 0 ;
26853 PyObject * obj0 = 0 ;
26854 PyObject * obj1 = 0 ;
26855 char * kwnames[] = {
26856 (char *) "self",(char *) "country", NULL
26857 };
26858
26859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26863 }
26864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26865 if (obj1) {
26866 ecode2 = SWIG_AsVal_int(obj1, &val2);
26867 if (!SWIG_IsOK(ecode2)) {
26868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26869 }
26870 arg2 = static_cast< wxDateTime::Country >(val2);
26871 }
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 {
26879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26880 }
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj = 0;
26889 wxDateTime *arg1 = (wxDateTime *) 0 ;
26890 wxDateTime *arg2 = 0 ;
26891 bool result;
26892 void *argp1 = 0 ;
26893 int res1 = 0 ;
26894 void *argp2 = 0 ;
26895 int res2 = 0 ;
26896 PyObject * obj0 = 0 ;
26897 PyObject * obj1 = 0 ;
26898 char * kwnames[] = {
26899 (char *) "self",(char *) "datetime", NULL
26900 };
26901
26902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26904 if (!SWIG_IsOK(res1)) {
26905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26906 }
26907 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26908 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26909 if (!SWIG_IsOK(res2)) {
26910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26911 }
26912 if (!argp2) {
26913 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26914 }
26915 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26916 {
26917 PyThreadState* __tstate = wxPyBeginAllowThreads();
26918 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26919 wxPyEndAllowThreads(__tstate);
26920 if (PyErr_Occurred()) SWIG_fail;
26921 }
26922 {
26923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26924 }
26925 return resultobj;
26926 fail:
26927 return NULL;
26928 }
26929
26930
26931 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26932 PyObject *resultobj = 0;
26933 wxDateTime *arg1 = (wxDateTime *) 0 ;
26934 wxDateTime *arg2 = 0 ;
26935 bool result;
26936 void *argp1 = 0 ;
26937 int res1 = 0 ;
26938 void *argp2 = 0 ;
26939 int res2 = 0 ;
26940 PyObject * obj0 = 0 ;
26941 PyObject * obj1 = 0 ;
26942 char * kwnames[] = {
26943 (char *) "self",(char *) "datetime", NULL
26944 };
26945
26946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26948 if (!SWIG_IsOK(res1)) {
26949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26950 }
26951 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26952 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26953 if (!SWIG_IsOK(res2)) {
26954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26955 }
26956 if (!argp2) {
26957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26958 }
26959 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 {
26967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26968 }
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26976 PyObject *resultobj = 0;
26977 wxDateTime *arg1 = (wxDateTime *) 0 ;
26978 wxDateTime *arg2 = 0 ;
26979 bool result;
26980 void *argp1 = 0 ;
26981 int res1 = 0 ;
26982 void *argp2 = 0 ;
26983 int res2 = 0 ;
26984 PyObject * obj0 = 0 ;
26985 PyObject * obj1 = 0 ;
26986 char * kwnames[] = {
26987 (char *) "self",(char *) "datetime", NULL
26988 };
26989
26990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26992 if (!SWIG_IsOK(res1)) {
26993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26994 }
26995 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26996 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26997 if (!SWIG_IsOK(res2)) {
26998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26999 }
27000 if (!argp2) {
27001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27002 }
27003 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27004 {
27005 PyThreadState* __tstate = wxPyBeginAllowThreads();
27006 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
27007 wxPyEndAllowThreads(__tstate);
27008 if (PyErr_Occurred()) SWIG_fail;
27009 }
27010 {
27011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27012 }
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj = 0;
27021 wxDateTime *arg1 = (wxDateTime *) 0 ;
27022 wxDateTime *arg2 = 0 ;
27023 wxDateTime *arg3 = 0 ;
27024 bool result;
27025 void *argp1 = 0 ;
27026 int res1 = 0 ;
27027 void *argp2 = 0 ;
27028 int res2 = 0 ;
27029 void *argp3 = 0 ;
27030 int res3 = 0 ;
27031 PyObject * obj0 = 0 ;
27032 PyObject * obj1 = 0 ;
27033 PyObject * obj2 = 0 ;
27034 char * kwnames[] = {
27035 (char *) "self",(char *) "t1",(char *) "t2", NULL
27036 };
27037
27038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27040 if (!SWIG_IsOK(res1)) {
27041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27042 }
27043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27044 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27045 if (!SWIG_IsOK(res2)) {
27046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27047 }
27048 if (!argp2) {
27049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27050 }
27051 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27052 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27053 if (!SWIG_IsOK(res3)) {
27054 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27055 }
27056 if (!argp3) {
27057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27058 }
27059 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 {
27067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27068 }
27069 return resultobj;
27070 fail:
27071 return NULL;
27072 }
27073
27074
27075 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27076 PyObject *resultobj = 0;
27077 wxDateTime *arg1 = (wxDateTime *) 0 ;
27078 wxDateTime *arg2 = 0 ;
27079 wxDateTime *arg3 = 0 ;
27080 bool result;
27081 void *argp1 = 0 ;
27082 int res1 = 0 ;
27083 void *argp2 = 0 ;
27084 int res2 = 0 ;
27085 void *argp3 = 0 ;
27086 int res3 = 0 ;
27087 PyObject * obj0 = 0 ;
27088 PyObject * obj1 = 0 ;
27089 PyObject * obj2 = 0 ;
27090 char * kwnames[] = {
27091 (char *) "self",(char *) "t1",(char *) "t2", NULL
27092 };
27093
27094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27096 if (!SWIG_IsOK(res1)) {
27097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27098 }
27099 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27100 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27101 if (!SWIG_IsOK(res2)) {
27102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27103 }
27104 if (!argp2) {
27105 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27106 }
27107 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27108 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27109 if (!SWIG_IsOK(res3)) {
27110 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27111 }
27112 if (!argp3) {
27113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27114 }
27115 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27119 wxPyEndAllowThreads(__tstate);
27120 if (PyErr_Occurred()) SWIG_fail;
27121 }
27122 {
27123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27124 }
27125 return resultobj;
27126 fail:
27127 return NULL;
27128 }
27129
27130
27131 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27132 PyObject *resultobj = 0;
27133 wxDateTime *arg1 = (wxDateTime *) 0 ;
27134 wxDateTime *arg2 = 0 ;
27135 bool result;
27136 void *argp1 = 0 ;
27137 int res1 = 0 ;
27138 void *argp2 = 0 ;
27139 int res2 = 0 ;
27140 PyObject * obj0 = 0 ;
27141 PyObject * obj1 = 0 ;
27142 char * kwnames[] = {
27143 (char *) "self",(char *) "dt", NULL
27144 };
27145
27146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27148 if (!SWIG_IsOK(res1)) {
27149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27150 }
27151 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27153 if (!SWIG_IsOK(res2)) {
27154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27155 }
27156 if (!argp2) {
27157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27158 }
27159 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27163 wxPyEndAllowThreads(__tstate);
27164 if (PyErr_Occurred()) SWIG_fail;
27165 }
27166 {
27167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27168 }
27169 return resultobj;
27170 fail:
27171 return NULL;
27172 }
27173
27174
27175 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27176 PyObject *resultobj = 0;
27177 wxDateTime *arg1 = (wxDateTime *) 0 ;
27178 wxDateTime *arg2 = 0 ;
27179 bool result;
27180 void *argp1 = 0 ;
27181 int res1 = 0 ;
27182 void *argp2 = 0 ;
27183 int res2 = 0 ;
27184 PyObject * obj0 = 0 ;
27185 PyObject * obj1 = 0 ;
27186 char * kwnames[] = {
27187 (char *) "self",(char *) "dt", NULL
27188 };
27189
27190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27192 if (!SWIG_IsOK(res1)) {
27193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27194 }
27195 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27197 if (!SWIG_IsOK(res2)) {
27198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27199 }
27200 if (!argp2) {
27201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27202 }
27203 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27204 {
27205 PyThreadState* __tstate = wxPyBeginAllowThreads();
27206 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 {
27211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27212 }
27213 return resultobj;
27214 fail:
27215 return NULL;
27216 }
27217
27218
27219 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27220 PyObject *resultobj = 0;
27221 wxDateTime *arg1 = (wxDateTime *) 0 ;
27222 wxDateTime *arg2 = 0 ;
27223 wxTimeSpan *arg3 = 0 ;
27224 bool result;
27225 void *argp1 = 0 ;
27226 int res1 = 0 ;
27227 void *argp2 = 0 ;
27228 int res2 = 0 ;
27229 void *argp3 = 0 ;
27230 int res3 = 0 ;
27231 PyObject * obj0 = 0 ;
27232 PyObject * obj1 = 0 ;
27233 PyObject * obj2 = 0 ;
27234 char * kwnames[] = {
27235 (char *) "self",(char *) "dt",(char *) "ts", NULL
27236 };
27237
27238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27240 if (!SWIG_IsOK(res1)) {
27241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27242 }
27243 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27245 if (!SWIG_IsOK(res2)) {
27246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27247 }
27248 if (!argp2) {
27249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27250 }
27251 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27252 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27253 if (!SWIG_IsOK(res3)) {
27254 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27255 }
27256 if (!argp3) {
27257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27258 }
27259 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27260 {
27261 PyThreadState* __tstate = wxPyBeginAllowThreads();
27262 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 {
27267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27268 }
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27276 PyObject *resultobj = 0;
27277 wxDateTime *arg1 = (wxDateTime *) 0 ;
27278 wxTimeSpan *arg2 = 0 ;
27279 wxDateTime *result = 0 ;
27280 void *argp1 = 0 ;
27281 int res1 = 0 ;
27282 void *argp2 = 0 ;
27283 int res2 = 0 ;
27284 PyObject * obj0 = 0 ;
27285 PyObject * obj1 = 0 ;
27286 char * kwnames[] = {
27287 (char *) "self",(char *) "diff", NULL
27288 };
27289
27290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27292 if (!SWIG_IsOK(res1)) {
27293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27294 }
27295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27297 if (!SWIG_IsOK(res2)) {
27298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27299 }
27300 if (!argp2) {
27301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27302 }
27303 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 {
27307 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27308 result = (wxDateTime *) &_result_ref;
27309 }
27310 wxPyEndAllowThreads(__tstate);
27311 if (PyErr_Occurred()) SWIG_fail;
27312 }
27313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27321 PyObject *resultobj = 0;
27322 wxDateTime *arg1 = (wxDateTime *) 0 ;
27323 wxDateSpan *arg2 = 0 ;
27324 wxDateTime *result = 0 ;
27325 void *argp1 = 0 ;
27326 int res1 = 0 ;
27327 void *argp2 = 0 ;
27328 int res2 = 0 ;
27329 PyObject * obj0 = 0 ;
27330 PyObject * obj1 = 0 ;
27331 char * kwnames[] = {
27332 (char *) "self",(char *) "diff", NULL
27333 };
27334
27335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27337 if (!SWIG_IsOK(res1)) {
27338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27339 }
27340 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27341 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27342 if (!SWIG_IsOK(res2)) {
27343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27344 }
27345 if (!argp2) {
27346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27347 }
27348 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27349 {
27350 PyThreadState* __tstate = wxPyBeginAllowThreads();
27351 {
27352 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27353 result = (wxDateTime *) &_result_ref;
27354 }
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27359 return resultobj;
27360 fail:
27361 return NULL;
27362 }
27363
27364
27365 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27366 PyObject *resultobj = 0;
27367 wxDateTime *arg1 = (wxDateTime *) 0 ;
27368 wxTimeSpan *arg2 = 0 ;
27369 wxDateTime *result = 0 ;
27370 void *argp1 = 0 ;
27371 int res1 = 0 ;
27372 void *argp2 = 0 ;
27373 int res2 = 0 ;
27374 PyObject * obj0 = 0 ;
27375 PyObject * obj1 = 0 ;
27376 char * kwnames[] = {
27377 (char *) "self",(char *) "diff", NULL
27378 };
27379
27380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27384 }
27385 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27386 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27387 if (!SWIG_IsOK(res2)) {
27388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27389 }
27390 if (!argp2) {
27391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27392 }
27393 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 {
27397 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27398 result = (wxDateTime *) &_result_ref;
27399 }
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj = 0;
27412 wxDateTime *arg1 = (wxDateTime *) 0 ;
27413 wxDateSpan *arg2 = 0 ;
27414 wxDateTime *result = 0 ;
27415 void *argp1 = 0 ;
27416 int res1 = 0 ;
27417 void *argp2 = 0 ;
27418 int res2 = 0 ;
27419 PyObject * obj0 = 0 ;
27420 PyObject * obj1 = 0 ;
27421 char * kwnames[] = {
27422 (char *) "self",(char *) "diff", NULL
27423 };
27424
27425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27427 if (!SWIG_IsOK(res1)) {
27428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27429 }
27430 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27431 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27432 if (!SWIG_IsOK(res2)) {
27433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27434 }
27435 if (!argp2) {
27436 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27437 }
27438 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 {
27442 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27443 result = (wxDateTime *) &_result_ref;
27444 }
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27456 PyObject *resultobj = 0;
27457 wxDateTime *arg1 = (wxDateTime *) 0 ;
27458 wxDateTime *arg2 = 0 ;
27459 wxTimeSpan result;
27460 void *argp1 = 0 ;
27461 int res1 = 0 ;
27462 void *argp2 = 0 ;
27463 int res2 = 0 ;
27464 PyObject * obj0 = 0 ;
27465 PyObject * obj1 = 0 ;
27466 char * kwnames[] = {
27467 (char *) "self",(char *) "dt", NULL
27468 };
27469
27470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27472 if (!SWIG_IsOK(res1)) {
27473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27474 }
27475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27476 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27477 if (!SWIG_IsOK(res2)) {
27478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27479 }
27480 if (!argp2) {
27481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27482 }
27483 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27484 {
27485 PyThreadState* __tstate = wxPyBeginAllowThreads();
27486 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27498 PyObject *resultobj = 0;
27499 wxDateTime *arg1 = (wxDateTime *) 0 ;
27500 wxTimeSpan *arg2 = 0 ;
27501 wxDateTime *result = 0 ;
27502 void *argp1 = 0 ;
27503 int res1 = 0 ;
27504 void *argp2 = 0 ;
27505 int res2 = 0 ;
27506
27507 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27509 if (!SWIG_IsOK(res1)) {
27510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27511 }
27512 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27513 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27514 if (!SWIG_IsOK(res2)) {
27515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27516 }
27517 if (!argp2) {
27518 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27519 }
27520 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 {
27524 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27525 result = (wxDateTime *) &_result_ref;
27526 }
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27538 PyObject *resultobj = 0;
27539 wxDateTime *arg1 = (wxDateTime *) 0 ;
27540 wxDateSpan *arg2 = 0 ;
27541 wxDateTime *result = 0 ;
27542 void *argp1 = 0 ;
27543 int res1 = 0 ;
27544 void *argp2 = 0 ;
27545 int res2 = 0 ;
27546
27547 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27549 if (!SWIG_IsOK(res1)) {
27550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27551 }
27552 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27553 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27554 if (!SWIG_IsOK(res2)) {
27555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27556 }
27557 if (!argp2) {
27558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27559 }
27560 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27561 {
27562 PyThreadState* __tstate = wxPyBeginAllowThreads();
27563 {
27564 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27565 result = (wxDateTime *) &_result_ref;
27566 }
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27571 return resultobj;
27572 fail:
27573 return NULL;
27574 }
27575
27576
27577 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27578 int argc;
27579 PyObject *argv[3];
27580
27581 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27582 --argc;
27583 if (argc == 2) {
27584 int _v = 0;
27585 {
27586 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27587 _v = SWIG_CheckState(res);
27588 }
27589 if (!_v) goto check_1;
27590 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27591 }
27592 check_1:
27593
27594 if (argc == 2) {
27595 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27596 }
27597
27598 fail:
27599 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27600 return NULL;
27601 }
27602
27603
27604 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27605 PyObject *resultobj = 0;
27606 wxDateTime *arg1 = (wxDateTime *) 0 ;
27607 wxTimeSpan *arg2 = 0 ;
27608 wxDateTime *result = 0 ;
27609 void *argp1 = 0 ;
27610 int res1 = 0 ;
27611 void *argp2 = 0 ;
27612 int res2 = 0 ;
27613
27614 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27616 if (!SWIG_IsOK(res1)) {
27617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27618 }
27619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27620 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27621 if (!SWIG_IsOK(res2)) {
27622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27623 }
27624 if (!argp2) {
27625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27626 }
27627 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27628 {
27629 PyThreadState* __tstate = wxPyBeginAllowThreads();
27630 {
27631 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27632 result = (wxDateTime *) &_result_ref;
27633 }
27634 wxPyEndAllowThreads(__tstate);
27635 if (PyErr_Occurred()) SWIG_fail;
27636 }
27637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27638 return resultobj;
27639 fail:
27640 return NULL;
27641 }
27642
27643
27644 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27645 PyObject *resultobj = 0;
27646 wxDateTime *arg1 = (wxDateTime *) 0 ;
27647 wxDateSpan *arg2 = 0 ;
27648 wxDateTime *result = 0 ;
27649 void *argp1 = 0 ;
27650 int res1 = 0 ;
27651 void *argp2 = 0 ;
27652 int res2 = 0 ;
27653
27654 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27656 if (!SWIG_IsOK(res1)) {
27657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27658 }
27659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27660 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27661 if (!SWIG_IsOK(res2)) {
27662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27663 }
27664 if (!argp2) {
27665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27666 }
27667 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 {
27671 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27672 result = (wxDateTime *) &_result_ref;
27673 }
27674 wxPyEndAllowThreads(__tstate);
27675 if (PyErr_Occurred()) SWIG_fail;
27676 }
27677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27685 int argc;
27686 PyObject *argv[3];
27687
27688 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27689 --argc;
27690 if (argc == 2) {
27691 int _v = 0;
27692 {
27693 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27694 _v = SWIG_CheckState(res);
27695 }
27696 if (!_v) goto check_1;
27697 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27698 }
27699 check_1:
27700
27701 if (argc == 2) {
27702 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27703 }
27704
27705 fail:
27706 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27707 return NULL;
27708 }
27709
27710
27711 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27712 PyObject *resultobj = 0;
27713 wxDateTime *arg1 = (wxDateTime *) 0 ;
27714 wxTimeSpan *arg2 = 0 ;
27715 wxDateTime result;
27716 void *argp1 = 0 ;
27717 int res1 = 0 ;
27718 void *argp2 = 0 ;
27719 int res2 = 0 ;
27720
27721 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27723 if (!SWIG_IsOK(res1)) {
27724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27725 }
27726 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27727 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27728 if (!SWIG_IsOK(res2)) {
27729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27730 }
27731 if (!argp2) {
27732 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27733 }
27734 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27735 {
27736 PyThreadState* __tstate = wxPyBeginAllowThreads();
27737 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27738 wxPyEndAllowThreads(__tstate);
27739 if (PyErr_Occurred()) SWIG_fail;
27740 }
27741 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27742 return resultobj;
27743 fail:
27744 return NULL;
27745 }
27746
27747
27748 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27749 PyObject *resultobj = 0;
27750 wxDateTime *arg1 = (wxDateTime *) 0 ;
27751 wxDateSpan *arg2 = 0 ;
27752 wxDateTime result;
27753 void *argp1 = 0 ;
27754 int res1 = 0 ;
27755 void *argp2 = 0 ;
27756 int res2 = 0 ;
27757
27758 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27760 if (!SWIG_IsOK(res1)) {
27761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27762 }
27763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27764 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27765 if (!SWIG_IsOK(res2)) {
27766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27767 }
27768 if (!argp2) {
27769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27770 }
27771 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27786 int argc;
27787 PyObject *argv[3];
27788
27789 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27790 --argc;
27791 if (argc == 2) {
27792 int _v = 0;
27793 {
27794 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27795 _v = SWIG_CheckState(res);
27796 }
27797 if (!_v) goto check_1;
27798 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27799 }
27800 check_1:
27801
27802 if (argc == 2) {
27803 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27804 }
27805
27806 fail:
27807 Py_INCREF(Py_NotImplemented);
27808 return Py_NotImplemented;
27809 }
27810
27811
27812 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27813 PyObject *resultobj = 0;
27814 wxDateTime *arg1 = (wxDateTime *) 0 ;
27815 wxDateTime *arg2 = 0 ;
27816 wxTimeSpan result;
27817 void *argp1 = 0 ;
27818 int res1 = 0 ;
27819 void *argp2 = 0 ;
27820 int res2 = 0 ;
27821
27822 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27824 if (!SWIG_IsOK(res1)) {
27825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27826 }
27827 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27828 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27829 if (!SWIG_IsOK(res2)) {
27830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27831 }
27832 if (!argp2) {
27833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27834 }
27835 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27839 wxPyEndAllowThreads(__tstate);
27840 if (PyErr_Occurred()) SWIG_fail;
27841 }
27842 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27843 return resultobj;
27844 fail:
27845 return NULL;
27846 }
27847
27848
27849 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27850 PyObject *resultobj = 0;
27851 wxDateTime *arg1 = (wxDateTime *) 0 ;
27852 wxTimeSpan *arg2 = 0 ;
27853 wxDateTime result;
27854 void *argp1 = 0 ;
27855 int res1 = 0 ;
27856 void *argp2 = 0 ;
27857 int res2 = 0 ;
27858
27859 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27861 if (!SWIG_IsOK(res1)) {
27862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27863 }
27864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27865 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27866 if (!SWIG_IsOK(res2)) {
27867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27868 }
27869 if (!argp2) {
27870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27871 }
27872 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27887 PyObject *resultobj = 0;
27888 wxDateTime *arg1 = (wxDateTime *) 0 ;
27889 wxDateSpan *arg2 = 0 ;
27890 wxDateTime result;
27891 void *argp1 = 0 ;
27892 int res1 = 0 ;
27893 void *argp2 = 0 ;
27894 int res2 = 0 ;
27895
27896 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27898 if (!SWIG_IsOK(res1)) {
27899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27900 }
27901 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27902 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27903 if (!SWIG_IsOK(res2)) {
27904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27905 }
27906 if (!argp2) {
27907 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27908 }
27909 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27910 {
27911 PyThreadState* __tstate = wxPyBeginAllowThreads();
27912 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27917 return resultobj;
27918 fail:
27919 return NULL;
27920 }
27921
27922
27923 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27924 int argc;
27925 PyObject *argv[3];
27926
27927 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27928 --argc;
27929 if (argc == 2) {
27930 int _v = 0;
27931 {
27932 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27933 _v = SWIG_CheckState(res);
27934 }
27935 if (!_v) goto check_1;
27936 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27937 }
27938 check_1:
27939
27940 if (argc == 2) {
27941 int _v = 0;
27942 {
27943 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27944 _v = SWIG_CheckState(res);
27945 }
27946 if (!_v) goto check_2;
27947 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27948 }
27949 check_2:
27950
27951 if (argc == 2) {
27952 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27953 }
27954
27955 fail:
27956 Py_INCREF(Py_NotImplemented);
27957 return Py_NotImplemented;
27958 }
27959
27960
27961 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj = 0;
27963 wxDateTime *arg1 = (wxDateTime *) 0 ;
27964 wxDateTime *arg2 = (wxDateTime *) 0 ;
27965 bool result;
27966 void *argp1 = 0 ;
27967 int res1 = 0 ;
27968 void *argp2 = 0 ;
27969 int res2 = 0 ;
27970 PyObject * obj0 = 0 ;
27971 PyObject * obj1 = 0 ;
27972 char * kwnames[] = {
27973 (char *) "self",(char *) "other", NULL
27974 };
27975
27976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27978 if (!SWIG_IsOK(res1)) {
27979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27980 }
27981 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27983 if (!SWIG_IsOK(res2)) {
27984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27985 }
27986 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27987 {
27988 PyThreadState* __tstate = wxPyBeginAllowThreads();
27989 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27990 wxPyEndAllowThreads(__tstate);
27991 if (PyErr_Occurred()) SWIG_fail;
27992 }
27993 {
27994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27995 }
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj = 0;
28004 wxDateTime *arg1 = (wxDateTime *) 0 ;
28005 wxDateTime *arg2 = (wxDateTime *) 0 ;
28006 bool result;
28007 void *argp1 = 0 ;
28008 int res1 = 0 ;
28009 void *argp2 = 0 ;
28010 int res2 = 0 ;
28011 PyObject * obj0 = 0 ;
28012 PyObject * obj1 = 0 ;
28013 char * kwnames[] = {
28014 (char *) "self",(char *) "other", NULL
28015 };
28016
28017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28019 if (!SWIG_IsOK(res1)) {
28020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28021 }
28022 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28023 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28024 if (!SWIG_IsOK(res2)) {
28025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28026 }
28027 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28028 {
28029 PyThreadState* __tstate = wxPyBeginAllowThreads();
28030 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28031 wxPyEndAllowThreads(__tstate);
28032 if (PyErr_Occurred()) SWIG_fail;
28033 }
28034 {
28035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28036 }
28037 return resultobj;
28038 fail:
28039 return NULL;
28040 }
28041
28042
28043 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28044 PyObject *resultobj = 0;
28045 wxDateTime *arg1 = (wxDateTime *) 0 ;
28046 wxDateTime *arg2 = (wxDateTime *) 0 ;
28047 bool result;
28048 void *argp1 = 0 ;
28049 int res1 = 0 ;
28050 void *argp2 = 0 ;
28051 int res2 = 0 ;
28052 PyObject * obj0 = 0 ;
28053 PyObject * obj1 = 0 ;
28054 char * kwnames[] = {
28055 (char *) "self",(char *) "other", NULL
28056 };
28057
28058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28060 if (!SWIG_IsOK(res1)) {
28061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28062 }
28063 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28065 if (!SWIG_IsOK(res2)) {
28066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28067 }
28068 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28069 {
28070 PyThreadState* __tstate = wxPyBeginAllowThreads();
28071 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28072 wxPyEndAllowThreads(__tstate);
28073 if (PyErr_Occurred()) SWIG_fail;
28074 }
28075 {
28076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28077 }
28078 return resultobj;
28079 fail:
28080 return NULL;
28081 }
28082
28083
28084 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28085 PyObject *resultobj = 0;
28086 wxDateTime *arg1 = (wxDateTime *) 0 ;
28087 wxDateTime *arg2 = (wxDateTime *) 0 ;
28088 bool result;
28089 void *argp1 = 0 ;
28090 int res1 = 0 ;
28091 void *argp2 = 0 ;
28092 int res2 = 0 ;
28093 PyObject * obj0 = 0 ;
28094 PyObject * obj1 = 0 ;
28095 char * kwnames[] = {
28096 (char *) "self",(char *) "other", NULL
28097 };
28098
28099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28101 if (!SWIG_IsOK(res1)) {
28102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28103 }
28104 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28106 if (!SWIG_IsOK(res2)) {
28107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28108 }
28109 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28110 {
28111 PyThreadState* __tstate = wxPyBeginAllowThreads();
28112 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 {
28117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28118 }
28119 return resultobj;
28120 fail:
28121 return NULL;
28122 }
28123
28124
28125 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28126 PyObject *resultobj = 0;
28127 wxDateTime *arg1 = (wxDateTime *) 0 ;
28128 wxDateTime *arg2 = (wxDateTime *) 0 ;
28129 bool result;
28130 void *argp1 = 0 ;
28131 int res1 = 0 ;
28132 void *argp2 = 0 ;
28133 int res2 = 0 ;
28134 PyObject * obj0 = 0 ;
28135 PyObject * obj1 = 0 ;
28136 char * kwnames[] = {
28137 (char *) "self",(char *) "other", NULL
28138 };
28139
28140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28142 if (!SWIG_IsOK(res1)) {
28143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28144 }
28145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28147 if (!SWIG_IsOK(res2)) {
28148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28149 }
28150 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28151 {
28152 PyThreadState* __tstate = wxPyBeginAllowThreads();
28153 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28154 wxPyEndAllowThreads(__tstate);
28155 if (PyErr_Occurred()) SWIG_fail;
28156 }
28157 {
28158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28159 }
28160 return resultobj;
28161 fail:
28162 return NULL;
28163 }
28164
28165
28166 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28167 PyObject *resultobj = 0;
28168 wxDateTime *arg1 = (wxDateTime *) 0 ;
28169 wxDateTime *arg2 = (wxDateTime *) 0 ;
28170 bool result;
28171 void *argp1 = 0 ;
28172 int res1 = 0 ;
28173 void *argp2 = 0 ;
28174 int res2 = 0 ;
28175 PyObject * obj0 = 0 ;
28176 PyObject * obj1 = 0 ;
28177 char * kwnames[] = {
28178 (char *) "self",(char *) "other", NULL
28179 };
28180
28181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28183 if (!SWIG_IsOK(res1)) {
28184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28185 }
28186 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28188 if (!SWIG_IsOK(res2)) {
28189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28190 }
28191 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 {
28199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28200 }
28201 return resultobj;
28202 fail:
28203 return NULL;
28204 }
28205
28206
28207 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28208 PyObject *resultobj = 0;
28209 wxDateTime *arg1 = (wxDateTime *) 0 ;
28210 wxString *arg2 = 0 ;
28211 int result;
28212 void *argp1 = 0 ;
28213 int res1 = 0 ;
28214 bool temp2 = false ;
28215 PyObject * obj0 = 0 ;
28216 PyObject * obj1 = 0 ;
28217 char * kwnames[] = {
28218 (char *) "self",(char *) "date", NULL
28219 };
28220
28221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28223 if (!SWIG_IsOK(res1)) {
28224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28225 }
28226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28227 {
28228 arg2 = wxString_in_helper(obj1);
28229 if (arg2 == NULL) SWIG_fail;
28230 temp2 = true;
28231 }
28232 {
28233 PyThreadState* __tstate = wxPyBeginAllowThreads();
28234 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28235 wxPyEndAllowThreads(__tstate);
28236 if (PyErr_Occurred()) SWIG_fail;
28237 }
28238 resultobj = SWIG_From_int(static_cast< int >(result));
28239 {
28240 if (temp2)
28241 delete arg2;
28242 }
28243 return resultobj;
28244 fail:
28245 {
28246 if (temp2)
28247 delete arg2;
28248 }
28249 return NULL;
28250 }
28251
28252
28253 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28254 PyObject *resultobj = 0;
28255 wxDateTime *arg1 = (wxDateTime *) 0 ;
28256 wxString *arg2 = 0 ;
28257 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28258 wxString *arg3 = (wxString *) &arg3_defvalue ;
28259 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28260 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28261 int result;
28262 void *argp1 = 0 ;
28263 int res1 = 0 ;
28264 bool temp2 = false ;
28265 bool temp3 = false ;
28266 void *argp4 = 0 ;
28267 int res4 = 0 ;
28268 PyObject * obj0 = 0 ;
28269 PyObject * obj1 = 0 ;
28270 PyObject * obj2 = 0 ;
28271 PyObject * obj3 = 0 ;
28272 char * kwnames[] = {
28273 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28274 };
28275
28276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28278 if (!SWIG_IsOK(res1)) {
28279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28280 }
28281 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28282 {
28283 arg2 = wxString_in_helper(obj1);
28284 if (arg2 == NULL) SWIG_fail;
28285 temp2 = true;
28286 }
28287 if (obj2) {
28288 {
28289 arg3 = wxString_in_helper(obj2);
28290 if (arg3 == NULL) SWIG_fail;
28291 temp3 = true;
28292 }
28293 }
28294 if (obj3) {
28295 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28296 if (!SWIG_IsOK(res4)) {
28297 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28298 }
28299 if (!argp4) {
28300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28301 }
28302 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28303 }
28304 {
28305 PyThreadState* __tstate = wxPyBeginAllowThreads();
28306 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28307 wxPyEndAllowThreads(__tstate);
28308 if (PyErr_Occurred()) SWIG_fail;
28309 }
28310 resultobj = SWIG_From_int(static_cast< int >(result));
28311 {
28312 if (temp2)
28313 delete arg2;
28314 }
28315 {
28316 if (temp3)
28317 delete arg3;
28318 }
28319 return resultobj;
28320 fail:
28321 {
28322 if (temp2)
28323 delete arg2;
28324 }
28325 {
28326 if (temp3)
28327 delete arg3;
28328 }
28329 return NULL;
28330 }
28331
28332
28333 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28334 PyObject *resultobj = 0;
28335 wxDateTime *arg1 = (wxDateTime *) 0 ;
28336 wxString *arg2 = 0 ;
28337 int result;
28338 void *argp1 = 0 ;
28339 int res1 = 0 ;
28340 bool temp2 = false ;
28341 PyObject * obj0 = 0 ;
28342 PyObject * obj1 = 0 ;
28343 char * kwnames[] = {
28344 (char *) "self",(char *) "datetime", NULL
28345 };
28346
28347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28349 if (!SWIG_IsOK(res1)) {
28350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28351 }
28352 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28353 {
28354 arg2 = wxString_in_helper(obj1);
28355 if (arg2 == NULL) SWIG_fail;
28356 temp2 = true;
28357 }
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28361 wxPyEndAllowThreads(__tstate);
28362 if (PyErr_Occurred()) SWIG_fail;
28363 }
28364 resultobj = SWIG_From_int(static_cast< int >(result));
28365 {
28366 if (temp2)
28367 delete arg2;
28368 }
28369 return resultobj;
28370 fail:
28371 {
28372 if (temp2)
28373 delete arg2;
28374 }
28375 return NULL;
28376 }
28377
28378
28379 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28380 PyObject *resultobj = 0;
28381 wxDateTime *arg1 = (wxDateTime *) 0 ;
28382 wxString *arg2 = 0 ;
28383 int result;
28384 void *argp1 = 0 ;
28385 int res1 = 0 ;
28386 bool temp2 = false ;
28387 PyObject * obj0 = 0 ;
28388 PyObject * obj1 = 0 ;
28389 char * kwnames[] = {
28390 (char *) "self",(char *) "date", NULL
28391 };
28392
28393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28395 if (!SWIG_IsOK(res1)) {
28396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28397 }
28398 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28399 {
28400 arg2 = wxString_in_helper(obj1);
28401 if (arg2 == NULL) SWIG_fail;
28402 temp2 = true;
28403 }
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 resultobj = SWIG_From_int(static_cast< int >(result));
28411 {
28412 if (temp2)
28413 delete arg2;
28414 }
28415 return resultobj;
28416 fail:
28417 {
28418 if (temp2)
28419 delete arg2;
28420 }
28421 return NULL;
28422 }
28423
28424
28425 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28426 PyObject *resultobj = 0;
28427 wxDateTime *arg1 = (wxDateTime *) 0 ;
28428 wxString *arg2 = 0 ;
28429 int result;
28430 void *argp1 = 0 ;
28431 int res1 = 0 ;
28432 bool temp2 = false ;
28433 PyObject * obj0 = 0 ;
28434 PyObject * obj1 = 0 ;
28435 char * kwnames[] = {
28436 (char *) "self",(char *) "time", NULL
28437 };
28438
28439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28441 if (!SWIG_IsOK(res1)) {
28442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28443 }
28444 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28445 {
28446 arg2 = wxString_in_helper(obj1);
28447 if (arg2 == NULL) SWIG_fail;
28448 temp2 = true;
28449 }
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_From_int(static_cast< int >(result));
28457 {
28458 if (temp2)
28459 delete arg2;
28460 }
28461 return resultobj;
28462 fail:
28463 {
28464 if (temp2)
28465 delete arg2;
28466 }
28467 return NULL;
28468 }
28469
28470
28471 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28472 PyObject *resultobj = 0;
28473 wxDateTime *arg1 = (wxDateTime *) 0 ;
28474 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28475 wxString *arg2 = (wxString *) &arg2_defvalue ;
28476 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28477 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28478 wxString result;
28479 void *argp1 = 0 ;
28480 int res1 = 0 ;
28481 bool temp2 = false ;
28482 bool temp3 = false ;
28483 PyObject * obj0 = 0 ;
28484 PyObject * obj1 = 0 ;
28485 PyObject * obj2 = 0 ;
28486 char * kwnames[] = {
28487 (char *) "self",(char *) "format",(char *) "tz", NULL
28488 };
28489
28490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28492 if (!SWIG_IsOK(res1)) {
28493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28494 }
28495 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28496 if (obj1) {
28497 {
28498 arg2 = wxString_in_helper(obj1);
28499 if (arg2 == NULL) SWIG_fail;
28500 temp2 = true;
28501 }
28502 }
28503 if (obj2) {
28504 {
28505 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28506 temp3 = true;
28507 }
28508 }
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 {
28516 #if wxUSE_UNICODE
28517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28518 #else
28519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28520 #endif
28521 }
28522 {
28523 if (temp2)
28524 delete arg2;
28525 }
28526 {
28527 if (temp3) delete arg3;
28528 }
28529 return resultobj;
28530 fail:
28531 {
28532 if (temp2)
28533 delete arg2;
28534 }
28535 {
28536 if (temp3) delete arg3;
28537 }
28538 return NULL;
28539 }
28540
28541
28542 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28543 PyObject *resultobj = 0;
28544 wxDateTime *arg1 = (wxDateTime *) 0 ;
28545 wxString result;
28546 void *argp1 = 0 ;
28547 int res1 = 0 ;
28548 PyObject *swig_obj[1] ;
28549
28550 if (!args) SWIG_fail;
28551 swig_obj[0] = args;
28552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28553 if (!SWIG_IsOK(res1)) {
28554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28555 }
28556 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 result = ((wxDateTime const *)arg1)->FormatDate();
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 {
28564 #if wxUSE_UNICODE
28565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28566 #else
28567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28568 #endif
28569 }
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28577 PyObject *resultobj = 0;
28578 wxDateTime *arg1 = (wxDateTime *) 0 ;
28579 wxString result;
28580 void *argp1 = 0 ;
28581 int res1 = 0 ;
28582 PyObject *swig_obj[1] ;
28583
28584 if (!args) SWIG_fail;
28585 swig_obj[0] = args;
28586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28587 if (!SWIG_IsOK(res1)) {
28588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28589 }
28590 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28591 {
28592 PyThreadState* __tstate = wxPyBeginAllowThreads();
28593 result = ((wxDateTime const *)arg1)->FormatTime();
28594 wxPyEndAllowThreads(__tstate);
28595 if (PyErr_Occurred()) SWIG_fail;
28596 }
28597 {
28598 #if wxUSE_UNICODE
28599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28600 #else
28601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28602 #endif
28603 }
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28611 PyObject *resultobj = 0;
28612 wxDateTime *arg1 = (wxDateTime *) 0 ;
28613 wxString result;
28614 void *argp1 = 0 ;
28615 int res1 = 0 ;
28616 PyObject *swig_obj[1] ;
28617
28618 if (!args) SWIG_fail;
28619 swig_obj[0] = args;
28620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28621 if (!SWIG_IsOK(res1)) {
28622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28623 }
28624 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 result = ((wxDateTime const *)arg1)->FormatISODate();
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 {
28632 #if wxUSE_UNICODE
28633 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28634 #else
28635 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28636 #endif
28637 }
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxDateTime *arg1 = (wxDateTime *) 0 ;
28647 wxString result;
28648 void *argp1 = 0 ;
28649 int res1 = 0 ;
28650 PyObject *swig_obj[1] ;
28651
28652 if (!args) SWIG_fail;
28653 swig_obj[0] = args;
28654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28657 }
28658 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = ((wxDateTime const *)arg1)->FormatISOTime();
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 {
28666 #if wxUSE_UNICODE
28667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28668 #else
28669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28670 #endif
28671 }
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28679 PyObject *obj;
28680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28681 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28682 return SWIG_Py_Void();
28683 }
28684
28685 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28686 return SWIG_Python_InitShadowInstance(args);
28687 }
28688
28689 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28690 PyObject *resultobj = 0;
28691 long arg1 ;
28692 wxTimeSpan result;
28693 long val1 ;
28694 int ecode1 = 0 ;
28695 PyObject * obj0 = 0 ;
28696 char * kwnames[] = {
28697 (char *) "ms", NULL
28698 };
28699
28700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28701 ecode1 = SWIG_AsVal_long(obj0, &val1);
28702 if (!SWIG_IsOK(ecode1)) {
28703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28704 }
28705 arg1 = static_cast< long >(val1);
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 result = wxTimeSpan::Milliseconds(arg1);
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28720 PyObject *resultobj = 0;
28721 wxTimeSpan result;
28722
28723 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28724 {
28725 PyThreadState* __tstate = wxPyBeginAllowThreads();
28726 result = wxTimeSpan::Millisecond();
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28738 PyObject *resultobj = 0;
28739 long arg1 ;
28740 wxTimeSpan result;
28741 long val1 ;
28742 int ecode1 = 0 ;
28743 PyObject * obj0 = 0 ;
28744 char * kwnames[] = {
28745 (char *) "sec", NULL
28746 };
28747
28748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28749 ecode1 = SWIG_AsVal_long(obj0, &val1);
28750 if (!SWIG_IsOK(ecode1)) {
28751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28752 }
28753 arg1 = static_cast< long >(val1);
28754 {
28755 PyThreadState* __tstate = wxPyBeginAllowThreads();
28756 result = wxTimeSpan::Seconds(arg1);
28757 wxPyEndAllowThreads(__tstate);
28758 if (PyErr_Occurred()) SWIG_fail;
28759 }
28760 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28761 return resultobj;
28762 fail:
28763 return NULL;
28764 }
28765
28766
28767 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28768 PyObject *resultobj = 0;
28769 wxTimeSpan result;
28770
28771 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28772 {
28773 PyThreadState* __tstate = wxPyBeginAllowThreads();
28774 result = wxTimeSpan::Second();
28775 wxPyEndAllowThreads(__tstate);
28776 if (PyErr_Occurred()) SWIG_fail;
28777 }
28778 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28779 return resultobj;
28780 fail:
28781 return NULL;
28782 }
28783
28784
28785 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28786 PyObject *resultobj = 0;
28787 long arg1 ;
28788 wxTimeSpan result;
28789 long val1 ;
28790 int ecode1 = 0 ;
28791 PyObject * obj0 = 0 ;
28792 char * kwnames[] = {
28793 (char *) "min", NULL
28794 };
28795
28796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28797 ecode1 = SWIG_AsVal_long(obj0, &val1);
28798 if (!SWIG_IsOK(ecode1)) {
28799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28800 }
28801 arg1 = static_cast< long >(val1);
28802 {
28803 PyThreadState* __tstate = wxPyBeginAllowThreads();
28804 result = wxTimeSpan::Minutes(arg1);
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28816 PyObject *resultobj = 0;
28817 wxTimeSpan result;
28818
28819 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28820 {
28821 PyThreadState* __tstate = wxPyBeginAllowThreads();
28822 result = wxTimeSpan::Minute();
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28834 PyObject *resultobj = 0;
28835 long arg1 ;
28836 wxTimeSpan result;
28837 long val1 ;
28838 int ecode1 = 0 ;
28839 PyObject * obj0 = 0 ;
28840 char * kwnames[] = {
28841 (char *) "hours", NULL
28842 };
28843
28844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28845 ecode1 = SWIG_AsVal_long(obj0, &val1);
28846 if (!SWIG_IsOK(ecode1)) {
28847 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28848 }
28849 arg1 = static_cast< long >(val1);
28850 {
28851 PyThreadState* __tstate = wxPyBeginAllowThreads();
28852 result = wxTimeSpan::Hours(arg1);
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28864 PyObject *resultobj = 0;
28865 wxTimeSpan result;
28866
28867 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28868 {
28869 PyThreadState* __tstate = wxPyBeginAllowThreads();
28870 result = wxTimeSpan::Hour();
28871 wxPyEndAllowThreads(__tstate);
28872 if (PyErr_Occurred()) SWIG_fail;
28873 }
28874 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28875 return resultobj;
28876 fail:
28877 return NULL;
28878 }
28879
28880
28881 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28882 PyObject *resultobj = 0;
28883 long arg1 ;
28884 wxTimeSpan result;
28885 long val1 ;
28886 int ecode1 = 0 ;
28887 PyObject * obj0 = 0 ;
28888 char * kwnames[] = {
28889 (char *) "days", NULL
28890 };
28891
28892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28893 ecode1 = SWIG_AsVal_long(obj0, &val1);
28894 if (!SWIG_IsOK(ecode1)) {
28895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28896 }
28897 arg1 = static_cast< long >(val1);
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 result = wxTimeSpan::Days(arg1);
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28912 PyObject *resultobj = 0;
28913 wxTimeSpan result;
28914
28915 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28916 {
28917 PyThreadState* __tstate = wxPyBeginAllowThreads();
28918 result = wxTimeSpan::Day();
28919 wxPyEndAllowThreads(__tstate);
28920 if (PyErr_Occurred()) SWIG_fail;
28921 }
28922 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28923 return resultobj;
28924 fail:
28925 return NULL;
28926 }
28927
28928
28929 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28930 PyObject *resultobj = 0;
28931 long arg1 ;
28932 wxTimeSpan result;
28933 long val1 ;
28934 int ecode1 = 0 ;
28935 PyObject * obj0 = 0 ;
28936 char * kwnames[] = {
28937 (char *) "days", NULL
28938 };
28939
28940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28941 ecode1 = SWIG_AsVal_long(obj0, &val1);
28942 if (!SWIG_IsOK(ecode1)) {
28943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28944 }
28945 arg1 = static_cast< long >(val1);
28946 {
28947 PyThreadState* __tstate = wxPyBeginAllowThreads();
28948 result = wxTimeSpan::Weeks(arg1);
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28960 PyObject *resultobj = 0;
28961 wxTimeSpan result;
28962
28963 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28964 {
28965 PyThreadState* __tstate = wxPyBeginAllowThreads();
28966 result = wxTimeSpan::Week();
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28971 return resultobj;
28972 fail:
28973 return NULL;
28974 }
28975
28976
28977 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28978 PyObject *resultobj = 0;
28979 long arg1 = (long) 0 ;
28980 long arg2 = (long) 0 ;
28981 long arg3 = (long) 0 ;
28982 long arg4 = (long) 0 ;
28983 wxTimeSpan *result = 0 ;
28984 long val1 ;
28985 int ecode1 = 0 ;
28986 long val2 ;
28987 int ecode2 = 0 ;
28988 long val3 ;
28989 int ecode3 = 0 ;
28990 long val4 ;
28991 int ecode4 = 0 ;
28992 PyObject * obj0 = 0 ;
28993 PyObject * obj1 = 0 ;
28994 PyObject * obj2 = 0 ;
28995 PyObject * obj3 = 0 ;
28996 char * kwnames[] = {
28997 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28998 };
28999
29000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29001 if (obj0) {
29002 ecode1 = SWIG_AsVal_long(obj0, &val1);
29003 if (!SWIG_IsOK(ecode1)) {
29004 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
29005 }
29006 arg1 = static_cast< long >(val1);
29007 }
29008 if (obj1) {
29009 ecode2 = SWIG_AsVal_long(obj1, &val2);
29010 if (!SWIG_IsOK(ecode2)) {
29011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
29012 }
29013 arg2 = static_cast< long >(val2);
29014 }
29015 if (obj2) {
29016 ecode3 = SWIG_AsVal_long(obj2, &val3);
29017 if (!SWIG_IsOK(ecode3)) {
29018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
29019 }
29020 arg3 = static_cast< long >(val3);
29021 }
29022 if (obj3) {
29023 ecode4 = SWIG_AsVal_long(obj3, &val4);
29024 if (!SWIG_IsOK(ecode4)) {
29025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
29026 }
29027 arg4 = static_cast< long >(val4);
29028 }
29029 {
29030 PyThreadState* __tstate = wxPyBeginAllowThreads();
29031 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29036 return resultobj;
29037 fail:
29038 return NULL;
29039 }
29040
29041
29042 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29043 PyObject *resultobj = 0;
29044 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29045 void *argp1 = 0 ;
29046 int res1 = 0 ;
29047 PyObject *swig_obj[1] ;
29048
29049 if (!args) SWIG_fail;
29050 swig_obj[0] = args;
29051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29052 if (!SWIG_IsOK(res1)) {
29053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29054 }
29055 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 delete arg1;
29059
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_Py_Void();
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29071 PyObject *resultobj = 0;
29072 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29073 wxTimeSpan *arg2 = 0 ;
29074 wxTimeSpan *result = 0 ;
29075 void *argp1 = 0 ;
29076 int res1 = 0 ;
29077 void *argp2 = 0 ;
29078 int res2 = 0 ;
29079 PyObject * obj0 = 0 ;
29080 PyObject * obj1 = 0 ;
29081 char * kwnames[] = {
29082 (char *) "self",(char *) "diff", NULL
29083 };
29084
29085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29087 if (!SWIG_IsOK(res1)) {
29088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29089 }
29090 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29091 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29092 if (!SWIG_IsOK(res2)) {
29093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29094 }
29095 if (!argp2) {
29096 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29097 }
29098 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 {
29102 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29103 result = (wxTimeSpan *) &_result_ref;
29104 }
29105 wxPyEndAllowThreads(__tstate);
29106 if (PyErr_Occurred()) SWIG_fail;
29107 }
29108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29109 return resultobj;
29110 fail:
29111 return NULL;
29112 }
29113
29114
29115 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29116 PyObject *resultobj = 0;
29117 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29118 wxTimeSpan *arg2 = 0 ;
29119 wxTimeSpan *result = 0 ;
29120 void *argp1 = 0 ;
29121 int res1 = 0 ;
29122 void *argp2 = 0 ;
29123 int res2 = 0 ;
29124 PyObject * obj0 = 0 ;
29125 PyObject * obj1 = 0 ;
29126 char * kwnames[] = {
29127 (char *) "self",(char *) "diff", NULL
29128 };
29129
29130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29132 if (!SWIG_IsOK(res1)) {
29133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29134 }
29135 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29136 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29137 if (!SWIG_IsOK(res2)) {
29138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29139 }
29140 if (!argp2) {
29141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29142 }
29143 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29144 {
29145 PyThreadState* __tstate = wxPyBeginAllowThreads();
29146 {
29147 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29148 result = (wxTimeSpan *) &_result_ref;
29149 }
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29161 PyObject *resultobj = 0;
29162 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29163 int arg2 ;
29164 wxTimeSpan *result = 0 ;
29165 void *argp1 = 0 ;
29166 int res1 = 0 ;
29167 int val2 ;
29168 int ecode2 = 0 ;
29169 PyObject * obj0 = 0 ;
29170 PyObject * obj1 = 0 ;
29171 char * kwnames[] = {
29172 (char *) "self",(char *) "n", NULL
29173 };
29174
29175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29177 if (!SWIG_IsOK(res1)) {
29178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29179 }
29180 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29181 ecode2 = SWIG_AsVal_int(obj1, &val2);
29182 if (!SWIG_IsOK(ecode2)) {
29183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29184 }
29185 arg2 = static_cast< int >(val2);
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 {
29189 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29190 result = (wxTimeSpan *) &_result_ref;
29191 }
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29203 PyObject *resultobj = 0;
29204 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29205 wxTimeSpan *result = 0 ;
29206 void *argp1 = 0 ;
29207 int res1 = 0 ;
29208 PyObject *swig_obj[1] ;
29209
29210 if (!args) SWIG_fail;
29211 swig_obj[0] = args;
29212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29213 if (!SWIG_IsOK(res1)) {
29214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29215 }
29216 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29217 {
29218 PyThreadState* __tstate = wxPyBeginAllowThreads();
29219 {
29220 wxTimeSpan &_result_ref = (arg1)->Neg();
29221 result = (wxTimeSpan *) &_result_ref;
29222 }
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29234 PyObject *resultobj = 0;
29235 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29236 wxTimeSpan result;
29237 void *argp1 = 0 ;
29238 int res1 = 0 ;
29239 PyObject *swig_obj[1] ;
29240
29241 if (!args) SWIG_fail;
29242 swig_obj[0] = args;
29243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29244 if (!SWIG_IsOK(res1)) {
29245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29246 }
29247 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29248 {
29249 PyThreadState* __tstate = wxPyBeginAllowThreads();
29250 result = ((wxTimeSpan const *)arg1)->Abs();
29251 wxPyEndAllowThreads(__tstate);
29252 if (PyErr_Occurred()) SWIG_fail;
29253 }
29254 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29262 PyObject *resultobj = 0;
29263 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29264 wxTimeSpan *arg2 = 0 ;
29265 wxTimeSpan *result = 0 ;
29266 void *argp1 = 0 ;
29267 int res1 = 0 ;
29268 void *argp2 = 0 ;
29269 int res2 = 0 ;
29270 PyObject * obj0 = 0 ;
29271 PyObject * obj1 = 0 ;
29272 char * kwnames[] = {
29273 (char *) "self",(char *) "diff", NULL
29274 };
29275
29276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29278 if (!SWIG_IsOK(res1)) {
29279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29280 }
29281 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29282 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29283 if (!SWIG_IsOK(res2)) {
29284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29285 }
29286 if (!argp2) {
29287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29288 }
29289 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29290 {
29291 PyThreadState* __tstate = wxPyBeginAllowThreads();
29292 {
29293 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29294 result = (wxTimeSpan *) &_result_ref;
29295 }
29296 wxPyEndAllowThreads(__tstate);
29297 if (PyErr_Occurred()) SWIG_fail;
29298 }
29299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29300 return resultobj;
29301 fail:
29302 return NULL;
29303 }
29304
29305
29306 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29307 PyObject *resultobj = 0;
29308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29309 wxTimeSpan *arg2 = 0 ;
29310 wxTimeSpan *result = 0 ;
29311 void *argp1 = 0 ;
29312 int res1 = 0 ;
29313 void *argp2 = 0 ;
29314 int res2 = 0 ;
29315 PyObject * obj0 = 0 ;
29316 PyObject * obj1 = 0 ;
29317 char * kwnames[] = {
29318 (char *) "self",(char *) "diff", NULL
29319 };
29320
29321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29323 if (!SWIG_IsOK(res1)) {
29324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29325 }
29326 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29327 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29328 if (!SWIG_IsOK(res2)) {
29329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29330 }
29331 if (!argp2) {
29332 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29333 }
29334 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 {
29338 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29339 result = (wxTimeSpan *) &_result_ref;
29340 }
29341 wxPyEndAllowThreads(__tstate);
29342 if (PyErr_Occurred()) SWIG_fail;
29343 }
29344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29352 PyObject *resultobj = 0;
29353 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29354 int arg2 ;
29355 wxTimeSpan *result = 0 ;
29356 void *argp1 = 0 ;
29357 int res1 = 0 ;
29358 int val2 ;
29359 int ecode2 = 0 ;
29360 PyObject * obj0 = 0 ;
29361 PyObject * obj1 = 0 ;
29362 char * kwnames[] = {
29363 (char *) "self",(char *) "n", NULL
29364 };
29365
29366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29368 if (!SWIG_IsOK(res1)) {
29369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29370 }
29371 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29372 ecode2 = SWIG_AsVal_int(obj1, &val2);
29373 if (!SWIG_IsOK(ecode2)) {
29374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29375 }
29376 arg2 = static_cast< int >(val2);
29377 {
29378 PyThreadState* __tstate = wxPyBeginAllowThreads();
29379 {
29380 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29381 result = (wxTimeSpan *) &_result_ref;
29382 }
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29394 PyObject *resultobj = 0;
29395 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29396 wxTimeSpan *result = 0 ;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 PyObject *swig_obj[1] ;
29400
29401 if (!args) SWIG_fail;
29402 swig_obj[0] = args;
29403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29404 if (!SWIG_IsOK(res1)) {
29405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29406 }
29407 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29408 {
29409 PyThreadState* __tstate = wxPyBeginAllowThreads();
29410 {
29411 wxTimeSpan &_result_ref = (arg1)->operator -();
29412 result = (wxTimeSpan *) &_result_ref;
29413 }
29414 wxPyEndAllowThreads(__tstate);
29415 if (PyErr_Occurred()) SWIG_fail;
29416 }
29417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29418 return resultobj;
29419 fail:
29420 return NULL;
29421 }
29422
29423
29424 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29425 PyObject *resultobj = 0;
29426 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29427 wxTimeSpan *arg2 = 0 ;
29428 wxTimeSpan result;
29429 void *argp1 = 0 ;
29430 int res1 = 0 ;
29431 void *argp2 = 0 ;
29432 int res2 = 0 ;
29433 PyObject * obj0 = 0 ;
29434 PyObject * obj1 = 0 ;
29435 char * kwnames[] = {
29436 (char *) "self",(char *) "other", NULL
29437 };
29438
29439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29441 if (!SWIG_IsOK(res1)) {
29442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29443 }
29444 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29445 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29446 if (!SWIG_IsOK(res2)) {
29447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29448 }
29449 if (!argp2) {
29450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29451 }
29452 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29453 {
29454 PyThreadState* __tstate = wxPyBeginAllowThreads();
29455 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29456 wxPyEndAllowThreads(__tstate);
29457 if (PyErr_Occurred()) SWIG_fail;
29458 }
29459 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29460 return resultobj;
29461 fail:
29462 return NULL;
29463 }
29464
29465
29466 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29467 PyObject *resultobj = 0;
29468 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29469 wxTimeSpan *arg2 = 0 ;
29470 wxTimeSpan result;
29471 void *argp1 = 0 ;
29472 int res1 = 0 ;
29473 void *argp2 = 0 ;
29474 int res2 = 0 ;
29475 PyObject * obj0 = 0 ;
29476 PyObject * obj1 = 0 ;
29477 char * kwnames[] = {
29478 (char *) "self",(char *) "other", NULL
29479 };
29480
29481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29483 if (!SWIG_IsOK(res1)) {
29484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29485 }
29486 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29487 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29488 if (!SWIG_IsOK(res2)) {
29489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29490 }
29491 if (!argp2) {
29492 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29493 }
29494 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29495 {
29496 PyThreadState* __tstate = wxPyBeginAllowThreads();
29497 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29498 wxPyEndAllowThreads(__tstate);
29499 if (PyErr_Occurred()) SWIG_fail;
29500 }
29501 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29509 PyObject *resultobj = 0;
29510 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29511 int arg2 ;
29512 wxTimeSpan result;
29513 void *argp1 = 0 ;
29514 int res1 = 0 ;
29515 int val2 ;
29516 int ecode2 = 0 ;
29517 PyObject * obj0 = 0 ;
29518 PyObject * obj1 = 0 ;
29519 char * kwnames[] = {
29520 (char *) "self",(char *) "n", NULL
29521 };
29522
29523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29525 if (!SWIG_IsOK(res1)) {
29526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29527 }
29528 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29529 ecode2 = SWIG_AsVal_int(obj1, &val2);
29530 if (!SWIG_IsOK(ecode2)) {
29531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29532 }
29533 arg2 = static_cast< int >(val2);
29534 {
29535 PyThreadState* __tstate = wxPyBeginAllowThreads();
29536 result = wxTimeSpan___mul__(arg1,arg2);
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj = 0;
29549 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29550 int arg2 ;
29551 wxTimeSpan result;
29552 void *argp1 = 0 ;
29553 int res1 = 0 ;
29554 int val2 ;
29555 int ecode2 = 0 ;
29556 PyObject * obj0 = 0 ;
29557 PyObject * obj1 = 0 ;
29558 char * kwnames[] = {
29559 (char *) "self",(char *) "n", NULL
29560 };
29561
29562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29564 if (!SWIG_IsOK(res1)) {
29565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29566 }
29567 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29568 ecode2 = SWIG_AsVal_int(obj1, &val2);
29569 if (!SWIG_IsOK(ecode2)) {
29570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29571 }
29572 arg2 = static_cast< int >(val2);
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 result = wxTimeSpan___rmul__(arg1,arg2);
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29580 return resultobj;
29581 fail:
29582 return NULL;
29583 }
29584
29585
29586 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29587 PyObject *resultobj = 0;
29588 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29589 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29590 bool result;
29591 void *argp1 = 0 ;
29592 int res1 = 0 ;
29593 void *argp2 = 0 ;
29594 int res2 = 0 ;
29595 PyObject * obj0 = 0 ;
29596 PyObject * obj1 = 0 ;
29597 char * kwnames[] = {
29598 (char *) "self",(char *) "other", NULL
29599 };
29600
29601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29603 if (!SWIG_IsOK(res1)) {
29604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29605 }
29606 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29608 if (!SWIG_IsOK(res2)) {
29609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29610 }
29611 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29612 {
29613 PyThreadState* __tstate = wxPyBeginAllowThreads();
29614 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29615 wxPyEndAllowThreads(__tstate);
29616 if (PyErr_Occurred()) SWIG_fail;
29617 }
29618 {
29619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29620 }
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29628 PyObject *resultobj = 0;
29629 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29630 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29631 bool result;
29632 void *argp1 = 0 ;
29633 int res1 = 0 ;
29634 void *argp2 = 0 ;
29635 int res2 = 0 ;
29636 PyObject * obj0 = 0 ;
29637 PyObject * obj1 = 0 ;
29638 char * kwnames[] = {
29639 (char *) "self",(char *) "other", NULL
29640 };
29641
29642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29644 if (!SWIG_IsOK(res1)) {
29645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29646 }
29647 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29648 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29649 if (!SWIG_IsOK(res2)) {
29650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29651 }
29652 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29653 {
29654 PyThreadState* __tstate = wxPyBeginAllowThreads();
29655 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29656 wxPyEndAllowThreads(__tstate);
29657 if (PyErr_Occurred()) SWIG_fail;
29658 }
29659 {
29660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29661 }
29662 return resultobj;
29663 fail:
29664 return NULL;
29665 }
29666
29667
29668 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29669 PyObject *resultobj = 0;
29670 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29671 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29672 bool result;
29673 void *argp1 = 0 ;
29674 int res1 = 0 ;
29675 void *argp2 = 0 ;
29676 int res2 = 0 ;
29677 PyObject * obj0 = 0 ;
29678 PyObject * obj1 = 0 ;
29679 char * kwnames[] = {
29680 (char *) "self",(char *) "other", NULL
29681 };
29682
29683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29685 if (!SWIG_IsOK(res1)) {
29686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29687 }
29688 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29690 if (!SWIG_IsOK(res2)) {
29691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29692 }
29693 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29702 }
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj = 0;
29711 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29712 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29713 bool result;
29714 void *argp1 = 0 ;
29715 int res1 = 0 ;
29716 void *argp2 = 0 ;
29717 int res2 = 0 ;
29718 PyObject * obj0 = 0 ;
29719 PyObject * obj1 = 0 ;
29720 char * kwnames[] = {
29721 (char *) "self",(char *) "other", NULL
29722 };
29723
29724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29726 if (!SWIG_IsOK(res1)) {
29727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29728 }
29729 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29731 if (!SWIG_IsOK(res2)) {
29732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29733 }
29734 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 {
29742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29743 }
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29751 PyObject *resultobj = 0;
29752 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29753 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29754 bool result;
29755 void *argp1 = 0 ;
29756 int res1 = 0 ;
29757 void *argp2 = 0 ;
29758 int res2 = 0 ;
29759 PyObject * obj0 = 0 ;
29760 PyObject * obj1 = 0 ;
29761 char * kwnames[] = {
29762 (char *) "self",(char *) "other", NULL
29763 };
29764
29765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29767 if (!SWIG_IsOK(res1)) {
29768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29769 }
29770 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29772 if (!SWIG_IsOK(res2)) {
29773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29774 }
29775 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29776 {
29777 PyThreadState* __tstate = wxPyBeginAllowThreads();
29778 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29779 wxPyEndAllowThreads(__tstate);
29780 if (PyErr_Occurred()) SWIG_fail;
29781 }
29782 {
29783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29784 }
29785 return resultobj;
29786 fail:
29787 return NULL;
29788 }
29789
29790
29791 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29792 PyObject *resultobj = 0;
29793 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29794 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29795 bool result;
29796 void *argp1 = 0 ;
29797 int res1 = 0 ;
29798 void *argp2 = 0 ;
29799 int res2 = 0 ;
29800 PyObject * obj0 = 0 ;
29801 PyObject * obj1 = 0 ;
29802 char * kwnames[] = {
29803 (char *) "self",(char *) "other", NULL
29804 };
29805
29806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29808 if (!SWIG_IsOK(res1)) {
29809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29810 }
29811 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29813 if (!SWIG_IsOK(res2)) {
29814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29815 }
29816 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29817 {
29818 PyThreadState* __tstate = wxPyBeginAllowThreads();
29819 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29820 wxPyEndAllowThreads(__tstate);
29821 if (PyErr_Occurred()) SWIG_fail;
29822 }
29823 {
29824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29825 }
29826 return resultobj;
29827 fail:
29828 return NULL;
29829 }
29830
29831
29832 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29833 PyObject *resultobj = 0;
29834 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29835 bool result;
29836 void *argp1 = 0 ;
29837 int res1 = 0 ;
29838 PyObject *swig_obj[1] ;
29839
29840 if (!args) SWIG_fail;
29841 swig_obj[0] = args;
29842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29843 if (!SWIG_IsOK(res1)) {
29844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29845 }
29846 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29847 {
29848 PyThreadState* __tstate = wxPyBeginAllowThreads();
29849 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29850 wxPyEndAllowThreads(__tstate);
29851 if (PyErr_Occurred()) SWIG_fail;
29852 }
29853 {
29854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29855 }
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29863 PyObject *resultobj = 0;
29864 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29865 bool result;
29866 void *argp1 = 0 ;
29867 int res1 = 0 ;
29868 PyObject *swig_obj[1] ;
29869
29870 if (!args) SWIG_fail;
29871 swig_obj[0] = args;
29872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29873 if (!SWIG_IsOK(res1)) {
29874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29875 }
29876 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29880 wxPyEndAllowThreads(__tstate);
29881 if (PyErr_Occurred()) SWIG_fail;
29882 }
29883 {
29884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29885 }
29886 return resultobj;
29887 fail:
29888 return NULL;
29889 }
29890
29891
29892 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29893 PyObject *resultobj = 0;
29894 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29895 bool result;
29896 void *argp1 = 0 ;
29897 int res1 = 0 ;
29898 PyObject *swig_obj[1] ;
29899
29900 if (!args) SWIG_fail;
29901 swig_obj[0] = args;
29902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29903 if (!SWIG_IsOK(res1)) {
29904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29905 }
29906 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29907 {
29908 PyThreadState* __tstate = wxPyBeginAllowThreads();
29909 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29910 wxPyEndAllowThreads(__tstate);
29911 if (PyErr_Occurred()) SWIG_fail;
29912 }
29913 {
29914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29915 }
29916 return resultobj;
29917 fail:
29918 return NULL;
29919 }
29920
29921
29922 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29923 PyObject *resultobj = 0;
29924 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29925 wxTimeSpan *arg2 = 0 ;
29926 bool result;
29927 void *argp1 = 0 ;
29928 int res1 = 0 ;
29929 void *argp2 = 0 ;
29930 int res2 = 0 ;
29931 PyObject * obj0 = 0 ;
29932 PyObject * obj1 = 0 ;
29933 char * kwnames[] = {
29934 (char *) "self",(char *) "ts", NULL
29935 };
29936
29937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29939 if (!SWIG_IsOK(res1)) {
29940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29941 }
29942 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29943 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29944 if (!SWIG_IsOK(res2)) {
29945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29946 }
29947 if (!argp2) {
29948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29949 }
29950 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 {
29958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29959 }
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj = 0;
29968 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29969 wxTimeSpan *arg2 = 0 ;
29970 bool result;
29971 void *argp1 = 0 ;
29972 int res1 = 0 ;
29973 void *argp2 = 0 ;
29974 int res2 = 0 ;
29975 PyObject * obj0 = 0 ;
29976 PyObject * obj1 = 0 ;
29977 char * kwnames[] = {
29978 (char *) "self",(char *) "ts", NULL
29979 };
29980
29981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29983 if (!SWIG_IsOK(res1)) {
29984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29985 }
29986 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29987 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29988 if (!SWIG_IsOK(res2)) {
29989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29990 }
29991 if (!argp2) {
29992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29993 }
29994 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29995 {
29996 PyThreadState* __tstate = wxPyBeginAllowThreads();
29997 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29998 wxPyEndAllowThreads(__tstate);
29999 if (PyErr_Occurred()) SWIG_fail;
30000 }
30001 {
30002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30003 }
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30011 PyObject *resultobj = 0;
30012 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30013 wxTimeSpan *arg2 = 0 ;
30014 bool result;
30015 void *argp1 = 0 ;
30016 int res1 = 0 ;
30017 void *argp2 = 0 ;
30018 int res2 = 0 ;
30019 PyObject * obj0 = 0 ;
30020 PyObject * obj1 = 0 ;
30021 char * kwnames[] = {
30022 (char *) "self",(char *) "t", NULL
30023 };
30024
30025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
30026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30027 if (!SWIG_IsOK(res1)) {
30028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30029 }
30030 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30031 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30032 if (!SWIG_IsOK(res2)) {
30033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30034 }
30035 if (!argp2) {
30036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30037 }
30038 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30039 {
30040 PyThreadState* __tstate = wxPyBeginAllowThreads();
30041 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30042 wxPyEndAllowThreads(__tstate);
30043 if (PyErr_Occurred()) SWIG_fail;
30044 }
30045 {
30046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30047 }
30048 return resultobj;
30049 fail:
30050 return NULL;
30051 }
30052
30053
30054 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30055 PyObject *resultobj = 0;
30056 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30057 int result;
30058 void *argp1 = 0 ;
30059 int res1 = 0 ;
30060 PyObject *swig_obj[1] ;
30061
30062 if (!args) SWIG_fail;
30063 swig_obj[0] = args;
30064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30065 if (!SWIG_IsOK(res1)) {
30066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30067 }
30068 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 resultobj = SWIG_From_int(static_cast< int >(result));
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30083 PyObject *resultobj = 0;
30084 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30085 int result;
30086 void *argp1 = 0 ;
30087 int res1 = 0 ;
30088 PyObject *swig_obj[1] ;
30089
30090 if (!args) SWIG_fail;
30091 swig_obj[0] = args;
30092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30093 if (!SWIG_IsOK(res1)) {
30094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30095 }
30096 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30097 {
30098 PyThreadState* __tstate = wxPyBeginAllowThreads();
30099 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30100 wxPyEndAllowThreads(__tstate);
30101 if (PyErr_Occurred()) SWIG_fail;
30102 }
30103 resultobj = SWIG_From_int(static_cast< int >(result));
30104 return resultobj;
30105 fail:
30106 return NULL;
30107 }
30108
30109
30110 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30111 PyObject *resultobj = 0;
30112 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30113 int result;
30114 void *argp1 = 0 ;
30115 int res1 = 0 ;
30116 PyObject *swig_obj[1] ;
30117
30118 if (!args) SWIG_fail;
30119 swig_obj[0] = args;
30120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30121 if (!SWIG_IsOK(res1)) {
30122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30123 }
30124 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30128 wxPyEndAllowThreads(__tstate);
30129 if (PyErr_Occurred()) SWIG_fail;
30130 }
30131 resultobj = SWIG_From_int(static_cast< int >(result));
30132 return resultobj;
30133 fail:
30134 return NULL;
30135 }
30136
30137
30138 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30139 PyObject *resultobj = 0;
30140 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30141 int result;
30142 void *argp1 = 0 ;
30143 int res1 = 0 ;
30144 PyObject *swig_obj[1] ;
30145
30146 if (!args) SWIG_fail;
30147 swig_obj[0] = args;
30148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30149 if (!SWIG_IsOK(res1)) {
30150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30151 }
30152 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30153 {
30154 PyThreadState* __tstate = wxPyBeginAllowThreads();
30155 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30156 wxPyEndAllowThreads(__tstate);
30157 if (PyErr_Occurred()) SWIG_fail;
30158 }
30159 resultobj = SWIG_From_int(static_cast< int >(result));
30160 return resultobj;
30161 fail:
30162 return NULL;
30163 }
30164
30165
30166 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30167 PyObject *resultobj = 0;
30168 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30169 wxLongLong result;
30170 void *argp1 = 0 ;
30171 int res1 = 0 ;
30172 PyObject *swig_obj[1] ;
30173
30174 if (!args) SWIG_fail;
30175 swig_obj[0] = args;
30176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30177 if (!SWIG_IsOK(res1)) {
30178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30179 }
30180 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30181 {
30182 PyThreadState* __tstate = wxPyBeginAllowThreads();
30183 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 {
30188 PyObject *hi, *lo, *shifter, *shifted;
30189 hi = PyLong_FromLong( (&result)->GetHi() );
30190 lo = PyLong_FromLong( (&result)->GetLo() );
30191 shifter = PyLong_FromLong(32);
30192 shifted = PyNumber_Lshift(hi, shifter);
30193 resultobj = PyNumber_Or(shifted, lo);
30194 Py_DECREF(hi);
30195 Py_DECREF(lo);
30196 Py_DECREF(shifter);
30197 Py_DECREF(shifted);
30198 }
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30206 PyObject *resultobj = 0;
30207 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30208 wxLongLong result;
30209 void *argp1 = 0 ;
30210 int res1 = 0 ;
30211 PyObject *swig_obj[1] ;
30212
30213 if (!args) SWIG_fail;
30214 swig_obj[0] = args;
30215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30216 if (!SWIG_IsOK(res1)) {
30217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30218 }
30219 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30220 {
30221 PyThreadState* __tstate = wxPyBeginAllowThreads();
30222 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 {
30227 PyObject *hi, *lo, *shifter, *shifted;
30228 hi = PyLong_FromLong( (&result)->GetHi() );
30229 lo = PyLong_FromLong( (&result)->GetLo() );
30230 shifter = PyLong_FromLong(32);
30231 shifted = PyNumber_Lshift(hi, shifter);
30232 resultobj = PyNumber_Or(shifted, lo);
30233 Py_DECREF(hi);
30234 Py_DECREF(lo);
30235 Py_DECREF(shifter);
30236 Py_DECREF(shifted);
30237 }
30238 return resultobj;
30239 fail:
30240 return NULL;
30241 }
30242
30243
30244 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30245 PyObject *resultobj = 0;
30246 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30247 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30248 wxString *arg2 = (wxString *) &arg2_defvalue ;
30249 wxString result;
30250 void *argp1 = 0 ;
30251 int res1 = 0 ;
30252 bool temp2 = false ;
30253 PyObject * obj0 = 0 ;
30254 PyObject * obj1 = 0 ;
30255 char * kwnames[] = {
30256 (char *) "self",(char *) "format", NULL
30257 };
30258
30259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30261 if (!SWIG_IsOK(res1)) {
30262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30263 }
30264 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30265 if (obj1) {
30266 {
30267 arg2 = wxString_in_helper(obj1);
30268 if (arg2 == NULL) SWIG_fail;
30269 temp2 = true;
30270 }
30271 }
30272 {
30273 PyThreadState* __tstate = wxPyBeginAllowThreads();
30274 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 {
30279 #if wxUSE_UNICODE
30280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30281 #else
30282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30283 #endif
30284 }
30285 {
30286 if (temp2)
30287 delete arg2;
30288 }
30289 return resultobj;
30290 fail:
30291 {
30292 if (temp2)
30293 delete arg2;
30294 }
30295 return NULL;
30296 }
30297
30298
30299 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30300 PyObject *obj;
30301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30302 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30303 return SWIG_Py_Void();
30304 }
30305
30306 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30307 return SWIG_Python_InitShadowInstance(args);
30308 }
30309
30310 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30311 PyObject *resultobj = 0;
30312 int arg1 = (int) 0 ;
30313 int arg2 = (int) 0 ;
30314 int arg3 = (int) 0 ;
30315 int arg4 = (int) 0 ;
30316 wxDateSpan *result = 0 ;
30317 int val1 ;
30318 int ecode1 = 0 ;
30319 int val2 ;
30320 int ecode2 = 0 ;
30321 int val3 ;
30322 int ecode3 = 0 ;
30323 int val4 ;
30324 int ecode4 = 0 ;
30325 PyObject * obj0 = 0 ;
30326 PyObject * obj1 = 0 ;
30327 PyObject * obj2 = 0 ;
30328 PyObject * obj3 = 0 ;
30329 char * kwnames[] = {
30330 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30331 };
30332
30333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30334 if (obj0) {
30335 ecode1 = SWIG_AsVal_int(obj0, &val1);
30336 if (!SWIG_IsOK(ecode1)) {
30337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30338 }
30339 arg1 = static_cast< int >(val1);
30340 }
30341 if (obj1) {
30342 ecode2 = SWIG_AsVal_int(obj1, &val2);
30343 if (!SWIG_IsOK(ecode2)) {
30344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30345 }
30346 arg2 = static_cast< int >(val2);
30347 }
30348 if (obj2) {
30349 ecode3 = SWIG_AsVal_int(obj2, &val3);
30350 if (!SWIG_IsOK(ecode3)) {
30351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30352 }
30353 arg3 = static_cast< int >(val3);
30354 }
30355 if (obj3) {
30356 ecode4 = SWIG_AsVal_int(obj3, &val4);
30357 if (!SWIG_IsOK(ecode4)) {
30358 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30359 }
30360 arg4 = static_cast< int >(val4);
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30376 PyObject *resultobj = 0;
30377 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 PyObject *swig_obj[1] ;
30381
30382 if (!args) SWIG_fail;
30383 swig_obj[0] = args;
30384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30385 if (!SWIG_IsOK(res1)) {
30386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30387 }
30388 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 delete arg1;
30392
30393 wxPyEndAllowThreads(__tstate);
30394 if (PyErr_Occurred()) SWIG_fail;
30395 }
30396 resultobj = SWIG_Py_Void();
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj = 0;
30405 int arg1 ;
30406 wxDateSpan result;
30407 int val1 ;
30408 int ecode1 = 0 ;
30409 PyObject * obj0 = 0 ;
30410 char * kwnames[] = {
30411 (char *) "days", NULL
30412 };
30413
30414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30415 ecode1 = SWIG_AsVal_int(obj0, &val1);
30416 if (!SWIG_IsOK(ecode1)) {
30417 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30418 }
30419 arg1 = static_cast< int >(val1);
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 result = wxDateSpan::Days(arg1);
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30427 return resultobj;
30428 fail:
30429 return NULL;
30430 }
30431
30432
30433 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30434 PyObject *resultobj = 0;
30435 wxDateSpan result;
30436
30437 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30438 {
30439 PyThreadState* __tstate = wxPyBeginAllowThreads();
30440 result = wxDateSpan::Day();
30441 wxPyEndAllowThreads(__tstate);
30442 if (PyErr_Occurred()) SWIG_fail;
30443 }
30444 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30445 return resultobj;
30446 fail:
30447 return NULL;
30448 }
30449
30450
30451 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30452 PyObject *resultobj = 0;
30453 int arg1 ;
30454 wxDateSpan result;
30455 int val1 ;
30456 int ecode1 = 0 ;
30457 PyObject * obj0 = 0 ;
30458 char * kwnames[] = {
30459 (char *) "weeks", NULL
30460 };
30461
30462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30463 ecode1 = SWIG_AsVal_int(obj0, &val1);
30464 if (!SWIG_IsOK(ecode1)) {
30465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30466 }
30467 arg1 = static_cast< int >(val1);
30468 {
30469 PyThreadState* __tstate = wxPyBeginAllowThreads();
30470 result = wxDateSpan::Weeks(arg1);
30471 wxPyEndAllowThreads(__tstate);
30472 if (PyErr_Occurred()) SWIG_fail;
30473 }
30474 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30475 return resultobj;
30476 fail:
30477 return NULL;
30478 }
30479
30480
30481 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30482 PyObject *resultobj = 0;
30483 wxDateSpan result;
30484
30485 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30486 {
30487 PyThreadState* __tstate = wxPyBeginAllowThreads();
30488 result = wxDateSpan::Week();
30489 wxPyEndAllowThreads(__tstate);
30490 if (PyErr_Occurred()) SWIG_fail;
30491 }
30492 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30493 return resultobj;
30494 fail:
30495 return NULL;
30496 }
30497
30498
30499 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30500 PyObject *resultobj = 0;
30501 int arg1 ;
30502 wxDateSpan result;
30503 int val1 ;
30504 int ecode1 = 0 ;
30505 PyObject * obj0 = 0 ;
30506 char * kwnames[] = {
30507 (char *) "mon", NULL
30508 };
30509
30510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30511 ecode1 = SWIG_AsVal_int(obj0, &val1);
30512 if (!SWIG_IsOK(ecode1)) {
30513 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30514 }
30515 arg1 = static_cast< int >(val1);
30516 {
30517 PyThreadState* __tstate = wxPyBeginAllowThreads();
30518 result = wxDateSpan::Months(arg1);
30519 wxPyEndAllowThreads(__tstate);
30520 if (PyErr_Occurred()) SWIG_fail;
30521 }
30522 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30530 PyObject *resultobj = 0;
30531 wxDateSpan result;
30532
30533 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 result = wxDateSpan::Month();
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30548 PyObject *resultobj = 0;
30549 int arg1 ;
30550 wxDateSpan result;
30551 int val1 ;
30552 int ecode1 = 0 ;
30553 PyObject * obj0 = 0 ;
30554 char * kwnames[] = {
30555 (char *) "years", NULL
30556 };
30557
30558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30559 ecode1 = SWIG_AsVal_int(obj0, &val1);
30560 if (!SWIG_IsOK(ecode1)) {
30561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30562 }
30563 arg1 = static_cast< int >(val1);
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 result = wxDateSpan::Years(arg1);
30567 wxPyEndAllowThreads(__tstate);
30568 if (PyErr_Occurred()) SWIG_fail;
30569 }
30570 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30578 PyObject *resultobj = 0;
30579 wxDateSpan result;
30580
30581 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30582 {
30583 PyThreadState* __tstate = wxPyBeginAllowThreads();
30584 result = wxDateSpan::Year();
30585 wxPyEndAllowThreads(__tstate);
30586 if (PyErr_Occurred()) SWIG_fail;
30587 }
30588 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30589 return resultobj;
30590 fail:
30591 return NULL;
30592 }
30593
30594
30595 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30596 PyObject *resultobj = 0;
30597 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30598 int arg2 ;
30599 wxDateSpan *result = 0 ;
30600 void *argp1 = 0 ;
30601 int res1 = 0 ;
30602 int val2 ;
30603 int ecode2 = 0 ;
30604 PyObject * obj0 = 0 ;
30605 PyObject * obj1 = 0 ;
30606 char * kwnames[] = {
30607 (char *) "self",(char *) "n", NULL
30608 };
30609
30610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30612 if (!SWIG_IsOK(res1)) {
30613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30614 }
30615 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30616 ecode2 = SWIG_AsVal_int(obj1, &val2);
30617 if (!SWIG_IsOK(ecode2)) {
30618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30619 }
30620 arg2 = static_cast< int >(val2);
30621 {
30622 PyThreadState* __tstate = wxPyBeginAllowThreads();
30623 {
30624 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30625 result = (wxDateSpan *) &_result_ref;
30626 }
30627 wxPyEndAllowThreads(__tstate);
30628 if (PyErr_Occurred()) SWIG_fail;
30629 }
30630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30631 return resultobj;
30632 fail:
30633 return NULL;
30634 }
30635
30636
30637 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30638 PyObject *resultobj = 0;
30639 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30640 int arg2 ;
30641 wxDateSpan *result = 0 ;
30642 void *argp1 = 0 ;
30643 int res1 = 0 ;
30644 int val2 ;
30645 int ecode2 = 0 ;
30646 PyObject * obj0 = 0 ;
30647 PyObject * obj1 = 0 ;
30648 char * kwnames[] = {
30649 (char *) "self",(char *) "n", NULL
30650 };
30651
30652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30654 if (!SWIG_IsOK(res1)) {
30655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30656 }
30657 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30658 ecode2 = SWIG_AsVal_int(obj1, &val2);
30659 if (!SWIG_IsOK(ecode2)) {
30660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30661 }
30662 arg2 = static_cast< int >(val2);
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 {
30666 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30667 result = (wxDateSpan *) &_result_ref;
30668 }
30669 wxPyEndAllowThreads(__tstate);
30670 if (PyErr_Occurred()) SWIG_fail;
30671 }
30672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30673 return resultobj;
30674 fail:
30675 return NULL;
30676 }
30677
30678
30679 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30680 PyObject *resultobj = 0;
30681 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30682 int arg2 ;
30683 wxDateSpan *result = 0 ;
30684 void *argp1 = 0 ;
30685 int res1 = 0 ;
30686 int val2 ;
30687 int ecode2 = 0 ;
30688 PyObject * obj0 = 0 ;
30689 PyObject * obj1 = 0 ;
30690 char * kwnames[] = {
30691 (char *) "self",(char *) "n", NULL
30692 };
30693
30694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30696 if (!SWIG_IsOK(res1)) {
30697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30698 }
30699 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30700 ecode2 = SWIG_AsVal_int(obj1, &val2);
30701 if (!SWIG_IsOK(ecode2)) {
30702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30703 }
30704 arg2 = static_cast< int >(val2);
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 {
30708 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30709 result = (wxDateSpan *) &_result_ref;
30710 }
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30715 return resultobj;
30716 fail:
30717 return NULL;
30718 }
30719
30720
30721 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30722 PyObject *resultobj = 0;
30723 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30724 int arg2 ;
30725 wxDateSpan *result = 0 ;
30726 void *argp1 = 0 ;
30727 int res1 = 0 ;
30728 int val2 ;
30729 int ecode2 = 0 ;
30730 PyObject * obj0 = 0 ;
30731 PyObject * obj1 = 0 ;
30732 char * kwnames[] = {
30733 (char *) "self",(char *) "n", NULL
30734 };
30735
30736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30738 if (!SWIG_IsOK(res1)) {
30739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30740 }
30741 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30742 ecode2 = SWIG_AsVal_int(obj1, &val2);
30743 if (!SWIG_IsOK(ecode2)) {
30744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30745 }
30746 arg2 = static_cast< int >(val2);
30747 {
30748 PyThreadState* __tstate = wxPyBeginAllowThreads();
30749 {
30750 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30751 result = (wxDateSpan *) &_result_ref;
30752 }
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30764 PyObject *resultobj = 0;
30765 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30766 int result;
30767 void *argp1 = 0 ;
30768 int res1 = 0 ;
30769 PyObject *swig_obj[1] ;
30770
30771 if (!args) SWIG_fail;
30772 swig_obj[0] = args;
30773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30774 if (!SWIG_IsOK(res1)) {
30775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30776 }
30777 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = (int)((wxDateSpan const *)arg1)->GetYears();
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 resultobj = SWIG_From_int(static_cast< int >(result));
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30792 PyObject *resultobj = 0;
30793 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30794 int result;
30795 void *argp1 = 0 ;
30796 int res1 = 0 ;
30797 PyObject *swig_obj[1] ;
30798
30799 if (!args) SWIG_fail;
30800 swig_obj[0] = args;
30801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30802 if (!SWIG_IsOK(res1)) {
30803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30804 }
30805 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_From_int(static_cast< int >(result));
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30822 int result;
30823 void *argp1 = 0 ;
30824 int res1 = 0 ;
30825 PyObject *swig_obj[1] ;
30826
30827 if (!args) SWIG_fail;
30828 swig_obj[0] = args;
30829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30832 }
30833 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_From_int(static_cast< int >(result));
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30848 PyObject *resultobj = 0;
30849 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30850 int result;
30851 void *argp1 = 0 ;
30852 int res1 = 0 ;
30853 PyObject *swig_obj[1] ;
30854
30855 if (!args) SWIG_fail;
30856 swig_obj[0] = args;
30857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30858 if (!SWIG_IsOK(res1)) {
30859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30860 }
30861 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30862 {
30863 PyThreadState* __tstate = wxPyBeginAllowThreads();
30864 result = (int)((wxDateSpan const *)arg1)->GetDays();
30865 wxPyEndAllowThreads(__tstate);
30866 if (PyErr_Occurred()) SWIG_fail;
30867 }
30868 resultobj = SWIG_From_int(static_cast< int >(result));
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30876 PyObject *resultobj = 0;
30877 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30878 int result;
30879 void *argp1 = 0 ;
30880 int res1 = 0 ;
30881 PyObject *swig_obj[1] ;
30882
30883 if (!args) SWIG_fail;
30884 swig_obj[0] = args;
30885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30886 if (!SWIG_IsOK(res1)) {
30887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30888 }
30889 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30890 {
30891 PyThreadState* __tstate = wxPyBeginAllowThreads();
30892 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 resultobj = SWIG_From_int(static_cast< int >(result));
30897 return resultobj;
30898 fail:
30899 return NULL;
30900 }
30901
30902
30903 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30904 PyObject *resultobj = 0;
30905 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30906 wxDateSpan *arg2 = 0 ;
30907 wxDateSpan *result = 0 ;
30908 void *argp1 = 0 ;
30909 int res1 = 0 ;
30910 void *argp2 = 0 ;
30911 int res2 = 0 ;
30912 PyObject * obj0 = 0 ;
30913 PyObject * obj1 = 0 ;
30914 char * kwnames[] = {
30915 (char *) "self",(char *) "other", NULL
30916 };
30917
30918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30920 if (!SWIG_IsOK(res1)) {
30921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30922 }
30923 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30924 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30925 if (!SWIG_IsOK(res2)) {
30926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30927 }
30928 if (!argp2) {
30929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30930 }
30931 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30932 {
30933 PyThreadState* __tstate = wxPyBeginAllowThreads();
30934 {
30935 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30936 result = (wxDateSpan *) &_result_ref;
30937 }
30938 wxPyEndAllowThreads(__tstate);
30939 if (PyErr_Occurred()) SWIG_fail;
30940 }
30941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj = 0;
30950 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30951 wxDateSpan *arg2 = 0 ;
30952 wxDateSpan *result = 0 ;
30953 void *argp1 = 0 ;
30954 int res1 = 0 ;
30955 void *argp2 = 0 ;
30956 int res2 = 0 ;
30957 PyObject * obj0 = 0 ;
30958 PyObject * obj1 = 0 ;
30959 char * kwnames[] = {
30960 (char *) "self",(char *) "other", NULL
30961 };
30962
30963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30965 if (!SWIG_IsOK(res1)) {
30966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30967 }
30968 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30970 if (!SWIG_IsOK(res2)) {
30971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30972 }
30973 if (!argp2) {
30974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30975 }
30976 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 {
30980 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30981 result = (wxDateSpan *) &_result_ref;
30982 }
30983 wxPyEndAllowThreads(__tstate);
30984 if (PyErr_Occurred()) SWIG_fail;
30985 }
30986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30994 PyObject *resultobj = 0;
30995 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30996 wxDateSpan *result = 0 ;
30997 void *argp1 = 0 ;
30998 int res1 = 0 ;
30999 PyObject *swig_obj[1] ;
31000
31001 if (!args) SWIG_fail;
31002 swig_obj[0] = args;
31003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31004 if (!SWIG_IsOK(res1)) {
31005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31006 }
31007 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31008 {
31009 PyThreadState* __tstate = wxPyBeginAllowThreads();
31010 {
31011 wxDateSpan &_result_ref = (arg1)->Neg();
31012 result = (wxDateSpan *) &_result_ref;
31013 }
31014 wxPyEndAllowThreads(__tstate);
31015 if (PyErr_Occurred()) SWIG_fail;
31016 }
31017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj = 0;
31026 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31027 int arg2 ;
31028 wxDateSpan *result = 0 ;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 int val2 ;
31032 int ecode2 = 0 ;
31033 PyObject * obj0 = 0 ;
31034 PyObject * obj1 = 0 ;
31035 char * kwnames[] = {
31036 (char *) "self",(char *) "factor", NULL
31037 };
31038
31039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31041 if (!SWIG_IsOK(res1)) {
31042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31043 }
31044 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31045 ecode2 = SWIG_AsVal_int(obj1, &val2);
31046 if (!SWIG_IsOK(ecode2)) {
31047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31048 }
31049 arg2 = static_cast< int >(val2);
31050 {
31051 PyThreadState* __tstate = wxPyBeginAllowThreads();
31052 {
31053 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31054 result = (wxDateSpan *) &_result_ref;
31055 }
31056 wxPyEndAllowThreads(__tstate);
31057 if (PyErr_Occurred()) SWIG_fail;
31058 }
31059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31060 return resultobj;
31061 fail:
31062 return NULL;
31063 }
31064
31065
31066 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31067 PyObject *resultobj = 0;
31068 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31069 wxDateSpan *arg2 = 0 ;
31070 wxDateSpan *result = 0 ;
31071 void *argp1 = 0 ;
31072 int res1 = 0 ;
31073 void *argp2 = 0 ;
31074 int res2 = 0 ;
31075 PyObject * obj0 = 0 ;
31076 PyObject * obj1 = 0 ;
31077 char * kwnames[] = {
31078 (char *) "self",(char *) "other", NULL
31079 };
31080
31081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31085 }
31086 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31088 if (!SWIG_IsOK(res2)) {
31089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31090 }
31091 if (!argp2) {
31092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31093 }
31094 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31095 {
31096 PyThreadState* __tstate = wxPyBeginAllowThreads();
31097 {
31098 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31099 result = (wxDateSpan *) &_result_ref;
31100 }
31101 wxPyEndAllowThreads(__tstate);
31102 if (PyErr_Occurred()) SWIG_fail;
31103 }
31104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31112 PyObject *resultobj = 0;
31113 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31114 wxDateSpan *arg2 = 0 ;
31115 wxDateSpan *result = 0 ;
31116 void *argp1 = 0 ;
31117 int res1 = 0 ;
31118 void *argp2 = 0 ;
31119 int res2 = 0 ;
31120 PyObject * obj0 = 0 ;
31121 PyObject * obj1 = 0 ;
31122 char * kwnames[] = {
31123 (char *) "self",(char *) "other", NULL
31124 };
31125
31126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31128 if (!SWIG_IsOK(res1)) {
31129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31130 }
31131 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31132 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31133 if (!SWIG_IsOK(res2)) {
31134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31135 }
31136 if (!argp2) {
31137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31138 }
31139 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31140 {
31141 PyThreadState* __tstate = wxPyBeginAllowThreads();
31142 {
31143 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31144 result = (wxDateSpan *) &_result_ref;
31145 }
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31157 PyObject *resultobj = 0;
31158 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31159 wxDateSpan *result = 0 ;
31160 void *argp1 = 0 ;
31161 int res1 = 0 ;
31162 PyObject *swig_obj[1] ;
31163
31164 if (!args) SWIG_fail;
31165 swig_obj[0] = args;
31166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31167 if (!SWIG_IsOK(res1)) {
31168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31169 }
31170 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 {
31174 wxDateSpan &_result_ref = (arg1)->operator -();
31175 result = (wxDateSpan *) &_result_ref;
31176 }
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31188 PyObject *resultobj = 0;
31189 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31190 int arg2 ;
31191 wxDateSpan *result = 0 ;
31192 void *argp1 = 0 ;
31193 int res1 = 0 ;
31194 int val2 ;
31195 int ecode2 = 0 ;
31196 PyObject * obj0 = 0 ;
31197 PyObject * obj1 = 0 ;
31198 char * kwnames[] = {
31199 (char *) "self",(char *) "factor", NULL
31200 };
31201
31202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31204 if (!SWIG_IsOK(res1)) {
31205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31206 }
31207 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31208 ecode2 = SWIG_AsVal_int(obj1, &val2);
31209 if (!SWIG_IsOK(ecode2)) {
31210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31211 }
31212 arg2 = static_cast< int >(val2);
31213 {
31214 PyThreadState* __tstate = wxPyBeginAllowThreads();
31215 {
31216 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31217 result = (wxDateSpan *) &_result_ref;
31218 }
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31230 PyObject *resultobj = 0;
31231 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31232 wxDateSpan *arg2 = 0 ;
31233 wxDateSpan result;
31234 void *argp1 = 0 ;
31235 int res1 = 0 ;
31236 void *argp2 = 0 ;
31237 int res2 = 0 ;
31238 PyObject * obj0 = 0 ;
31239 PyObject * obj1 = 0 ;
31240 char * kwnames[] = {
31241 (char *) "self",(char *) "other", NULL
31242 };
31243
31244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31246 if (!SWIG_IsOK(res1)) {
31247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31248 }
31249 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31250 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31251 if (!SWIG_IsOK(res2)) {
31252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31253 }
31254 if (!argp2) {
31255 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31256 }
31257 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31258 {
31259 PyThreadState* __tstate = wxPyBeginAllowThreads();
31260 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31261 wxPyEndAllowThreads(__tstate);
31262 if (PyErr_Occurred()) SWIG_fail;
31263 }
31264 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31265 return resultobj;
31266 fail:
31267 return NULL;
31268 }
31269
31270
31271 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31272 PyObject *resultobj = 0;
31273 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31274 wxDateSpan *arg2 = 0 ;
31275 wxDateSpan result;
31276 void *argp1 = 0 ;
31277 int res1 = 0 ;
31278 void *argp2 = 0 ;
31279 int res2 = 0 ;
31280 PyObject * obj0 = 0 ;
31281 PyObject * obj1 = 0 ;
31282 char * kwnames[] = {
31283 (char *) "self",(char *) "other", NULL
31284 };
31285
31286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31288 if (!SWIG_IsOK(res1)) {
31289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31290 }
31291 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31292 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31293 if (!SWIG_IsOK(res2)) {
31294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31295 }
31296 if (!argp2) {
31297 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31298 }
31299 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31303 wxPyEndAllowThreads(__tstate);
31304 if (PyErr_Occurred()) SWIG_fail;
31305 }
31306 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31314 PyObject *resultobj = 0;
31315 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31316 int arg2 ;
31317 wxDateSpan result;
31318 void *argp1 = 0 ;
31319 int res1 = 0 ;
31320 int val2 ;
31321 int ecode2 = 0 ;
31322 PyObject * obj0 = 0 ;
31323 PyObject * obj1 = 0 ;
31324 char * kwnames[] = {
31325 (char *) "self",(char *) "n", NULL
31326 };
31327
31328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31330 if (!SWIG_IsOK(res1)) {
31331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31332 }
31333 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31334 ecode2 = SWIG_AsVal_int(obj1, &val2);
31335 if (!SWIG_IsOK(ecode2)) {
31336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31337 }
31338 arg2 = static_cast< int >(val2);
31339 {
31340 PyThreadState* __tstate = wxPyBeginAllowThreads();
31341 result = wxDateSpan___mul__(arg1,arg2);
31342 wxPyEndAllowThreads(__tstate);
31343 if (PyErr_Occurred()) SWIG_fail;
31344 }
31345 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31346 return resultobj;
31347 fail:
31348 return NULL;
31349 }
31350
31351
31352 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31353 PyObject *resultobj = 0;
31354 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31355 int arg2 ;
31356 wxDateSpan result;
31357 void *argp1 = 0 ;
31358 int res1 = 0 ;
31359 int val2 ;
31360 int ecode2 = 0 ;
31361 PyObject * obj0 = 0 ;
31362 PyObject * obj1 = 0 ;
31363 char * kwnames[] = {
31364 (char *) "self",(char *) "n", NULL
31365 };
31366
31367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31369 if (!SWIG_IsOK(res1)) {
31370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31371 }
31372 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31373 ecode2 = SWIG_AsVal_int(obj1, &val2);
31374 if (!SWIG_IsOK(ecode2)) {
31375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31376 }
31377 arg2 = static_cast< int >(val2);
31378 {
31379 PyThreadState* __tstate = wxPyBeginAllowThreads();
31380 result = wxDateSpan___rmul__(arg1,arg2);
31381 wxPyEndAllowThreads(__tstate);
31382 if (PyErr_Occurred()) SWIG_fail;
31383 }
31384 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31385 return resultobj;
31386 fail:
31387 return NULL;
31388 }
31389
31390
31391 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31392 PyObject *resultobj = 0;
31393 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31394 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31395 bool result;
31396 void *argp1 = 0 ;
31397 int res1 = 0 ;
31398 void *argp2 = 0 ;
31399 int res2 = 0 ;
31400 PyObject * obj0 = 0 ;
31401 PyObject * obj1 = 0 ;
31402 char * kwnames[] = {
31403 (char *) "self",(char *) "other", NULL
31404 };
31405
31406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31408 if (!SWIG_IsOK(res1)) {
31409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31410 }
31411 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31412 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31413 if (!SWIG_IsOK(res2)) {
31414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31415 }
31416 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 {
31424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31425 }
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31433 PyObject *resultobj = 0;
31434 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31435 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31436 bool result;
31437 void *argp1 = 0 ;
31438 int res1 = 0 ;
31439 void *argp2 = 0 ;
31440 int res2 = 0 ;
31441 PyObject * obj0 = 0 ;
31442 PyObject * obj1 = 0 ;
31443 char * kwnames[] = {
31444 (char *) "self",(char *) "other", NULL
31445 };
31446
31447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31449 if (!SWIG_IsOK(res1)) {
31450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31451 }
31452 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31454 if (!SWIG_IsOK(res2)) {
31455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31456 }
31457 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31461 wxPyEndAllowThreads(__tstate);
31462 if (PyErr_Occurred()) SWIG_fail;
31463 }
31464 {
31465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31466 }
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31474 PyObject *obj;
31475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31476 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31477 return SWIG_Py_Void();
31478 }
31479
31480 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31481 return SWIG_Python_InitShadowInstance(args);
31482 }
31483
31484 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31485 PyObject *resultobj = 0;
31486 long result;
31487
31488 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31489 {
31490 PyThreadState* __tstate = wxPyBeginAllowThreads();
31491 result = (long)wxGetLocalTime();
31492 wxPyEndAllowThreads(__tstate);
31493 if (PyErr_Occurred()) SWIG_fail;
31494 }
31495 resultobj = SWIG_From_long(static_cast< long >(result));
31496 return resultobj;
31497 fail:
31498 return NULL;
31499 }
31500
31501
31502 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31503 PyObject *resultobj = 0;
31504 long result;
31505
31506 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 result = (long)wxGetUTCTime();
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 resultobj = SWIG_From_long(static_cast< long >(result));
31514 return resultobj;
31515 fail:
31516 return NULL;
31517 }
31518
31519
31520 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31521 PyObject *resultobj = 0;
31522 long result;
31523
31524 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31525 {
31526 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 result = (long)wxGetCurrentTime();
31528 wxPyEndAllowThreads(__tstate);
31529 if (PyErr_Occurred()) SWIG_fail;
31530 }
31531 resultobj = SWIG_From_long(static_cast< long >(result));
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31539 PyObject *resultobj = 0;
31540 wxLongLong result;
31541
31542 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31543 {
31544 PyThreadState* __tstate = wxPyBeginAllowThreads();
31545 result = wxGetLocalTimeMillis();
31546 wxPyEndAllowThreads(__tstate);
31547 if (PyErr_Occurred()) SWIG_fail;
31548 }
31549 {
31550 PyObject *hi, *lo, *shifter, *shifted;
31551 hi = PyLong_FromLong( (&result)->GetHi() );
31552 lo = PyLong_FromLong( (&result)->GetLo() );
31553 shifter = PyLong_FromLong(32);
31554 shifted = PyNumber_Lshift(hi, shifter);
31555 resultobj = PyNumber_Or(shifted, lo);
31556 Py_DECREF(hi);
31557 Py_DECREF(lo);
31558 Py_DECREF(shifter);
31559 Py_DECREF(shifted);
31560 }
31561 return resultobj;
31562 fail:
31563 return NULL;
31564 }
31565
31566
31567 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31568 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31569 return 1;
31570 }
31571
31572
31573 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31574 PyObject *pyobj = 0;
31575
31576 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31577 return pyobj;
31578 }
31579
31580
31581 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31582 PyObject *resultobj = 0;
31583 wxDataFormatId arg1 ;
31584 wxDataFormat *result = 0 ;
31585 int val1 ;
31586 int ecode1 = 0 ;
31587 PyObject * obj0 = 0 ;
31588 char * kwnames[] = {
31589 (char *) "type", NULL
31590 };
31591
31592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31593 ecode1 = SWIG_AsVal_int(obj0, &val1);
31594 if (!SWIG_IsOK(ecode1)) {
31595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31596 }
31597 arg1 = static_cast< wxDataFormatId >(val1);
31598 {
31599 PyThreadState* __tstate = wxPyBeginAllowThreads();
31600 result = (wxDataFormat *)new wxDataFormat(arg1);
31601 wxPyEndAllowThreads(__tstate);
31602 if (PyErr_Occurred()) SWIG_fail;
31603 }
31604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31605 return resultobj;
31606 fail:
31607 return NULL;
31608 }
31609
31610
31611 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31612 PyObject *resultobj = 0;
31613 wxString *arg1 = 0 ;
31614 wxDataFormat *result = 0 ;
31615 bool temp1 = false ;
31616 PyObject * obj0 = 0 ;
31617 char * kwnames[] = {
31618 (char *) "format", NULL
31619 };
31620
31621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31622 {
31623 arg1 = wxString_in_helper(obj0);
31624 if (arg1 == NULL) SWIG_fail;
31625 temp1 = true;
31626 }
31627 {
31628 PyThreadState* __tstate = wxPyBeginAllowThreads();
31629 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31630 wxPyEndAllowThreads(__tstate);
31631 if (PyErr_Occurred()) SWIG_fail;
31632 }
31633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31634 {
31635 if (temp1)
31636 delete arg1;
31637 }
31638 return resultobj;
31639 fail:
31640 {
31641 if (temp1)
31642 delete arg1;
31643 }
31644 return NULL;
31645 }
31646
31647
31648 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31649 PyObject *resultobj = 0;
31650 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31651 void *argp1 = 0 ;
31652 int res1 = 0 ;
31653 PyObject *swig_obj[1] ;
31654
31655 if (!args) SWIG_fail;
31656 swig_obj[0] = args;
31657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31658 if (!SWIG_IsOK(res1)) {
31659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31660 }
31661 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 delete arg1;
31665
31666 wxPyEndAllowThreads(__tstate);
31667 if (PyErr_Occurred()) SWIG_fail;
31668 }
31669 resultobj = SWIG_Py_Void();
31670 return resultobj;
31671 fail:
31672 return NULL;
31673 }
31674
31675
31676 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31677 PyObject *resultobj = 0;
31678 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31679 wxDataFormatId arg2 ;
31680 bool result;
31681 void *argp1 = 0 ;
31682 int res1 = 0 ;
31683 int val2 ;
31684 int ecode2 = 0 ;
31685
31686 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31688 if (!SWIG_IsOK(res1)) {
31689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31690 }
31691 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31692 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31693 if (!SWIG_IsOK(ecode2)) {
31694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31695 }
31696 arg2 = static_cast< wxDataFormatId >(val2);
31697 {
31698 PyThreadState* __tstate = wxPyBeginAllowThreads();
31699 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31700 wxPyEndAllowThreads(__tstate);
31701 if (PyErr_Occurred()) SWIG_fail;
31702 }
31703 {
31704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31705 }
31706 return resultobj;
31707 fail:
31708 return NULL;
31709 }
31710
31711
31712 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31713 PyObject *resultobj = 0;
31714 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31715 wxDataFormatId arg2 ;
31716 bool result;
31717 void *argp1 = 0 ;
31718 int res1 = 0 ;
31719 int val2 ;
31720 int ecode2 = 0 ;
31721
31722 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31724 if (!SWIG_IsOK(res1)) {
31725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31726 }
31727 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31728 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31729 if (!SWIG_IsOK(ecode2)) {
31730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31731 }
31732 arg2 = static_cast< wxDataFormatId >(val2);
31733 {
31734 PyThreadState* __tstate = wxPyBeginAllowThreads();
31735 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 {
31740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31741 }
31742 return resultobj;
31743 fail:
31744 return NULL;
31745 }
31746
31747
31748 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31749 PyObject *resultobj = 0;
31750 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31751 wxDataFormat *arg2 = 0 ;
31752 bool result;
31753 void *argp1 = 0 ;
31754 int res1 = 0 ;
31755 void *argp2 = 0 ;
31756 int res2 = 0 ;
31757
31758 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31760 if (!SWIG_IsOK(res1)) {
31761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31762 }
31763 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31764 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31765 if (!SWIG_IsOK(res2)) {
31766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31767 }
31768 if (!argp2) {
31769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31770 }
31771 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31772 {
31773 PyThreadState* __tstate = wxPyBeginAllowThreads();
31774 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31775 wxPyEndAllowThreads(__tstate);
31776 if (PyErr_Occurred()) SWIG_fail;
31777 }
31778 {
31779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31780 }
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31788 int argc;
31789 PyObject *argv[3];
31790
31791 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31792 --argc;
31793 if (argc == 2) {
31794 int _v = 0;
31795 {
31796 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31797 _v = SWIG_CheckState(res);
31798 }
31799 if (!_v) goto check_1;
31800 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31801 }
31802 check_1:
31803
31804 if (argc == 2) {
31805 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31806 }
31807
31808 fail:
31809 Py_INCREF(Py_NotImplemented);
31810 return Py_NotImplemented;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31815 PyObject *resultobj = 0;
31816 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31817 wxDataFormat *arg2 = 0 ;
31818 bool result;
31819 void *argp1 = 0 ;
31820 int res1 = 0 ;
31821 void *argp2 = 0 ;
31822 int res2 = 0 ;
31823
31824 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31826 if (!SWIG_IsOK(res1)) {
31827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31828 }
31829 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31830 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31831 if (!SWIG_IsOK(res2)) {
31832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31833 }
31834 if (!argp2) {
31835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31836 }
31837 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 {
31845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31846 }
31847 return resultobj;
31848 fail:
31849 return NULL;
31850 }
31851
31852
31853 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31854 int argc;
31855 PyObject *argv[3];
31856
31857 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31858 --argc;
31859 if (argc == 2) {
31860 int _v = 0;
31861 {
31862 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31863 _v = SWIG_CheckState(res);
31864 }
31865 if (!_v) goto check_1;
31866 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31867 }
31868 check_1:
31869
31870 if (argc == 2) {
31871 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31872 }
31873
31874 fail:
31875 Py_INCREF(Py_NotImplemented);
31876 return Py_NotImplemented;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31881 PyObject *resultobj = 0;
31882 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31883 wxDataFormatId arg2 ;
31884 void *argp1 = 0 ;
31885 int res1 = 0 ;
31886 int val2 ;
31887 int ecode2 = 0 ;
31888 PyObject * obj0 = 0 ;
31889 PyObject * obj1 = 0 ;
31890 char * kwnames[] = {
31891 (char *) "self",(char *) "format", NULL
31892 };
31893
31894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31896 if (!SWIG_IsOK(res1)) {
31897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31898 }
31899 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31900 ecode2 = SWIG_AsVal_int(obj1, &val2);
31901 if (!SWIG_IsOK(ecode2)) {
31902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31903 }
31904 arg2 = static_cast< wxDataFormatId >(val2);
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 (arg1)->SetType(arg2);
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_Py_Void();
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31919 PyObject *resultobj = 0;
31920 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31921 wxDataFormatId result;
31922 void *argp1 = 0 ;
31923 int res1 = 0 ;
31924 PyObject *swig_obj[1] ;
31925
31926 if (!args) SWIG_fail;
31927 swig_obj[0] = args;
31928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31929 if (!SWIG_IsOK(res1)) {
31930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31931 }
31932 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 resultobj = SWIG_From_int(static_cast< int >(result));
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31947 PyObject *resultobj = 0;
31948 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31949 wxString result;
31950 void *argp1 = 0 ;
31951 int res1 = 0 ;
31952 PyObject *swig_obj[1] ;
31953
31954 if (!args) SWIG_fail;
31955 swig_obj[0] = args;
31956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31957 if (!SWIG_IsOK(res1)) {
31958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31959 }
31960 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31961 {
31962 PyThreadState* __tstate = wxPyBeginAllowThreads();
31963 result = ((wxDataFormat const *)arg1)->GetId();
31964 wxPyEndAllowThreads(__tstate);
31965 if (PyErr_Occurred()) SWIG_fail;
31966 }
31967 {
31968 #if wxUSE_UNICODE
31969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31970 #else
31971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31972 #endif
31973 }
31974 return resultobj;
31975 fail:
31976 return NULL;
31977 }
31978
31979
31980 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31981 PyObject *resultobj = 0;
31982 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31983 wxString *arg2 = 0 ;
31984 void *argp1 = 0 ;
31985 int res1 = 0 ;
31986 bool temp2 = false ;
31987 PyObject * obj0 = 0 ;
31988 PyObject * obj1 = 0 ;
31989 char * kwnames[] = {
31990 (char *) "self",(char *) "format", NULL
31991 };
31992
31993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31995 if (!SWIG_IsOK(res1)) {
31996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31997 }
31998 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31999 {
32000 arg2 = wxString_in_helper(obj1);
32001 if (arg2 == NULL) SWIG_fail;
32002 temp2 = true;
32003 }
32004 {
32005 PyThreadState* __tstate = wxPyBeginAllowThreads();
32006 (arg1)->SetId((wxString const &)*arg2);
32007 wxPyEndAllowThreads(__tstate);
32008 if (PyErr_Occurred()) SWIG_fail;
32009 }
32010 resultobj = SWIG_Py_Void();
32011 {
32012 if (temp2)
32013 delete arg2;
32014 }
32015 return resultobj;
32016 fail:
32017 {
32018 if (temp2)
32019 delete arg2;
32020 }
32021 return NULL;
32022 }
32023
32024
32025 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32026 PyObject *obj;
32027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32028 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32029 return SWIG_Py_Void();
32030 }
32031
32032 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32033 return SWIG_Python_InitShadowInstance(args);
32034 }
32035
32036 SWIGINTERN int FormatInvalid_set(PyObject *) {
32037 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32038 return 1;
32039 }
32040
32041
32042 SWIGINTERN PyObject *FormatInvalid_get(void) {
32043 PyObject *pyobj = 0;
32044
32045 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32046 return pyobj;
32047 }
32048
32049
32050 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32051 PyObject *resultobj = 0;
32052 wxDataObject *arg1 = (wxDataObject *) 0 ;
32053 void *argp1 = 0 ;
32054 int res1 = 0 ;
32055 PyObject *swig_obj[1] ;
32056
32057 if (!args) SWIG_fail;
32058 swig_obj[0] = args;
32059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32060 if (!SWIG_IsOK(res1)) {
32061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32062 }
32063 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32064 {
32065 PyThreadState* __tstate = wxPyBeginAllowThreads();
32066 delete arg1;
32067
32068 wxPyEndAllowThreads(__tstate);
32069 if (PyErr_Occurred()) SWIG_fail;
32070 }
32071 resultobj = SWIG_Py_Void();
32072 return resultobj;
32073 fail:
32074 return NULL;
32075 }
32076
32077
32078 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32079 PyObject *resultobj = 0;
32080 wxDataObject *arg1 = (wxDataObject *) 0 ;
32081 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32082 SwigValueWrapper<wxDataFormat > result;
32083 void *argp1 = 0 ;
32084 int res1 = 0 ;
32085 int val2 ;
32086 int ecode2 = 0 ;
32087 PyObject * obj0 = 0 ;
32088 PyObject * obj1 = 0 ;
32089 char * kwnames[] = {
32090 (char *) "self",(char *) "dir", NULL
32091 };
32092
32093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32095 if (!SWIG_IsOK(res1)) {
32096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32097 }
32098 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32099 if (obj1) {
32100 ecode2 = SWIG_AsVal_int(obj1, &val2);
32101 if (!SWIG_IsOK(ecode2)) {
32102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32103 }
32104 arg2 = static_cast< wxDataObject::Direction >(val2);
32105 }
32106 {
32107 PyThreadState* __tstate = wxPyBeginAllowThreads();
32108 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32109 wxPyEndAllowThreads(__tstate);
32110 if (PyErr_Occurred()) SWIG_fail;
32111 }
32112 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32113 return resultobj;
32114 fail:
32115 return NULL;
32116 }
32117
32118
32119 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32120 PyObject *resultobj = 0;
32121 wxDataObject *arg1 = (wxDataObject *) 0 ;
32122 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32123 size_t result;
32124 void *argp1 = 0 ;
32125 int res1 = 0 ;
32126 int val2 ;
32127 int ecode2 = 0 ;
32128 PyObject * obj0 = 0 ;
32129 PyObject * obj1 = 0 ;
32130 char * kwnames[] = {
32131 (char *) "self",(char *) "dir", NULL
32132 };
32133
32134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32136 if (!SWIG_IsOK(res1)) {
32137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32138 }
32139 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32140 if (obj1) {
32141 ecode2 = SWIG_AsVal_int(obj1, &val2);
32142 if (!SWIG_IsOK(ecode2)) {
32143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32144 }
32145 arg2 = static_cast< wxDataObject::Direction >(val2);
32146 }
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32161 PyObject *resultobj = 0;
32162 wxDataObject *arg1 = (wxDataObject *) 0 ;
32163 wxDataFormat *arg2 = 0 ;
32164 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32165 bool result;
32166 void *argp1 = 0 ;
32167 int res1 = 0 ;
32168 void *argp2 = 0 ;
32169 int res2 = 0 ;
32170 int val3 ;
32171 int ecode3 = 0 ;
32172 PyObject * obj0 = 0 ;
32173 PyObject * obj1 = 0 ;
32174 PyObject * obj2 = 0 ;
32175 char * kwnames[] = {
32176 (char *) "self",(char *) "format",(char *) "dir", NULL
32177 };
32178
32179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32181 if (!SWIG_IsOK(res1)) {
32182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32183 }
32184 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32185 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32186 if (!SWIG_IsOK(res2)) {
32187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32188 }
32189 if (!argp2) {
32190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32191 }
32192 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32193 if (obj2) {
32194 ecode3 = SWIG_AsVal_int(obj2, &val3);
32195 if (!SWIG_IsOK(ecode3)) {
32196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32197 }
32198 arg3 = static_cast< wxDataObject::Direction >(val3);
32199 }
32200 {
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32203 wxPyEndAllowThreads(__tstate);
32204 if (PyErr_Occurred()) SWIG_fail;
32205 }
32206 {
32207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32208 }
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32216 PyObject *resultobj = 0;
32217 wxDataObject *arg1 = (wxDataObject *) 0 ;
32218 wxDataFormat *arg2 = 0 ;
32219 size_t result;
32220 void *argp1 = 0 ;
32221 int res1 = 0 ;
32222 void *argp2 = 0 ;
32223 int res2 = 0 ;
32224 PyObject * obj0 = 0 ;
32225 PyObject * obj1 = 0 ;
32226 char * kwnames[] = {
32227 (char *) "self",(char *) "format", NULL
32228 };
32229
32230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32232 if (!SWIG_IsOK(res1)) {
32233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32234 }
32235 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32237 if (!SWIG_IsOK(res2)) {
32238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32239 }
32240 if (!argp2) {
32241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32242 }
32243 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32244 {
32245 PyThreadState* __tstate = wxPyBeginAllowThreads();
32246 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32247 wxPyEndAllowThreads(__tstate);
32248 if (PyErr_Occurred()) SWIG_fail;
32249 }
32250 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32251 return resultobj;
32252 fail:
32253 return NULL;
32254 }
32255
32256
32257 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32258 PyObject *resultobj = 0;
32259 wxDataObject *arg1 = (wxDataObject *) 0 ;
32260 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32261 PyObject *result = 0 ;
32262 void *argp1 = 0 ;
32263 int res1 = 0 ;
32264 int val2 ;
32265 int ecode2 = 0 ;
32266 PyObject * obj0 = 0 ;
32267 PyObject * obj1 = 0 ;
32268 char * kwnames[] = {
32269 (char *) "self",(char *) "dir", NULL
32270 };
32271
32272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32274 if (!SWIG_IsOK(res1)) {
32275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32276 }
32277 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32278 if (obj1) {
32279 ecode2 = SWIG_AsVal_int(obj1, &val2);
32280 if (!SWIG_IsOK(ecode2)) {
32281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32282 }
32283 arg2 = static_cast< wxDataObject::Direction >(val2);
32284 }
32285 {
32286 PyThreadState* __tstate = wxPyBeginAllowThreads();
32287 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 resultobj = result;
32292 return resultobj;
32293 fail:
32294 return NULL;
32295 }
32296
32297
32298 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32299 PyObject *resultobj = 0;
32300 wxDataObject *arg1 = (wxDataObject *) 0 ;
32301 wxDataFormat *arg2 = 0 ;
32302 PyObject *result = 0 ;
32303 void *argp1 = 0 ;
32304 int res1 = 0 ;
32305 void *argp2 = 0 ;
32306 int res2 = 0 ;
32307 PyObject * obj0 = 0 ;
32308 PyObject * obj1 = 0 ;
32309 char * kwnames[] = {
32310 (char *) "self",(char *) "format", NULL
32311 };
32312
32313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32315 if (!SWIG_IsOK(res1)) {
32316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32317 }
32318 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32319 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32320 if (!SWIG_IsOK(res2)) {
32321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32322 }
32323 if (!argp2) {
32324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32325 }
32326 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32327 {
32328 PyThreadState* __tstate = wxPyBeginAllowThreads();
32329 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32330 wxPyEndAllowThreads(__tstate);
32331 if (PyErr_Occurred()) SWIG_fail;
32332 }
32333 resultobj = result;
32334 return resultobj;
32335 fail:
32336 return NULL;
32337 }
32338
32339
32340 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32341 PyObject *resultobj = 0;
32342 wxDataObject *arg1 = (wxDataObject *) 0 ;
32343 wxDataFormat *arg2 = 0 ;
32344 PyObject *arg3 = (PyObject *) 0 ;
32345 bool result;
32346 void *argp1 = 0 ;
32347 int res1 = 0 ;
32348 void *argp2 = 0 ;
32349 int res2 = 0 ;
32350 PyObject * obj0 = 0 ;
32351 PyObject * obj1 = 0 ;
32352 PyObject * obj2 = 0 ;
32353 char * kwnames[] = {
32354 (char *) "self",(char *) "format",(char *) "data", NULL
32355 };
32356
32357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32359 if (!SWIG_IsOK(res1)) {
32360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32361 }
32362 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32363 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32364 if (!SWIG_IsOK(res2)) {
32365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32366 }
32367 if (!argp2) {
32368 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32369 }
32370 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32371 arg3 = obj2;
32372 {
32373 PyThreadState* __tstate = wxPyBeginAllowThreads();
32374 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32375 wxPyEndAllowThreads(__tstate);
32376 if (PyErr_Occurred()) SWIG_fail;
32377 }
32378 {
32379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32380 }
32381 return resultobj;
32382 fail:
32383 return NULL;
32384 }
32385
32386
32387 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32388 PyObject *obj;
32389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32390 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32391 return SWIG_Py_Void();
32392 }
32393
32394 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32395 PyObject *resultobj = 0;
32396 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32397 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32398 wxDataObjectSimple *result = 0 ;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 PyObject * obj0 = 0 ;
32402 char * kwnames[] = {
32403 (char *) "format", NULL
32404 };
32405
32406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32407 if (obj0) {
32408 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32409 if (!SWIG_IsOK(res1)) {
32410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32411 }
32412 if (!argp1) {
32413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32414 }
32415 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32416 }
32417 {
32418 PyThreadState* __tstate = wxPyBeginAllowThreads();
32419 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32431 PyObject *resultobj = 0;
32432 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32433 wxDataFormat *result = 0 ;
32434 void *argp1 = 0 ;
32435 int res1 = 0 ;
32436 PyObject *swig_obj[1] ;
32437
32438 if (!args) SWIG_fail;
32439 swig_obj[0] = args;
32440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32441 if (!SWIG_IsOK(res1)) {
32442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32443 }
32444 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32445 {
32446 PyThreadState* __tstate = wxPyBeginAllowThreads();
32447 {
32448 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32449 result = (wxDataFormat *) &_result_ref;
32450 }
32451 wxPyEndAllowThreads(__tstate);
32452 if (PyErr_Occurred()) SWIG_fail;
32453 }
32454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32455 return resultobj;
32456 fail:
32457 return NULL;
32458 }
32459
32460
32461 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32462 PyObject *resultobj = 0;
32463 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32464 wxDataFormat *arg2 = 0 ;
32465 void *argp1 = 0 ;
32466 int res1 = 0 ;
32467 void *argp2 = 0 ;
32468 int res2 = 0 ;
32469 PyObject * obj0 = 0 ;
32470 PyObject * obj1 = 0 ;
32471 char * kwnames[] = {
32472 (char *) "self",(char *) "format", NULL
32473 };
32474
32475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32477 if (!SWIG_IsOK(res1)) {
32478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32479 }
32480 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32481 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32482 if (!SWIG_IsOK(res2)) {
32483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32484 }
32485 if (!argp2) {
32486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32487 }
32488 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32489 {
32490 PyThreadState* __tstate = wxPyBeginAllowThreads();
32491 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32492 wxPyEndAllowThreads(__tstate);
32493 if (PyErr_Occurred()) SWIG_fail;
32494 }
32495 resultobj = SWIG_Py_Void();
32496 return resultobj;
32497 fail:
32498 return NULL;
32499 }
32500
32501
32502 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32503 PyObject *resultobj = 0;
32504 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32505 size_t result;
32506 void *argp1 = 0 ;
32507 int res1 = 0 ;
32508 PyObject *swig_obj[1] ;
32509
32510 if (!args) SWIG_fail;
32511 swig_obj[0] = args;
32512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32513 if (!SWIG_IsOK(res1)) {
32514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32515 }
32516 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32517 {
32518 PyThreadState* __tstate = wxPyBeginAllowThreads();
32519 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32520 wxPyEndAllowThreads(__tstate);
32521 if (PyErr_Occurred()) SWIG_fail;
32522 }
32523 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32533 PyObject *result = 0 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject *swig_obj[1] ;
32537
32538 if (!args) SWIG_fail;
32539 swig_obj[0] = args;
32540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32543 }
32544 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32548 wxPyEndAllowThreads(__tstate);
32549 if (PyErr_Occurred()) SWIG_fail;
32550 }
32551 resultobj = result;
32552 return resultobj;
32553 fail:
32554 return NULL;
32555 }
32556
32557
32558 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32559 PyObject *resultobj = 0;
32560 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32561 PyObject *arg2 = (PyObject *) 0 ;
32562 bool result;
32563 void *argp1 = 0 ;
32564 int res1 = 0 ;
32565 PyObject * obj0 = 0 ;
32566 PyObject * obj1 = 0 ;
32567 char * kwnames[] = {
32568 (char *) "self",(char *) "data", NULL
32569 };
32570
32571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32573 if (!SWIG_IsOK(res1)) {
32574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32575 }
32576 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32577 arg2 = obj1;
32578 {
32579 PyThreadState* __tstate = wxPyBeginAllowThreads();
32580 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32581 wxPyEndAllowThreads(__tstate);
32582 if (PyErr_Occurred()) SWIG_fail;
32583 }
32584 {
32585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32586 }
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32594 PyObject *obj;
32595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32596 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32597 return SWIG_Py_Void();
32598 }
32599
32600 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32601 return SWIG_Python_InitShadowInstance(args);
32602 }
32603
32604 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32605 PyObject *resultobj = 0;
32606 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32607 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32608 wxPyDataObjectSimple *result = 0 ;
32609 void *argp1 = 0 ;
32610 int res1 = 0 ;
32611 PyObject * obj0 = 0 ;
32612 char * kwnames[] = {
32613 (char *) "format", NULL
32614 };
32615
32616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32617 if (obj0) {
32618 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32619 if (!SWIG_IsOK(res1)) {
32620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32621 }
32622 if (!argp1) {
32623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32624 }
32625 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32626 }
32627 {
32628 PyThreadState* __tstate = wxPyBeginAllowThreads();
32629 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32630 wxPyEndAllowThreads(__tstate);
32631 if (PyErr_Occurred()) SWIG_fail;
32632 }
32633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32641 PyObject *resultobj = 0;
32642 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32643 PyObject *arg2 = (PyObject *) 0 ;
32644 PyObject *arg3 = (PyObject *) 0 ;
32645 void *argp1 = 0 ;
32646 int res1 = 0 ;
32647 PyObject * obj0 = 0 ;
32648 PyObject * obj1 = 0 ;
32649 PyObject * obj2 = 0 ;
32650 char * kwnames[] = {
32651 (char *) "self",(char *) "self",(char *) "_class", NULL
32652 };
32653
32654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32656 if (!SWIG_IsOK(res1)) {
32657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32658 }
32659 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32660 arg2 = obj1;
32661 arg3 = obj2;
32662 {
32663 PyThreadState* __tstate = wxPyBeginAllowThreads();
32664 (arg1)->_setCallbackInfo(arg2,arg3);
32665 wxPyEndAllowThreads(__tstate);
32666 if (PyErr_Occurred()) SWIG_fail;
32667 }
32668 resultobj = SWIG_Py_Void();
32669 return resultobj;
32670 fail:
32671 return NULL;
32672 }
32673
32674
32675 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32676 PyObject *obj;
32677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32678 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32679 return SWIG_Py_Void();
32680 }
32681
32682 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32683 return SWIG_Python_InitShadowInstance(args);
32684 }
32685
32686 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32687 PyObject *resultobj = 0;
32688 wxDataObjectComposite *result = 0 ;
32689
32690 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32705 PyObject *resultobj = 0;
32706 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32707 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32708 bool arg3 = (bool) false ;
32709 void *argp1 = 0 ;
32710 int res1 = 0 ;
32711 int res2 = 0 ;
32712 bool val3 ;
32713 int ecode3 = 0 ;
32714 PyObject * obj0 = 0 ;
32715 PyObject * obj1 = 0 ;
32716 PyObject * obj2 = 0 ;
32717 char * kwnames[] = {
32718 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32719 };
32720
32721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32723 if (!SWIG_IsOK(res1)) {
32724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32725 }
32726 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32727 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32728 if (!SWIG_IsOK(res2)) {
32729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32730 }
32731 if (obj2) {
32732 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32733 if (!SWIG_IsOK(ecode3)) {
32734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32735 }
32736 arg3 = static_cast< bool >(val3);
32737 }
32738 {
32739 PyThreadState* __tstate = wxPyBeginAllowThreads();
32740 (arg1)->Add(arg2,arg3);
32741 wxPyEndAllowThreads(__tstate);
32742 if (PyErr_Occurred()) SWIG_fail;
32743 }
32744 resultobj = SWIG_Py_Void();
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 PyObject *resultobj = 0;
32753 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32754 SwigValueWrapper<wxDataFormat > result;
32755 void *argp1 = 0 ;
32756 int res1 = 0 ;
32757 PyObject *swig_obj[1] ;
32758
32759 if (!args) SWIG_fail;
32760 swig_obj[0] = args;
32761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32762 if (!SWIG_IsOK(res1)) {
32763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32764 }
32765 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *obj;
32781 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32782 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32783 return SWIG_Py_Void();
32784 }
32785
32786 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32787 return SWIG_Python_InitShadowInstance(args);
32788 }
32789
32790 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32791 PyObject *resultobj = 0;
32792 wxString const &arg1_defvalue = wxPyEmptyString ;
32793 wxString *arg1 = (wxString *) &arg1_defvalue ;
32794 wxTextDataObject *result = 0 ;
32795 bool temp1 = false ;
32796 PyObject * obj0 = 0 ;
32797 char * kwnames[] = {
32798 (char *) "text", NULL
32799 };
32800
32801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32802 if (obj0) {
32803 {
32804 arg1 = wxString_in_helper(obj0);
32805 if (arg1 == NULL) SWIG_fail;
32806 temp1 = true;
32807 }
32808 }
32809 {
32810 PyThreadState* __tstate = wxPyBeginAllowThreads();
32811 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32812 wxPyEndAllowThreads(__tstate);
32813 if (PyErr_Occurred()) SWIG_fail;
32814 }
32815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32816 {
32817 if (temp1)
32818 delete arg1;
32819 }
32820 return resultobj;
32821 fail:
32822 {
32823 if (temp1)
32824 delete arg1;
32825 }
32826 return NULL;
32827 }
32828
32829
32830 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32831 PyObject *resultobj = 0;
32832 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32833 size_t result;
32834 void *argp1 = 0 ;
32835 int res1 = 0 ;
32836 PyObject *swig_obj[1] ;
32837
32838 if (!args) SWIG_fail;
32839 swig_obj[0] = args;
32840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32841 if (!SWIG_IsOK(res1)) {
32842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32843 }
32844 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32845 {
32846 PyThreadState* __tstate = wxPyBeginAllowThreads();
32847 result = (size_t)(arg1)->GetTextLength();
32848 wxPyEndAllowThreads(__tstate);
32849 if (PyErr_Occurred()) SWIG_fail;
32850 }
32851 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32852 return resultobj;
32853 fail:
32854 return NULL;
32855 }
32856
32857
32858 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32859 PyObject *resultobj = 0;
32860 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32861 wxString result;
32862 void *argp1 = 0 ;
32863 int res1 = 0 ;
32864 PyObject *swig_obj[1] ;
32865
32866 if (!args) SWIG_fail;
32867 swig_obj[0] = args;
32868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32869 if (!SWIG_IsOK(res1)) {
32870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32871 }
32872 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32873 {
32874 PyThreadState* __tstate = wxPyBeginAllowThreads();
32875 result = (arg1)->GetText();
32876 wxPyEndAllowThreads(__tstate);
32877 if (PyErr_Occurred()) SWIG_fail;
32878 }
32879 {
32880 #if wxUSE_UNICODE
32881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32882 #else
32883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32884 #endif
32885 }
32886 return resultobj;
32887 fail:
32888 return NULL;
32889 }
32890
32891
32892 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32893 PyObject *resultobj = 0;
32894 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32895 wxString *arg2 = 0 ;
32896 void *argp1 = 0 ;
32897 int res1 = 0 ;
32898 bool temp2 = false ;
32899 PyObject * obj0 = 0 ;
32900 PyObject * obj1 = 0 ;
32901 char * kwnames[] = {
32902 (char *) "self",(char *) "text", NULL
32903 };
32904
32905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32907 if (!SWIG_IsOK(res1)) {
32908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32909 }
32910 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32911 {
32912 arg2 = wxString_in_helper(obj1);
32913 if (arg2 == NULL) SWIG_fail;
32914 temp2 = true;
32915 }
32916 {
32917 PyThreadState* __tstate = wxPyBeginAllowThreads();
32918 (arg1)->SetText((wxString const &)*arg2);
32919 wxPyEndAllowThreads(__tstate);
32920 if (PyErr_Occurred()) SWIG_fail;
32921 }
32922 resultobj = SWIG_Py_Void();
32923 {
32924 if (temp2)
32925 delete arg2;
32926 }
32927 return resultobj;
32928 fail:
32929 {
32930 if (temp2)
32931 delete arg2;
32932 }
32933 return NULL;
32934 }
32935
32936
32937 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32938 PyObject *obj;
32939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32940 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32941 return SWIG_Py_Void();
32942 }
32943
32944 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32945 return SWIG_Python_InitShadowInstance(args);
32946 }
32947
32948 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32949 PyObject *resultobj = 0;
32950 wxString const &arg1_defvalue = wxPyEmptyString ;
32951 wxString *arg1 = (wxString *) &arg1_defvalue ;
32952 wxPyTextDataObject *result = 0 ;
32953 bool temp1 = false ;
32954 PyObject * obj0 = 0 ;
32955 char * kwnames[] = {
32956 (char *) "text", NULL
32957 };
32958
32959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32960 if (obj0) {
32961 {
32962 arg1 = wxString_in_helper(obj0);
32963 if (arg1 == NULL) SWIG_fail;
32964 temp1 = true;
32965 }
32966 }
32967 {
32968 PyThreadState* __tstate = wxPyBeginAllowThreads();
32969 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32970 wxPyEndAllowThreads(__tstate);
32971 if (PyErr_Occurred()) SWIG_fail;
32972 }
32973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32974 {
32975 if (temp1)
32976 delete arg1;
32977 }
32978 return resultobj;
32979 fail:
32980 {
32981 if (temp1)
32982 delete arg1;
32983 }
32984 return NULL;
32985 }
32986
32987
32988 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32989 PyObject *resultobj = 0;
32990 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32991 PyObject *arg2 = (PyObject *) 0 ;
32992 PyObject *arg3 = (PyObject *) 0 ;
32993 void *argp1 = 0 ;
32994 int res1 = 0 ;
32995 PyObject * obj0 = 0 ;
32996 PyObject * obj1 = 0 ;
32997 PyObject * obj2 = 0 ;
32998 char * kwnames[] = {
32999 (char *) "self",(char *) "self",(char *) "_class", NULL
33000 };
33001
33002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
33004 if (!SWIG_IsOK(res1)) {
33005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
33006 }
33007 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
33008 arg2 = obj1;
33009 arg3 = obj2;
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 (arg1)->_setCallbackInfo(arg2,arg3);
33013 wxPyEndAllowThreads(__tstate);
33014 if (PyErr_Occurred()) SWIG_fail;
33015 }
33016 resultobj = SWIG_Py_Void();
33017 return resultobj;
33018 fail:
33019 return NULL;
33020 }
33021
33022
33023 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33024 PyObject *obj;
33025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33026 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
33027 return SWIG_Py_Void();
33028 }
33029
33030 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33031 return SWIG_Python_InitShadowInstance(args);
33032 }
33033
33034 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33035 PyObject *resultobj = 0;
33036 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33037 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33038 wxBitmapDataObject *result = 0 ;
33039 void *argp1 = 0 ;
33040 int res1 = 0 ;
33041 PyObject * obj0 = 0 ;
33042 char * kwnames[] = {
33043 (char *) "bitmap", NULL
33044 };
33045
33046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33047 if (obj0) {
33048 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33049 if (!SWIG_IsOK(res1)) {
33050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33051 }
33052 if (!argp1) {
33053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33054 }
33055 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33056 }
33057 {
33058 PyThreadState* __tstate = wxPyBeginAllowThreads();
33059 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33060 wxPyEndAllowThreads(__tstate);
33061 if (PyErr_Occurred()) SWIG_fail;
33062 }
33063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33064 return resultobj;
33065 fail:
33066 return NULL;
33067 }
33068
33069
33070 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33071 PyObject *resultobj = 0;
33072 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33073 wxBitmap result;
33074 void *argp1 = 0 ;
33075 int res1 = 0 ;
33076 PyObject *swig_obj[1] ;
33077
33078 if (!args) SWIG_fail;
33079 swig_obj[0] = args;
33080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33081 if (!SWIG_IsOK(res1)) {
33082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33083 }
33084 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33085 {
33086 PyThreadState* __tstate = wxPyBeginAllowThreads();
33087 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33088 wxPyEndAllowThreads(__tstate);
33089 if (PyErr_Occurred()) SWIG_fail;
33090 }
33091 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33092 return resultobj;
33093 fail:
33094 return NULL;
33095 }
33096
33097
33098 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33099 PyObject *resultobj = 0;
33100 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33101 wxBitmap *arg2 = 0 ;
33102 void *argp1 = 0 ;
33103 int res1 = 0 ;
33104 void *argp2 = 0 ;
33105 int res2 = 0 ;
33106 PyObject * obj0 = 0 ;
33107 PyObject * obj1 = 0 ;
33108 char * kwnames[] = {
33109 (char *) "self",(char *) "bitmap", NULL
33110 };
33111
33112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33114 if (!SWIG_IsOK(res1)) {
33115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33116 }
33117 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33119 if (!SWIG_IsOK(res2)) {
33120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33121 }
33122 if (!argp2) {
33123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33124 }
33125 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33126 {
33127 PyThreadState* __tstate = wxPyBeginAllowThreads();
33128 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 resultobj = SWIG_Py_Void();
33133 return resultobj;
33134 fail:
33135 return NULL;
33136 }
33137
33138
33139 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33140 PyObject *obj;
33141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33142 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33143 return SWIG_Py_Void();
33144 }
33145
33146 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33147 return SWIG_Python_InitShadowInstance(args);
33148 }
33149
33150 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33151 PyObject *resultobj = 0;
33152 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33153 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33154 wxPyBitmapDataObject *result = 0 ;
33155 void *argp1 = 0 ;
33156 int res1 = 0 ;
33157 PyObject * obj0 = 0 ;
33158 char * kwnames[] = {
33159 (char *) "bitmap", NULL
33160 };
33161
33162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33163 if (obj0) {
33164 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33165 if (!SWIG_IsOK(res1)) {
33166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33167 }
33168 if (!argp1) {
33169 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33170 }
33171 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33172 }
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33176 wxPyEndAllowThreads(__tstate);
33177 if (PyErr_Occurred()) SWIG_fail;
33178 }
33179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33180 return resultobj;
33181 fail:
33182 return NULL;
33183 }
33184
33185
33186 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33187 PyObject *resultobj = 0;
33188 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33189 PyObject *arg2 = (PyObject *) 0 ;
33190 PyObject *arg3 = (PyObject *) 0 ;
33191 void *argp1 = 0 ;
33192 int res1 = 0 ;
33193 PyObject * obj0 = 0 ;
33194 PyObject * obj1 = 0 ;
33195 PyObject * obj2 = 0 ;
33196 char * kwnames[] = {
33197 (char *) "self",(char *) "self",(char *) "_class", NULL
33198 };
33199
33200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33202 if (!SWIG_IsOK(res1)) {
33203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33204 }
33205 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33206 arg2 = obj1;
33207 arg3 = obj2;
33208 {
33209 PyThreadState* __tstate = wxPyBeginAllowThreads();
33210 (arg1)->_setCallbackInfo(arg2,arg3);
33211 wxPyEndAllowThreads(__tstate);
33212 if (PyErr_Occurred()) SWIG_fail;
33213 }
33214 resultobj = SWIG_Py_Void();
33215 return resultobj;
33216 fail:
33217 return NULL;
33218 }
33219
33220
33221 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33222 PyObject *obj;
33223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33224 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33225 return SWIG_Py_Void();
33226 }
33227
33228 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33229 return SWIG_Python_InitShadowInstance(args);
33230 }
33231
33232 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33233 PyObject *resultobj = 0;
33234 wxFileDataObject *result = 0 ;
33235
33236 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33237 {
33238 PyThreadState* __tstate = wxPyBeginAllowThreads();
33239 result = (wxFileDataObject *)new wxFileDataObject();
33240 wxPyEndAllowThreads(__tstate);
33241 if (PyErr_Occurred()) SWIG_fail;
33242 }
33243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33244 return resultobj;
33245 fail:
33246 return NULL;
33247 }
33248
33249
33250 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33251 PyObject *resultobj = 0;
33252 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33253 wxArrayString *result = 0 ;
33254 void *argp1 = 0 ;
33255 int res1 = 0 ;
33256 PyObject *swig_obj[1] ;
33257
33258 if (!args) SWIG_fail;
33259 swig_obj[0] = args;
33260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33261 if (!SWIG_IsOK(res1)) {
33262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33263 }
33264 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 {
33268 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33269 result = (wxArrayString *) &_result_ref;
33270 }
33271 wxPyEndAllowThreads(__tstate);
33272 if (PyErr_Occurred()) SWIG_fail;
33273 }
33274 {
33275 resultobj = wxArrayString2PyList_helper(*result);
33276 }
33277 return resultobj;
33278 fail:
33279 return NULL;
33280 }
33281
33282
33283 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33284 PyObject *resultobj = 0;
33285 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33286 wxString *arg2 = 0 ;
33287 void *argp1 = 0 ;
33288 int res1 = 0 ;
33289 bool temp2 = false ;
33290 PyObject * obj0 = 0 ;
33291 PyObject * obj1 = 0 ;
33292 char * kwnames[] = {
33293 (char *) "self",(char *) "filename", NULL
33294 };
33295
33296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33298 if (!SWIG_IsOK(res1)) {
33299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33300 }
33301 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33302 {
33303 arg2 = wxString_in_helper(obj1);
33304 if (arg2 == NULL) SWIG_fail;
33305 temp2 = true;
33306 }
33307 {
33308 PyThreadState* __tstate = wxPyBeginAllowThreads();
33309 (arg1)->AddFile((wxString const &)*arg2);
33310 wxPyEndAllowThreads(__tstate);
33311 if (PyErr_Occurred()) SWIG_fail;
33312 }
33313 resultobj = SWIG_Py_Void();
33314 {
33315 if (temp2)
33316 delete arg2;
33317 }
33318 return resultobj;
33319 fail:
33320 {
33321 if (temp2)
33322 delete arg2;
33323 }
33324 return NULL;
33325 }
33326
33327
33328 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33329 PyObject *obj;
33330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33331 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33332 return SWIG_Py_Void();
33333 }
33334
33335 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33336 return SWIG_Python_InitShadowInstance(args);
33337 }
33338
33339 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33340 PyObject *resultobj = 0;
33341 wxDataFormat *arg1 = 0 ;
33342 wxCustomDataObject *result = 0 ;
33343 void *argp1 = 0 ;
33344 int res1 = 0 ;
33345
33346 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33348 if (!SWIG_IsOK(res1)) {
33349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33350 }
33351 if (!argp1) {
33352 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33353 }
33354 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33355 {
33356 PyThreadState* __tstate = wxPyBeginAllowThreads();
33357 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33358 wxPyEndAllowThreads(__tstate);
33359 if (PyErr_Occurred()) SWIG_fail;
33360 }
33361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33362 return resultobj;
33363 fail:
33364 return NULL;
33365 }
33366
33367
33368 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33369 PyObject *resultobj = 0;
33370 wxString *arg1 = 0 ;
33371 wxCustomDataObject *result = 0 ;
33372 bool temp1 = false ;
33373
33374 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33375 {
33376 arg1 = wxString_in_helper(swig_obj[0]);
33377 if (arg1 == NULL) SWIG_fail;
33378 temp1 = true;
33379 }
33380 {
33381 PyThreadState* __tstate = wxPyBeginAllowThreads();
33382 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33383 wxPyEndAllowThreads(__tstate);
33384 if (PyErr_Occurred()) SWIG_fail;
33385 }
33386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33387 {
33388 if (temp1)
33389 delete arg1;
33390 }
33391 return resultobj;
33392 fail:
33393 {
33394 if (temp1)
33395 delete arg1;
33396 }
33397 return NULL;
33398 }
33399
33400
33401 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33402 PyObject *resultobj = 0;
33403 wxCustomDataObject *result = 0 ;
33404
33405 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33406 {
33407 PyThreadState* __tstate = wxPyBeginAllowThreads();
33408 result = (wxCustomDataObject *)new wxCustomDataObject();
33409 wxPyEndAllowThreads(__tstate);
33410 if (PyErr_Occurred()) SWIG_fail;
33411 }
33412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33413 return resultobj;
33414 fail:
33415 return NULL;
33416 }
33417
33418
33419 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33420 int argc;
33421 PyObject *argv[2];
33422
33423 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33424 --argc;
33425 if (argc == 0) {
33426 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33427 }
33428 if (argc == 1) {
33429 int _v = 0;
33430 {
33431 {
33432 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33433 }
33434 }
33435 if (!_v) goto check_2;
33436 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33437 }
33438 check_2:
33439
33440 if (argc == 1) {
33441 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33442 }
33443
33444 fail:
33445 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33446 return NULL;
33447 }
33448
33449
33450 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33451 PyObject *resultobj = 0;
33452 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33453 PyObject *arg2 = (PyObject *) 0 ;
33454 bool result;
33455 void *argp1 = 0 ;
33456 int res1 = 0 ;
33457 PyObject * obj0 = 0 ;
33458 PyObject * obj1 = 0 ;
33459 char * kwnames[] = {
33460 (char *) "self",(char *) "data", NULL
33461 };
33462
33463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33465 if (!SWIG_IsOK(res1)) {
33466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33467 }
33468 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33469 arg2 = obj1;
33470 {
33471 PyThreadState* __tstate = wxPyBeginAllowThreads();
33472 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33473 wxPyEndAllowThreads(__tstate);
33474 if (PyErr_Occurred()) SWIG_fail;
33475 }
33476 {
33477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33478 }
33479 return resultobj;
33480 fail:
33481 return NULL;
33482 }
33483
33484
33485 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33486 PyObject *resultobj = 0;
33487 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33488 size_t result;
33489 void *argp1 = 0 ;
33490 int res1 = 0 ;
33491 PyObject *swig_obj[1] ;
33492
33493 if (!args) SWIG_fail;
33494 swig_obj[0] = args;
33495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33496 if (!SWIG_IsOK(res1)) {
33497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33498 }
33499 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33500 {
33501 PyThreadState* __tstate = wxPyBeginAllowThreads();
33502 result = (size_t)(arg1)->GetSize();
33503 wxPyEndAllowThreads(__tstate);
33504 if (PyErr_Occurred()) SWIG_fail;
33505 }
33506 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33507 return resultobj;
33508 fail:
33509 return NULL;
33510 }
33511
33512
33513 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33514 PyObject *resultobj = 0;
33515 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33516 PyObject *result = 0 ;
33517 void *argp1 = 0 ;
33518 int res1 = 0 ;
33519 PyObject *swig_obj[1] ;
33520
33521 if (!args) SWIG_fail;
33522 swig_obj[0] = args;
33523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33524 if (!SWIG_IsOK(res1)) {
33525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33526 }
33527 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33528 {
33529 PyThreadState* __tstate = wxPyBeginAllowThreads();
33530 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33531 wxPyEndAllowThreads(__tstate);
33532 if (PyErr_Occurred()) SWIG_fail;
33533 }
33534 resultobj = result;
33535 return resultobj;
33536 fail:
33537 return NULL;
33538 }
33539
33540
33541 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33542 PyObject *obj;
33543 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33544 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33545 return SWIG_Py_Void();
33546 }
33547
33548 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33549 return SWIG_Python_InitShadowInstance(args);
33550 }
33551
33552 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33553 PyObject *resultobj = 0;
33554 wxString const &arg1_defvalue = wxPyEmptyString ;
33555 wxString *arg1 = (wxString *) &arg1_defvalue ;
33556 wxURLDataObject *result = 0 ;
33557 bool temp1 = false ;
33558 PyObject * obj0 = 0 ;
33559 char * kwnames[] = {
33560 (char *) "url", NULL
33561 };
33562
33563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33564 if (obj0) {
33565 {
33566 arg1 = wxString_in_helper(obj0);
33567 if (arg1 == NULL) SWIG_fail;
33568 temp1 = true;
33569 }
33570 }
33571 {
33572 PyThreadState* __tstate = wxPyBeginAllowThreads();
33573 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33574 wxPyEndAllowThreads(__tstate);
33575 if (PyErr_Occurred()) SWIG_fail;
33576 }
33577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33578 {
33579 if (temp1)
33580 delete arg1;
33581 }
33582 return resultobj;
33583 fail:
33584 {
33585 if (temp1)
33586 delete arg1;
33587 }
33588 return NULL;
33589 }
33590
33591
33592 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33593 PyObject *resultobj = 0;
33594 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33595 wxString result;
33596 void *argp1 = 0 ;
33597 int res1 = 0 ;
33598 PyObject *swig_obj[1] ;
33599
33600 if (!args) SWIG_fail;
33601 swig_obj[0] = args;
33602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33603 if (!SWIG_IsOK(res1)) {
33604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33605 }
33606 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33607 {
33608 PyThreadState* __tstate = wxPyBeginAllowThreads();
33609 result = (arg1)->GetURL();
33610 wxPyEndAllowThreads(__tstate);
33611 if (PyErr_Occurred()) SWIG_fail;
33612 }
33613 {
33614 #if wxUSE_UNICODE
33615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33616 #else
33617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33618 #endif
33619 }
33620 return resultobj;
33621 fail:
33622 return NULL;
33623 }
33624
33625
33626 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33627 PyObject *resultobj = 0;
33628 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33629 wxString *arg2 = 0 ;
33630 void *argp1 = 0 ;
33631 int res1 = 0 ;
33632 bool temp2 = false ;
33633 PyObject * obj0 = 0 ;
33634 PyObject * obj1 = 0 ;
33635 char * kwnames[] = {
33636 (char *) "self",(char *) "url", NULL
33637 };
33638
33639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33641 if (!SWIG_IsOK(res1)) {
33642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33643 }
33644 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33645 {
33646 arg2 = wxString_in_helper(obj1);
33647 if (arg2 == NULL) SWIG_fail;
33648 temp2 = true;
33649 }
33650 {
33651 PyThreadState* __tstate = wxPyBeginAllowThreads();
33652 (arg1)->SetURL((wxString const &)*arg2);
33653 wxPyEndAllowThreads(__tstate);
33654 if (PyErr_Occurred()) SWIG_fail;
33655 }
33656 resultobj = SWIG_Py_Void();
33657 {
33658 if (temp2)
33659 delete arg2;
33660 }
33661 return resultobj;
33662 fail:
33663 {
33664 if (temp2)
33665 delete arg2;
33666 }
33667 return NULL;
33668 }
33669
33670
33671 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33672 PyObject *obj;
33673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33674 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33675 return SWIG_Py_Void();
33676 }
33677
33678 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33679 return SWIG_Python_InitShadowInstance(args);
33680 }
33681
33682 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33683 PyObject *resultobj = 0;
33684 wxMetafileDataObject *result = 0 ;
33685
33686 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33687 {
33688 PyThreadState* __tstate = wxPyBeginAllowThreads();
33689 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33690 wxPyEndAllowThreads(__tstate);
33691 if (PyErr_Occurred()) SWIG_fail;
33692 }
33693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33694 return resultobj;
33695 fail:
33696 return NULL;
33697 }
33698
33699
33700 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33701 PyObject *resultobj = 0;
33702 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33703 wxMetafile *arg2 = 0 ;
33704 void *argp1 = 0 ;
33705 int res1 = 0 ;
33706 void *argp2 = 0 ;
33707 int res2 = 0 ;
33708 PyObject * obj0 = 0 ;
33709 PyObject * obj1 = 0 ;
33710 char * kwnames[] = {
33711 (char *) "self",(char *) "metafile", NULL
33712 };
33713
33714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33716 if (!SWIG_IsOK(res1)) {
33717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33718 }
33719 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33720 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33721 if (!SWIG_IsOK(res2)) {
33722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33723 }
33724 if (!argp2) {
33725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33726 }
33727 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33728 {
33729 PyThreadState* __tstate = wxPyBeginAllowThreads();
33730 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33731 wxPyEndAllowThreads(__tstate);
33732 if (PyErr_Occurred()) SWIG_fail;
33733 }
33734 resultobj = SWIG_Py_Void();
33735 return resultobj;
33736 fail:
33737 return NULL;
33738 }
33739
33740
33741 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33742 PyObject *resultobj = 0;
33743 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33744 wxMetafile result;
33745 void *argp1 = 0 ;
33746 int res1 = 0 ;
33747 PyObject *swig_obj[1] ;
33748
33749 if (!args) SWIG_fail;
33750 swig_obj[0] = args;
33751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33752 if (!SWIG_IsOK(res1)) {
33753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33754 }
33755 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33756 {
33757 PyThreadState* __tstate = wxPyBeginAllowThreads();
33758 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33759 wxPyEndAllowThreads(__tstate);
33760 if (PyErr_Occurred()) SWIG_fail;
33761 }
33762 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33763 return resultobj;
33764 fail:
33765 return NULL;
33766 }
33767
33768
33769 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33770 PyObject *obj;
33771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33772 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33773 return SWIG_Py_Void();
33774 }
33775
33776 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33777 return SWIG_Python_InitShadowInstance(args);
33778 }
33779
33780 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33781 PyObject *resultobj = 0;
33782 wxDragResult arg1 ;
33783 bool result;
33784 int val1 ;
33785 int ecode1 = 0 ;
33786 PyObject * obj0 = 0 ;
33787 char * kwnames[] = {
33788 (char *) "res", NULL
33789 };
33790
33791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33792 ecode1 = SWIG_AsVal_int(obj0, &val1);
33793 if (!SWIG_IsOK(ecode1)) {
33794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33795 }
33796 arg1 = static_cast< wxDragResult >(val1);
33797 {
33798 PyThreadState* __tstate = wxPyBeginAllowThreads();
33799 result = (bool)wxIsDragResultOk(arg1);
33800 wxPyEndAllowThreads(__tstate);
33801 if (PyErr_Occurred()) SWIG_fail;
33802 }
33803 {
33804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33805 }
33806 return resultobj;
33807 fail:
33808 return NULL;
33809 }
33810
33811
33812 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33813 PyObject *resultobj = 0;
33814 wxWindow *arg1 = (wxWindow *) 0 ;
33815 wxCursor const &arg2_defvalue = wxNullCursor ;
33816 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33817 wxCursor const &arg3_defvalue = wxNullCursor ;
33818 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33819 wxCursor const &arg4_defvalue = wxNullCursor ;
33820 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33821 wxPyDropSource *result = 0 ;
33822 void *argp1 = 0 ;
33823 int res1 = 0 ;
33824 void *argp2 = 0 ;
33825 int res2 = 0 ;
33826 void *argp3 = 0 ;
33827 int res3 = 0 ;
33828 void *argp4 = 0 ;
33829 int res4 = 0 ;
33830 PyObject * obj0 = 0 ;
33831 PyObject * obj1 = 0 ;
33832 PyObject * obj2 = 0 ;
33833 PyObject * obj3 = 0 ;
33834 char * kwnames[] = {
33835 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33836 };
33837
33838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33840 if (!SWIG_IsOK(res1)) {
33841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33842 }
33843 arg1 = reinterpret_cast< wxWindow * >(argp1);
33844 if (obj1) {
33845 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33846 if (!SWIG_IsOK(res2)) {
33847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33848 }
33849 if (!argp2) {
33850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33851 }
33852 arg2 = reinterpret_cast< wxCursor * >(argp2);
33853 }
33854 if (obj2) {
33855 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33856 if (!SWIG_IsOK(res3)) {
33857 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33858 }
33859 if (!argp3) {
33860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33861 }
33862 arg3 = reinterpret_cast< wxCursor * >(argp3);
33863 }
33864 if (obj3) {
33865 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33866 if (!SWIG_IsOK(res4)) {
33867 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33868 }
33869 if (!argp4) {
33870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33871 }
33872 arg4 = reinterpret_cast< wxCursor * >(argp4);
33873 }
33874 {
33875 PyThreadState* __tstate = wxPyBeginAllowThreads();
33876 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33877 wxPyEndAllowThreads(__tstate);
33878 if (PyErr_Occurred()) SWIG_fail;
33879 }
33880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33881 return resultobj;
33882 fail:
33883 return NULL;
33884 }
33885
33886
33887 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33888 PyObject *resultobj = 0;
33889 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33890 PyObject *arg2 = (PyObject *) 0 ;
33891 PyObject *arg3 = (PyObject *) 0 ;
33892 int arg4 = (int) 0 ;
33893 void *argp1 = 0 ;
33894 int res1 = 0 ;
33895 int val4 ;
33896 int ecode4 = 0 ;
33897 PyObject * obj0 = 0 ;
33898 PyObject * obj1 = 0 ;
33899 PyObject * obj2 = 0 ;
33900 PyObject * obj3 = 0 ;
33901 char * kwnames[] = {
33902 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33903 };
33904
33905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33907 if (!SWIG_IsOK(res1)) {
33908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33909 }
33910 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33911 arg2 = obj1;
33912 arg3 = obj2;
33913 if (obj3) {
33914 ecode4 = SWIG_AsVal_int(obj3, &val4);
33915 if (!SWIG_IsOK(ecode4)) {
33916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33917 }
33918 arg4 = static_cast< int >(val4);
33919 }
33920 {
33921 PyThreadState* __tstate = wxPyBeginAllowThreads();
33922 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33923 wxPyEndAllowThreads(__tstate);
33924 if (PyErr_Occurred()) SWIG_fail;
33925 }
33926 resultobj = SWIG_Py_Void();
33927 return resultobj;
33928 fail:
33929 return NULL;
33930 }
33931
33932
33933 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33934 PyObject *resultobj = 0;
33935 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33936 void *argp1 = 0 ;
33937 int res1 = 0 ;
33938 PyObject *swig_obj[1] ;
33939
33940 if (!args) SWIG_fail;
33941 swig_obj[0] = args;
33942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33943 if (!SWIG_IsOK(res1)) {
33944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33945 }
33946 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33947 {
33948 PyThreadState* __tstate = wxPyBeginAllowThreads();
33949 delete arg1;
33950
33951 wxPyEndAllowThreads(__tstate);
33952 if (PyErr_Occurred()) SWIG_fail;
33953 }
33954 resultobj = SWIG_Py_Void();
33955 return resultobj;
33956 fail:
33957 return NULL;
33958 }
33959
33960
33961 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33962 PyObject *resultobj = 0;
33963 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33964 wxDataObject *arg2 = 0 ;
33965 void *argp1 = 0 ;
33966 int res1 = 0 ;
33967 void *argp2 = 0 ;
33968 int res2 = 0 ;
33969 PyObject * obj0 = 0 ;
33970 PyObject * obj1 = 0 ;
33971 char * kwnames[] = {
33972 (char *) "self",(char *) "data", NULL
33973 };
33974
33975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33977 if (!SWIG_IsOK(res1)) {
33978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33979 }
33980 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33981 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33982 if (!SWIG_IsOK(res2)) {
33983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33984 }
33985 if (!argp2) {
33986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33987 }
33988 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33989 {
33990 PyThreadState* __tstate = wxPyBeginAllowThreads();
33991 (arg1)->SetData(*arg2);
33992 wxPyEndAllowThreads(__tstate);
33993 if (PyErr_Occurred()) SWIG_fail;
33994 }
33995 resultobj = SWIG_Py_Void();
33996 return resultobj;
33997 fail:
33998 return NULL;
33999 }
34000
34001
34002 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34003 PyObject *resultobj = 0;
34004 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34005 wxDataObject *result = 0 ;
34006 void *argp1 = 0 ;
34007 int res1 = 0 ;
34008 PyObject *swig_obj[1] ;
34009
34010 if (!args) SWIG_fail;
34011 swig_obj[0] = args;
34012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34013 if (!SWIG_IsOK(res1)) {
34014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34015 }
34016 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34017 {
34018 PyThreadState* __tstate = wxPyBeginAllowThreads();
34019 result = (wxDataObject *)(arg1)->GetDataObject();
34020 wxPyEndAllowThreads(__tstate);
34021 if (PyErr_Occurred()) SWIG_fail;
34022 }
34023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34024 return resultobj;
34025 fail:
34026 return NULL;
34027 }
34028
34029
34030 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34031 PyObject *resultobj = 0;
34032 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34033 wxDragResult arg2 ;
34034 wxCursor *arg3 = 0 ;
34035 void *argp1 = 0 ;
34036 int res1 = 0 ;
34037 int val2 ;
34038 int ecode2 = 0 ;
34039 void *argp3 = 0 ;
34040 int res3 = 0 ;
34041 PyObject * obj0 = 0 ;
34042 PyObject * obj1 = 0 ;
34043 PyObject * obj2 = 0 ;
34044 char * kwnames[] = {
34045 (char *) "self",(char *) "res",(char *) "cursor", NULL
34046 };
34047
34048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34050 if (!SWIG_IsOK(res1)) {
34051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34052 }
34053 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34054 ecode2 = SWIG_AsVal_int(obj1, &val2);
34055 if (!SWIG_IsOK(ecode2)) {
34056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34057 }
34058 arg2 = static_cast< wxDragResult >(val2);
34059 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34060 if (!SWIG_IsOK(res3)) {
34061 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34062 }
34063 if (!argp3) {
34064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34065 }
34066 arg3 = reinterpret_cast< wxCursor * >(argp3);
34067 {
34068 PyThreadState* __tstate = wxPyBeginAllowThreads();
34069 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 resultobj = SWIG_Py_Void();
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34081 PyObject *resultobj = 0;
34082 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34083 int arg2 = (int) wxDrag_CopyOnly ;
34084 wxDragResult result;
34085 void *argp1 = 0 ;
34086 int res1 = 0 ;
34087 int val2 ;
34088 int ecode2 = 0 ;
34089 PyObject * obj0 = 0 ;
34090 PyObject * obj1 = 0 ;
34091 char * kwnames[] = {
34092 (char *) "self",(char *) "flags", NULL
34093 };
34094
34095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34097 if (!SWIG_IsOK(res1)) {
34098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34099 }
34100 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34101 if (obj1) {
34102 ecode2 = SWIG_AsVal_int(obj1, &val2);
34103 if (!SWIG_IsOK(ecode2)) {
34104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34105 }
34106 arg2 = static_cast< int >(val2);
34107 }
34108 {
34109 PyThreadState* __tstate = wxPyBeginAllowThreads();
34110 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 resultobj = SWIG_From_int(static_cast< int >(result));
34115 return resultobj;
34116 fail:
34117 return NULL;
34118 }
34119
34120
34121 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34122 PyObject *resultobj = 0;
34123 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34124 wxDragResult arg2 ;
34125 bool result;
34126 void *argp1 = 0 ;
34127 int res1 = 0 ;
34128 int val2 ;
34129 int ecode2 = 0 ;
34130 PyObject * obj0 = 0 ;
34131 PyObject * obj1 = 0 ;
34132 char * kwnames[] = {
34133 (char *) "self",(char *) "effect", NULL
34134 };
34135
34136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34138 if (!SWIG_IsOK(res1)) {
34139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34140 }
34141 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34142 ecode2 = SWIG_AsVal_int(obj1, &val2);
34143 if (!SWIG_IsOK(ecode2)) {
34144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34145 }
34146 arg2 = static_cast< wxDragResult >(val2);
34147 {
34148 PyThreadState* __tstate = wxPyBeginAllowThreads();
34149 result = (bool)(arg1)->GiveFeedback(arg2);
34150 wxPyEndAllowThreads(__tstate);
34151 if (PyErr_Occurred()) SWIG_fail;
34152 }
34153 {
34154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34155 }
34156 return resultobj;
34157 fail:
34158 return NULL;
34159 }
34160
34161
34162 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34163 PyObject *obj;
34164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34165 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34166 return SWIG_Py_Void();
34167 }
34168
34169 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34170 return SWIG_Python_InitShadowInstance(args);
34171 }
34172
34173 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34174 PyObject *resultobj = 0;
34175 wxDataObject *arg1 = (wxDataObject *) NULL ;
34176 wxPyDropTarget *result = 0 ;
34177 int res1 = 0 ;
34178 PyObject * obj0 = 0 ;
34179 char * kwnames[] = {
34180 (char *) "dataObject", NULL
34181 };
34182
34183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34184 if (obj0) {
34185 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34186 if (!SWIG_IsOK(res1)) {
34187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34188 }
34189 }
34190 {
34191 PyThreadState* __tstate = wxPyBeginAllowThreads();
34192 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34193 wxPyEndAllowThreads(__tstate);
34194 if (PyErr_Occurred()) SWIG_fail;
34195 }
34196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34197 return resultobj;
34198 fail:
34199 return NULL;
34200 }
34201
34202
34203 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34204 PyObject *resultobj = 0;
34205 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34206 PyObject *arg2 = (PyObject *) 0 ;
34207 PyObject *arg3 = (PyObject *) 0 ;
34208 void *argp1 = 0 ;
34209 int res1 = 0 ;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 PyObject * obj2 = 0 ;
34213 char * kwnames[] = {
34214 (char *) "self",(char *) "self",(char *) "_class", NULL
34215 };
34216
34217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34219 if (!SWIG_IsOK(res1)) {
34220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34221 }
34222 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34223 arg2 = obj1;
34224 arg3 = obj2;
34225 {
34226 PyThreadState* __tstate = wxPyBeginAllowThreads();
34227 (arg1)->_setCallbackInfo(arg2,arg3);
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 resultobj = SWIG_Py_Void();
34232 return resultobj;
34233 fail:
34234 return NULL;
34235 }
34236
34237
34238 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34239 PyObject *resultobj = 0;
34240 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34241 void *argp1 = 0 ;
34242 int res1 = 0 ;
34243 PyObject *swig_obj[1] ;
34244
34245 if (!args) SWIG_fail;
34246 swig_obj[0] = args;
34247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34248 if (!SWIG_IsOK(res1)) {
34249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34250 }
34251 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34252 {
34253 PyThreadState* __tstate = wxPyBeginAllowThreads();
34254 delete arg1;
34255
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 resultobj = SWIG_Py_Void();
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34267 PyObject *resultobj = 0;
34268 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34269 wxDataObject *result = 0 ;
34270 void *argp1 = 0 ;
34271 int res1 = 0 ;
34272 PyObject *swig_obj[1] ;
34273
34274 if (!args) SWIG_fail;
34275 swig_obj[0] = args;
34276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34277 if (!SWIG_IsOK(res1)) {
34278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34279 }
34280 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34281 {
34282 PyThreadState* __tstate = wxPyBeginAllowThreads();
34283 result = (wxDataObject *)(arg1)->GetDataObject();
34284 wxPyEndAllowThreads(__tstate);
34285 if (PyErr_Occurred()) SWIG_fail;
34286 }
34287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj = 0;
34296 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34297 wxDataObject *arg2 = (wxDataObject *) 0 ;
34298 void *argp1 = 0 ;
34299 int res1 = 0 ;
34300 int res2 = 0 ;
34301 PyObject * obj0 = 0 ;
34302 PyObject * obj1 = 0 ;
34303 char * kwnames[] = {
34304 (char *) "self",(char *) "dataObject", NULL
34305 };
34306
34307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34309 if (!SWIG_IsOK(res1)) {
34310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34311 }
34312 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34313 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34314 if (!SWIG_IsOK(res2)) {
34315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34316 }
34317 {
34318 PyThreadState* __tstate = wxPyBeginAllowThreads();
34319 (arg1)->SetDataObject(arg2);
34320 wxPyEndAllowThreads(__tstate);
34321 if (PyErr_Occurred()) SWIG_fail;
34322 }
34323 resultobj = SWIG_Py_Void();
34324 return resultobj;
34325 fail:
34326 return NULL;
34327 }
34328
34329
34330 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34331 PyObject *resultobj = 0;
34332 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34333 int arg2 ;
34334 int arg3 ;
34335 wxDragResult arg4 ;
34336 wxDragResult result;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 int val2 ;
34340 int ecode2 = 0 ;
34341 int val3 ;
34342 int ecode3 = 0 ;
34343 int val4 ;
34344 int ecode4 = 0 ;
34345 PyObject * obj0 = 0 ;
34346 PyObject * obj1 = 0 ;
34347 PyObject * obj2 = 0 ;
34348 PyObject * obj3 = 0 ;
34349 char * kwnames[] = {
34350 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34351 };
34352
34353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34355 if (!SWIG_IsOK(res1)) {
34356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34357 }
34358 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34359 ecode2 = SWIG_AsVal_int(obj1, &val2);
34360 if (!SWIG_IsOK(ecode2)) {
34361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34362 }
34363 arg2 = static_cast< int >(val2);
34364 ecode3 = SWIG_AsVal_int(obj2, &val3);
34365 if (!SWIG_IsOK(ecode3)) {
34366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34367 }
34368 arg3 = static_cast< int >(val3);
34369 ecode4 = SWIG_AsVal_int(obj3, &val4);
34370 if (!SWIG_IsOK(ecode4)) {
34371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34372 }
34373 arg4 = static_cast< wxDragResult >(val4);
34374 {
34375 PyThreadState* __tstate = wxPyBeginAllowThreads();
34376 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34377 wxPyEndAllowThreads(__tstate);
34378 if (PyErr_Occurred()) SWIG_fail;
34379 }
34380 resultobj = SWIG_From_int(static_cast< int >(result));
34381 return resultobj;
34382 fail:
34383 return NULL;
34384 }
34385
34386
34387 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34388 PyObject *resultobj = 0;
34389 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34390 int arg2 ;
34391 int arg3 ;
34392 wxDragResult arg4 ;
34393 wxDragResult result;
34394 void *argp1 = 0 ;
34395 int res1 = 0 ;
34396 int val2 ;
34397 int ecode2 = 0 ;
34398 int val3 ;
34399 int ecode3 = 0 ;
34400 int val4 ;
34401 int ecode4 = 0 ;
34402 PyObject * obj0 = 0 ;
34403 PyObject * obj1 = 0 ;
34404 PyObject * obj2 = 0 ;
34405 PyObject * obj3 = 0 ;
34406 char * kwnames[] = {
34407 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34408 };
34409
34410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34412 if (!SWIG_IsOK(res1)) {
34413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34414 }
34415 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34416 ecode2 = SWIG_AsVal_int(obj1, &val2);
34417 if (!SWIG_IsOK(ecode2)) {
34418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34419 }
34420 arg2 = static_cast< int >(val2);
34421 ecode3 = SWIG_AsVal_int(obj2, &val3);
34422 if (!SWIG_IsOK(ecode3)) {
34423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34424 }
34425 arg3 = static_cast< int >(val3);
34426 ecode4 = SWIG_AsVal_int(obj3, &val4);
34427 if (!SWIG_IsOK(ecode4)) {
34428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34429 }
34430 arg4 = static_cast< wxDragResult >(val4);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 resultobj = SWIG_From_int(static_cast< int >(result));
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34445 PyObject *resultobj = 0;
34446 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34447 void *argp1 = 0 ;
34448 int res1 = 0 ;
34449 PyObject *swig_obj[1] ;
34450
34451 if (!args) SWIG_fail;
34452 swig_obj[0] = args;
34453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34454 if (!SWIG_IsOK(res1)) {
34455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34456 }
34457 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 (arg1)->OnLeave();
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 resultobj = SWIG_Py_Void();
34465 return resultobj;
34466 fail:
34467 return NULL;
34468 }
34469
34470
34471 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34472 PyObject *resultobj = 0;
34473 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34474 int arg2 ;
34475 int arg3 ;
34476 bool result;
34477 void *argp1 = 0 ;
34478 int res1 = 0 ;
34479 int val2 ;
34480 int ecode2 = 0 ;
34481 int val3 ;
34482 int ecode3 = 0 ;
34483 PyObject * obj0 = 0 ;
34484 PyObject * obj1 = 0 ;
34485 PyObject * obj2 = 0 ;
34486 char * kwnames[] = {
34487 (char *) "self",(char *) "x",(char *) "y", NULL
34488 };
34489
34490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34492 if (!SWIG_IsOK(res1)) {
34493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34494 }
34495 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34496 ecode2 = SWIG_AsVal_int(obj1, &val2);
34497 if (!SWIG_IsOK(ecode2)) {
34498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34499 }
34500 arg2 = static_cast< int >(val2);
34501 ecode3 = SWIG_AsVal_int(obj2, &val3);
34502 if (!SWIG_IsOK(ecode3)) {
34503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34504 }
34505 arg3 = static_cast< int >(val3);
34506 {
34507 PyThreadState* __tstate = wxPyBeginAllowThreads();
34508 result = (bool)(arg1)->OnDrop(arg2,arg3);
34509 wxPyEndAllowThreads(__tstate);
34510 if (PyErr_Occurred()) SWIG_fail;
34511 }
34512 {
34513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34514 }
34515 return resultobj;
34516 fail:
34517 return NULL;
34518 }
34519
34520
34521 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34522 PyObject *resultobj = 0;
34523 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34524 bool result;
34525 void *argp1 = 0 ;
34526 int res1 = 0 ;
34527 PyObject *swig_obj[1] ;
34528
34529 if (!args) SWIG_fail;
34530 swig_obj[0] = args;
34531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34532 if (!SWIG_IsOK(res1)) {
34533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34534 }
34535 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34536 {
34537 PyThreadState* __tstate = wxPyBeginAllowThreads();
34538 result = (bool)(arg1)->GetData();
34539 wxPyEndAllowThreads(__tstate);
34540 if (PyErr_Occurred()) SWIG_fail;
34541 }
34542 {
34543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34544 }
34545 return resultobj;
34546 fail:
34547 return NULL;
34548 }
34549
34550
34551 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34552 PyObject *resultobj = 0;
34553 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34554 wxDragResult arg2 ;
34555 void *argp1 = 0 ;
34556 int res1 = 0 ;
34557 int val2 ;
34558 int ecode2 = 0 ;
34559 PyObject * obj0 = 0 ;
34560 PyObject * obj1 = 0 ;
34561 char * kwnames[] = {
34562 (char *) "self",(char *) "action", NULL
34563 };
34564
34565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34567 if (!SWIG_IsOK(res1)) {
34568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34569 }
34570 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34571 ecode2 = SWIG_AsVal_int(obj1, &val2);
34572 if (!SWIG_IsOK(ecode2)) {
34573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34574 }
34575 arg2 = static_cast< wxDragResult >(val2);
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 (arg1)->SetDefaultAction(arg2);
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 resultobj = SWIG_Py_Void();
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34590 PyObject *resultobj = 0;
34591 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34592 wxDragResult result;
34593 void *argp1 = 0 ;
34594 int res1 = 0 ;
34595 PyObject *swig_obj[1] ;
34596
34597 if (!args) SWIG_fail;
34598 swig_obj[0] = args;
34599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34600 if (!SWIG_IsOK(res1)) {
34601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34602 }
34603 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 result = (wxDragResult)(arg1)->GetDefaultAction();
34607 wxPyEndAllowThreads(__tstate);
34608 if (PyErr_Occurred()) SWIG_fail;
34609 }
34610 resultobj = SWIG_From_int(static_cast< int >(result));
34611 return resultobj;
34612 fail:
34613 return NULL;
34614 }
34615
34616
34617 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34618 PyObject *obj;
34619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34620 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34621 return SWIG_Py_Void();
34622 }
34623
34624 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34625 return SWIG_Python_InitShadowInstance(args);
34626 }
34627
34628 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34629 PyObject *resultobj = 0;
34630 wxPyTextDropTarget *result = 0 ;
34631
34632 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34640 return resultobj;
34641 fail:
34642 return NULL;
34643 }
34644
34645
34646 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34647 PyObject *resultobj = 0;
34648 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34649 PyObject *arg2 = (PyObject *) 0 ;
34650 PyObject *arg3 = (PyObject *) 0 ;
34651 void *argp1 = 0 ;
34652 int res1 = 0 ;
34653 PyObject * obj0 = 0 ;
34654 PyObject * obj1 = 0 ;
34655 PyObject * obj2 = 0 ;
34656 char * kwnames[] = {
34657 (char *) "self",(char *) "self",(char *) "_class", NULL
34658 };
34659
34660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34662 if (!SWIG_IsOK(res1)) {
34663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34664 }
34665 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34666 arg2 = obj1;
34667 arg3 = obj2;
34668 {
34669 PyThreadState* __tstate = wxPyBeginAllowThreads();
34670 (arg1)->_setCallbackInfo(arg2,arg3);
34671 wxPyEndAllowThreads(__tstate);
34672 if (PyErr_Occurred()) SWIG_fail;
34673 }
34674 resultobj = SWIG_Py_Void();
34675 return resultobj;
34676 fail:
34677 return NULL;
34678 }
34679
34680
34681 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34682 PyObject *resultobj = 0;
34683 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34684 int arg2 ;
34685 int arg3 ;
34686 wxString *arg4 = 0 ;
34687 bool result;
34688 void *argp1 = 0 ;
34689 int res1 = 0 ;
34690 int val2 ;
34691 int ecode2 = 0 ;
34692 int val3 ;
34693 int ecode3 = 0 ;
34694 bool temp4 = false ;
34695 PyObject * obj0 = 0 ;
34696 PyObject * obj1 = 0 ;
34697 PyObject * obj2 = 0 ;
34698 PyObject * obj3 = 0 ;
34699 char * kwnames[] = {
34700 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34701 };
34702
34703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34705 if (!SWIG_IsOK(res1)) {
34706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34707 }
34708 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34709 ecode2 = SWIG_AsVal_int(obj1, &val2);
34710 if (!SWIG_IsOK(ecode2)) {
34711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34712 }
34713 arg2 = static_cast< int >(val2);
34714 ecode3 = SWIG_AsVal_int(obj2, &val3);
34715 if (!SWIG_IsOK(ecode3)) {
34716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34717 }
34718 arg3 = static_cast< int >(val3);
34719 {
34720 arg4 = wxString_in_helper(obj3);
34721 if (arg4 == NULL) SWIG_fail;
34722 temp4 = true;
34723 }
34724 {
34725 PyThreadState* __tstate = wxPyBeginAllowThreads();
34726 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34727 wxPyEndAllowThreads(__tstate);
34728 if (PyErr_Occurred()) SWIG_fail;
34729 }
34730 {
34731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34732 }
34733 {
34734 if (temp4)
34735 delete arg4;
34736 }
34737 return resultobj;
34738 fail:
34739 {
34740 if (temp4)
34741 delete arg4;
34742 }
34743 return NULL;
34744 }
34745
34746
34747 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34748 PyObject *resultobj = 0;
34749 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34750 int arg2 ;
34751 int arg3 ;
34752 wxDragResult arg4 ;
34753 wxDragResult result;
34754 void *argp1 = 0 ;
34755 int res1 = 0 ;
34756 int val2 ;
34757 int ecode2 = 0 ;
34758 int val3 ;
34759 int ecode3 = 0 ;
34760 int val4 ;
34761 int ecode4 = 0 ;
34762 PyObject * obj0 = 0 ;
34763 PyObject * obj1 = 0 ;
34764 PyObject * obj2 = 0 ;
34765 PyObject * obj3 = 0 ;
34766 char * kwnames[] = {
34767 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34768 };
34769
34770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34772 if (!SWIG_IsOK(res1)) {
34773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34774 }
34775 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34776 ecode2 = SWIG_AsVal_int(obj1, &val2);
34777 if (!SWIG_IsOK(ecode2)) {
34778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34779 }
34780 arg2 = static_cast< int >(val2);
34781 ecode3 = SWIG_AsVal_int(obj2, &val3);
34782 if (!SWIG_IsOK(ecode3)) {
34783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34784 }
34785 arg3 = static_cast< int >(val3);
34786 ecode4 = SWIG_AsVal_int(obj3, &val4);
34787 if (!SWIG_IsOK(ecode4)) {
34788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34789 }
34790 arg4 = static_cast< wxDragResult >(val4);
34791 {
34792 PyThreadState* __tstate = wxPyBeginAllowThreads();
34793 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34794 wxPyEndAllowThreads(__tstate);
34795 if (PyErr_Occurred()) SWIG_fail;
34796 }
34797 resultobj = SWIG_From_int(static_cast< int >(result));
34798 return resultobj;
34799 fail:
34800 return NULL;
34801 }
34802
34803
34804 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34805 PyObject *resultobj = 0;
34806 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34807 int arg2 ;
34808 int arg3 ;
34809 wxDragResult arg4 ;
34810 wxDragResult result;
34811 void *argp1 = 0 ;
34812 int res1 = 0 ;
34813 int val2 ;
34814 int ecode2 = 0 ;
34815 int val3 ;
34816 int ecode3 = 0 ;
34817 int val4 ;
34818 int ecode4 = 0 ;
34819 PyObject * obj0 = 0 ;
34820 PyObject * obj1 = 0 ;
34821 PyObject * obj2 = 0 ;
34822 PyObject * obj3 = 0 ;
34823 char * kwnames[] = {
34824 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34825 };
34826
34827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34829 if (!SWIG_IsOK(res1)) {
34830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34831 }
34832 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34833 ecode2 = SWIG_AsVal_int(obj1, &val2);
34834 if (!SWIG_IsOK(ecode2)) {
34835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34836 }
34837 arg2 = static_cast< int >(val2);
34838 ecode3 = SWIG_AsVal_int(obj2, &val3);
34839 if (!SWIG_IsOK(ecode3)) {
34840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34841 }
34842 arg3 = static_cast< int >(val3);
34843 ecode4 = SWIG_AsVal_int(obj3, &val4);
34844 if (!SWIG_IsOK(ecode4)) {
34845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34846 }
34847 arg4 = static_cast< wxDragResult >(val4);
34848 {
34849 PyThreadState* __tstate = wxPyBeginAllowThreads();
34850 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 resultobj = SWIG_From_int(static_cast< int >(result));
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34862 PyObject *resultobj = 0;
34863 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34864 void *argp1 = 0 ;
34865 int res1 = 0 ;
34866 PyObject *swig_obj[1] ;
34867
34868 if (!args) SWIG_fail;
34869 swig_obj[0] = args;
34870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34871 if (!SWIG_IsOK(res1)) {
34872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34873 }
34874 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34875 {
34876 PyThreadState* __tstate = wxPyBeginAllowThreads();
34877 (arg1)->OnLeave();
34878 wxPyEndAllowThreads(__tstate);
34879 if (PyErr_Occurred()) SWIG_fail;
34880 }
34881 resultobj = SWIG_Py_Void();
34882 return resultobj;
34883 fail:
34884 return NULL;
34885 }
34886
34887
34888 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34889 PyObject *resultobj = 0;
34890 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34891 int arg2 ;
34892 int arg3 ;
34893 bool result;
34894 void *argp1 = 0 ;
34895 int res1 = 0 ;
34896 int val2 ;
34897 int ecode2 = 0 ;
34898 int val3 ;
34899 int ecode3 = 0 ;
34900 PyObject * obj0 = 0 ;
34901 PyObject * obj1 = 0 ;
34902 PyObject * obj2 = 0 ;
34903 char * kwnames[] = {
34904 (char *) "self",(char *) "x",(char *) "y", NULL
34905 };
34906
34907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34909 if (!SWIG_IsOK(res1)) {
34910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34911 }
34912 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34913 ecode2 = SWIG_AsVal_int(obj1, &val2);
34914 if (!SWIG_IsOK(ecode2)) {
34915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34916 }
34917 arg2 = static_cast< int >(val2);
34918 ecode3 = SWIG_AsVal_int(obj2, &val3);
34919 if (!SWIG_IsOK(ecode3)) {
34920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34921 }
34922 arg3 = static_cast< int >(val3);
34923 {
34924 PyThreadState* __tstate = wxPyBeginAllowThreads();
34925 result = (bool)(arg1)->OnDrop(arg2,arg3);
34926 wxPyEndAllowThreads(__tstate);
34927 if (PyErr_Occurred()) SWIG_fail;
34928 }
34929 {
34930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34931 }
34932 return resultobj;
34933 fail:
34934 return NULL;
34935 }
34936
34937
34938 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34939 PyObject *resultobj = 0;
34940 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34941 int arg2 ;
34942 int arg3 ;
34943 wxDragResult arg4 ;
34944 wxDragResult result;
34945 void *argp1 = 0 ;
34946 int res1 = 0 ;
34947 int val2 ;
34948 int ecode2 = 0 ;
34949 int val3 ;
34950 int ecode3 = 0 ;
34951 int val4 ;
34952 int ecode4 = 0 ;
34953 PyObject * obj0 = 0 ;
34954 PyObject * obj1 = 0 ;
34955 PyObject * obj2 = 0 ;
34956 PyObject * obj3 = 0 ;
34957 char * kwnames[] = {
34958 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34959 };
34960
34961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34963 if (!SWIG_IsOK(res1)) {
34964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34965 }
34966 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34967 ecode2 = SWIG_AsVal_int(obj1, &val2);
34968 if (!SWIG_IsOK(ecode2)) {
34969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34970 }
34971 arg2 = static_cast< int >(val2);
34972 ecode3 = SWIG_AsVal_int(obj2, &val3);
34973 if (!SWIG_IsOK(ecode3)) {
34974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34975 }
34976 arg3 = static_cast< int >(val3);
34977 ecode4 = SWIG_AsVal_int(obj3, &val4);
34978 if (!SWIG_IsOK(ecode4)) {
34979 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34980 }
34981 arg4 = static_cast< wxDragResult >(val4);
34982 {
34983 PyThreadState* __tstate = wxPyBeginAllowThreads();
34984 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34985 wxPyEndAllowThreads(__tstate);
34986 if (PyErr_Occurred()) SWIG_fail;
34987 }
34988 resultobj = SWIG_From_int(static_cast< int >(result));
34989 return resultobj;
34990 fail:
34991 return NULL;
34992 }
34993
34994
34995 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34996 PyObject *obj;
34997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34998 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34999 return SWIG_Py_Void();
35000 }
35001
35002 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35003 return SWIG_Python_InitShadowInstance(args);
35004 }
35005
35006 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35007 PyObject *resultobj = 0;
35008 wxPyFileDropTarget *result = 0 ;
35009
35010 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
35011 {
35012 PyThreadState* __tstate = wxPyBeginAllowThreads();
35013 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
35014 wxPyEndAllowThreads(__tstate);
35015 if (PyErr_Occurred()) SWIG_fail;
35016 }
35017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
35018 return resultobj;
35019 fail:
35020 return NULL;
35021 }
35022
35023
35024 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35025 PyObject *resultobj = 0;
35026 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35027 PyObject *arg2 = (PyObject *) 0 ;
35028 PyObject *arg3 = (PyObject *) 0 ;
35029 void *argp1 = 0 ;
35030 int res1 = 0 ;
35031 PyObject * obj0 = 0 ;
35032 PyObject * obj1 = 0 ;
35033 PyObject * obj2 = 0 ;
35034 char * kwnames[] = {
35035 (char *) "self",(char *) "self",(char *) "_class", NULL
35036 };
35037
35038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35040 if (!SWIG_IsOK(res1)) {
35041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35042 }
35043 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35044 arg2 = obj1;
35045 arg3 = obj2;
35046 {
35047 PyThreadState* __tstate = wxPyBeginAllowThreads();
35048 (arg1)->_setCallbackInfo(arg2,arg3);
35049 wxPyEndAllowThreads(__tstate);
35050 if (PyErr_Occurred()) SWIG_fail;
35051 }
35052 resultobj = SWIG_Py_Void();
35053 return resultobj;
35054 fail:
35055 return NULL;
35056 }
35057
35058
35059 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35060 PyObject *resultobj = 0;
35061 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35062 int arg2 ;
35063 int arg3 ;
35064 wxArrayString *arg4 = 0 ;
35065 bool result;
35066 void *argp1 = 0 ;
35067 int res1 = 0 ;
35068 int val2 ;
35069 int ecode2 = 0 ;
35070 int val3 ;
35071 int ecode3 = 0 ;
35072 bool temp4 = false ;
35073 PyObject * obj0 = 0 ;
35074 PyObject * obj1 = 0 ;
35075 PyObject * obj2 = 0 ;
35076 PyObject * obj3 = 0 ;
35077 char * kwnames[] = {
35078 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35079 };
35080
35081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35083 if (!SWIG_IsOK(res1)) {
35084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35085 }
35086 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35087 ecode2 = SWIG_AsVal_int(obj1, &val2);
35088 if (!SWIG_IsOK(ecode2)) {
35089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35090 }
35091 arg2 = static_cast< int >(val2);
35092 ecode3 = SWIG_AsVal_int(obj2, &val3);
35093 if (!SWIG_IsOK(ecode3)) {
35094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35095 }
35096 arg3 = static_cast< int >(val3);
35097 {
35098 if (! PySequence_Check(obj3)) {
35099 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35100 SWIG_fail;
35101 }
35102 arg4 = new wxArrayString;
35103 temp4 = true;
35104 int i, len=PySequence_Length(obj3);
35105 for (i=0; i<len; i++) {
35106 PyObject* item = PySequence_GetItem(obj3, i);
35107 wxString* s = wxString_in_helper(item);
35108 if (PyErr_Occurred()) SWIG_fail;
35109 arg4->Add(*s);
35110 delete s;
35111 Py_DECREF(item);
35112 }
35113 }
35114 {
35115 PyThreadState* __tstate = wxPyBeginAllowThreads();
35116 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35117 wxPyEndAllowThreads(__tstate);
35118 if (PyErr_Occurred()) SWIG_fail;
35119 }
35120 {
35121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35122 }
35123 {
35124 if (temp4) delete arg4;
35125 }
35126 return resultobj;
35127 fail:
35128 {
35129 if (temp4) delete arg4;
35130 }
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35136 PyObject *resultobj = 0;
35137 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35138 int arg2 ;
35139 int arg3 ;
35140 wxDragResult arg4 ;
35141 wxDragResult result;
35142 void *argp1 = 0 ;
35143 int res1 = 0 ;
35144 int val2 ;
35145 int ecode2 = 0 ;
35146 int val3 ;
35147 int ecode3 = 0 ;
35148 int val4 ;
35149 int ecode4 = 0 ;
35150 PyObject * obj0 = 0 ;
35151 PyObject * obj1 = 0 ;
35152 PyObject * obj2 = 0 ;
35153 PyObject * obj3 = 0 ;
35154 char * kwnames[] = {
35155 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35156 };
35157
35158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35160 if (!SWIG_IsOK(res1)) {
35161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35162 }
35163 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35164 ecode2 = SWIG_AsVal_int(obj1, &val2);
35165 if (!SWIG_IsOK(ecode2)) {
35166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35167 }
35168 arg2 = static_cast< int >(val2);
35169 ecode3 = SWIG_AsVal_int(obj2, &val3);
35170 if (!SWIG_IsOK(ecode3)) {
35171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35172 }
35173 arg3 = static_cast< int >(val3);
35174 ecode4 = SWIG_AsVal_int(obj3, &val4);
35175 if (!SWIG_IsOK(ecode4)) {
35176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35177 }
35178 arg4 = static_cast< wxDragResult >(val4);
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35182 wxPyEndAllowThreads(__tstate);
35183 if (PyErr_Occurred()) SWIG_fail;
35184 }
35185 resultobj = SWIG_From_int(static_cast< int >(result));
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35193 PyObject *resultobj = 0;
35194 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35195 int arg2 ;
35196 int arg3 ;
35197 wxDragResult arg4 ;
35198 wxDragResult result;
35199 void *argp1 = 0 ;
35200 int res1 = 0 ;
35201 int val2 ;
35202 int ecode2 = 0 ;
35203 int val3 ;
35204 int ecode3 = 0 ;
35205 int val4 ;
35206 int ecode4 = 0 ;
35207 PyObject * obj0 = 0 ;
35208 PyObject * obj1 = 0 ;
35209 PyObject * obj2 = 0 ;
35210 PyObject * obj3 = 0 ;
35211 char * kwnames[] = {
35212 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35213 };
35214
35215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35217 if (!SWIG_IsOK(res1)) {
35218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35219 }
35220 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35221 ecode2 = SWIG_AsVal_int(obj1, &val2);
35222 if (!SWIG_IsOK(ecode2)) {
35223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35224 }
35225 arg2 = static_cast< int >(val2);
35226 ecode3 = SWIG_AsVal_int(obj2, &val3);
35227 if (!SWIG_IsOK(ecode3)) {
35228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35229 }
35230 arg3 = static_cast< int >(val3);
35231 ecode4 = SWIG_AsVal_int(obj3, &val4);
35232 if (!SWIG_IsOK(ecode4)) {
35233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35234 }
35235 arg4 = static_cast< wxDragResult >(val4);
35236 {
35237 PyThreadState* __tstate = wxPyBeginAllowThreads();
35238 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35239 wxPyEndAllowThreads(__tstate);
35240 if (PyErr_Occurred()) SWIG_fail;
35241 }
35242 resultobj = SWIG_From_int(static_cast< int >(result));
35243 return resultobj;
35244 fail:
35245 return NULL;
35246 }
35247
35248
35249 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35250 PyObject *resultobj = 0;
35251 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35252 void *argp1 = 0 ;
35253 int res1 = 0 ;
35254 PyObject *swig_obj[1] ;
35255
35256 if (!args) SWIG_fail;
35257 swig_obj[0] = args;
35258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35259 if (!SWIG_IsOK(res1)) {
35260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35261 }
35262 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 (arg1)->OnLeave();
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_Py_Void();
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35277 PyObject *resultobj = 0;
35278 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35279 int arg2 ;
35280 int arg3 ;
35281 bool result;
35282 void *argp1 = 0 ;
35283 int res1 = 0 ;
35284 int val2 ;
35285 int ecode2 = 0 ;
35286 int val3 ;
35287 int ecode3 = 0 ;
35288 PyObject * obj0 = 0 ;
35289 PyObject * obj1 = 0 ;
35290 PyObject * obj2 = 0 ;
35291 char * kwnames[] = {
35292 (char *) "self",(char *) "x",(char *) "y", NULL
35293 };
35294
35295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35297 if (!SWIG_IsOK(res1)) {
35298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35299 }
35300 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35301 ecode2 = SWIG_AsVal_int(obj1, &val2);
35302 if (!SWIG_IsOK(ecode2)) {
35303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35304 }
35305 arg2 = static_cast< int >(val2);
35306 ecode3 = SWIG_AsVal_int(obj2, &val3);
35307 if (!SWIG_IsOK(ecode3)) {
35308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35309 }
35310 arg3 = static_cast< int >(val3);
35311 {
35312 PyThreadState* __tstate = wxPyBeginAllowThreads();
35313 result = (bool)(arg1)->OnDrop(arg2,arg3);
35314 wxPyEndAllowThreads(__tstate);
35315 if (PyErr_Occurred()) SWIG_fail;
35316 }
35317 {
35318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35319 }
35320 return resultobj;
35321 fail:
35322 return NULL;
35323 }
35324
35325
35326 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35327 PyObject *resultobj = 0;
35328 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35329 int arg2 ;
35330 int arg3 ;
35331 wxDragResult arg4 ;
35332 wxDragResult result;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 int val2 ;
35336 int ecode2 = 0 ;
35337 int val3 ;
35338 int ecode3 = 0 ;
35339 int val4 ;
35340 int ecode4 = 0 ;
35341 PyObject * obj0 = 0 ;
35342 PyObject * obj1 = 0 ;
35343 PyObject * obj2 = 0 ;
35344 PyObject * obj3 = 0 ;
35345 char * kwnames[] = {
35346 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35347 };
35348
35349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35351 if (!SWIG_IsOK(res1)) {
35352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35353 }
35354 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35355 ecode2 = SWIG_AsVal_int(obj1, &val2);
35356 if (!SWIG_IsOK(ecode2)) {
35357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35358 }
35359 arg2 = static_cast< int >(val2);
35360 ecode3 = SWIG_AsVal_int(obj2, &val3);
35361 if (!SWIG_IsOK(ecode3)) {
35362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35363 }
35364 arg3 = static_cast< int >(val3);
35365 ecode4 = SWIG_AsVal_int(obj3, &val4);
35366 if (!SWIG_IsOK(ecode4)) {
35367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35368 }
35369 arg4 = static_cast< wxDragResult >(val4);
35370 {
35371 PyThreadState* __tstate = wxPyBeginAllowThreads();
35372 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35373 wxPyEndAllowThreads(__tstate);
35374 if (PyErr_Occurred()) SWIG_fail;
35375 }
35376 resultobj = SWIG_From_int(static_cast< int >(result));
35377 return resultobj;
35378 fail:
35379 return NULL;
35380 }
35381
35382
35383 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35384 PyObject *obj;
35385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35386 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35387 return SWIG_Py_Void();
35388 }
35389
35390 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35391 return SWIG_Python_InitShadowInstance(args);
35392 }
35393
35394 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35395 PyObject *resultobj = 0;
35396 wxClipboard *result = 0 ;
35397
35398 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = (wxClipboard *)new wxClipboard();
35402 wxPyEndAllowThreads(__tstate);
35403 if (PyErr_Occurred()) SWIG_fail;
35404 }
35405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35406 return resultobj;
35407 fail:
35408 return NULL;
35409 }
35410
35411
35412 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35413 PyObject *resultobj = 0;
35414 wxClipboard *arg1 = (wxClipboard *) 0 ;
35415 void *argp1 = 0 ;
35416 int res1 = 0 ;
35417 PyObject *swig_obj[1] ;
35418
35419 if (!args) SWIG_fail;
35420 swig_obj[0] = args;
35421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35422 if (!SWIG_IsOK(res1)) {
35423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35424 }
35425 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35426 {
35427 PyThreadState* __tstate = wxPyBeginAllowThreads();
35428 delete arg1;
35429
35430 wxPyEndAllowThreads(__tstate);
35431 if (PyErr_Occurred()) SWIG_fail;
35432 }
35433 resultobj = SWIG_Py_Void();
35434 return resultobj;
35435 fail:
35436 return NULL;
35437 }
35438
35439
35440 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35441 PyObject *resultobj = 0;
35442 wxClipboard *arg1 = (wxClipboard *) 0 ;
35443 bool result;
35444 void *argp1 = 0 ;
35445 int res1 = 0 ;
35446 PyObject *swig_obj[1] ;
35447
35448 if (!args) SWIG_fail;
35449 swig_obj[0] = args;
35450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35451 if (!SWIG_IsOK(res1)) {
35452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35453 }
35454 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35455 {
35456 PyThreadState* __tstate = wxPyBeginAllowThreads();
35457 result = (bool)(arg1)->Open();
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 {
35462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35463 }
35464 return resultobj;
35465 fail:
35466 return NULL;
35467 }
35468
35469
35470 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35471 PyObject *resultobj = 0;
35472 wxClipboard *arg1 = (wxClipboard *) 0 ;
35473 void *argp1 = 0 ;
35474 int res1 = 0 ;
35475 PyObject *swig_obj[1] ;
35476
35477 if (!args) SWIG_fail;
35478 swig_obj[0] = args;
35479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35480 if (!SWIG_IsOK(res1)) {
35481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35482 }
35483 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 (arg1)->Close();
35487 wxPyEndAllowThreads(__tstate);
35488 if (PyErr_Occurred()) SWIG_fail;
35489 }
35490 resultobj = SWIG_Py_Void();
35491 return resultobj;
35492 fail:
35493 return NULL;
35494 }
35495
35496
35497 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35498 PyObject *resultobj = 0;
35499 wxClipboard *arg1 = (wxClipboard *) 0 ;
35500 bool result;
35501 void *argp1 = 0 ;
35502 int res1 = 0 ;
35503 PyObject *swig_obj[1] ;
35504
35505 if (!args) SWIG_fail;
35506 swig_obj[0] = args;
35507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35508 if (!SWIG_IsOK(res1)) {
35509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35510 }
35511 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 {
35519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35520 }
35521 return resultobj;
35522 fail:
35523 return NULL;
35524 }
35525
35526
35527 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35528 PyObject *resultobj = 0;
35529 wxClipboard *arg1 = (wxClipboard *) 0 ;
35530 wxDataObject *arg2 = (wxDataObject *) 0 ;
35531 bool result;
35532 void *argp1 = 0 ;
35533 int res1 = 0 ;
35534 int res2 = 0 ;
35535 PyObject * obj0 = 0 ;
35536 PyObject * obj1 = 0 ;
35537 char * kwnames[] = {
35538 (char *) "self",(char *) "data", NULL
35539 };
35540
35541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35543 if (!SWIG_IsOK(res1)) {
35544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35545 }
35546 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35547 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35548 if (!SWIG_IsOK(res2)) {
35549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35550 }
35551 {
35552 PyThreadState* __tstate = wxPyBeginAllowThreads();
35553 result = (bool)(arg1)->AddData(arg2);
35554 wxPyEndAllowThreads(__tstate);
35555 if (PyErr_Occurred()) SWIG_fail;
35556 }
35557 {
35558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35559 }
35560 return resultobj;
35561 fail:
35562 return NULL;
35563 }
35564
35565
35566 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35567 PyObject *resultobj = 0;
35568 wxClipboard *arg1 = (wxClipboard *) 0 ;
35569 wxDataObject *arg2 = (wxDataObject *) 0 ;
35570 bool result;
35571 void *argp1 = 0 ;
35572 int res1 = 0 ;
35573 int res2 = 0 ;
35574 PyObject * obj0 = 0 ;
35575 PyObject * obj1 = 0 ;
35576 char * kwnames[] = {
35577 (char *) "self",(char *) "data", NULL
35578 };
35579
35580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35582 if (!SWIG_IsOK(res1)) {
35583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35584 }
35585 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35586 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35587 if (!SWIG_IsOK(res2)) {
35588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35589 }
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 result = (bool)(arg1)->SetData(arg2);
35593 wxPyEndAllowThreads(__tstate);
35594 if (PyErr_Occurred()) SWIG_fail;
35595 }
35596 {
35597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35598 }
35599 return resultobj;
35600 fail:
35601 return NULL;
35602 }
35603
35604
35605 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35606 PyObject *resultobj = 0;
35607 wxClipboard *arg1 = (wxClipboard *) 0 ;
35608 wxDataFormat *arg2 = 0 ;
35609 bool result;
35610 void *argp1 = 0 ;
35611 int res1 = 0 ;
35612 void *argp2 = 0 ;
35613 int res2 = 0 ;
35614 PyObject * obj0 = 0 ;
35615 PyObject * obj1 = 0 ;
35616 char * kwnames[] = {
35617 (char *) "self",(char *) "format", NULL
35618 };
35619
35620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35622 if (!SWIG_IsOK(res1)) {
35623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35624 }
35625 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35626 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35627 if (!SWIG_IsOK(res2)) {
35628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35629 }
35630 if (!argp2) {
35631 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35632 }
35633 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35634 {
35635 PyThreadState* __tstate = wxPyBeginAllowThreads();
35636 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35637 wxPyEndAllowThreads(__tstate);
35638 if (PyErr_Occurred()) SWIG_fail;
35639 }
35640 {
35641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35642 }
35643 return resultobj;
35644 fail:
35645 return NULL;
35646 }
35647
35648
35649 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35650 PyObject *resultobj = 0;
35651 wxClipboard *arg1 = (wxClipboard *) 0 ;
35652 wxDataObject *arg2 = 0 ;
35653 bool result;
35654 void *argp1 = 0 ;
35655 int res1 = 0 ;
35656 void *argp2 = 0 ;
35657 int res2 = 0 ;
35658 PyObject * obj0 = 0 ;
35659 PyObject * obj1 = 0 ;
35660 char * kwnames[] = {
35661 (char *) "self",(char *) "data", NULL
35662 };
35663
35664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35666 if (!SWIG_IsOK(res1)) {
35667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35668 }
35669 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35670 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35671 if (!SWIG_IsOK(res2)) {
35672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35673 }
35674 if (!argp2) {
35675 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35676 }
35677 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35678 {
35679 PyThreadState* __tstate = wxPyBeginAllowThreads();
35680 result = (bool)(arg1)->GetData(*arg2);
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 {
35685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35686 }
35687 return resultobj;
35688 fail:
35689 return NULL;
35690 }
35691
35692
35693 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35694 PyObject *resultobj = 0;
35695 wxClipboard *arg1 = (wxClipboard *) 0 ;
35696 void *argp1 = 0 ;
35697 int res1 = 0 ;
35698 PyObject *swig_obj[1] ;
35699
35700 if (!args) SWIG_fail;
35701 swig_obj[0] = args;
35702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35703 if (!SWIG_IsOK(res1)) {
35704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35705 }
35706 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35707 {
35708 PyThreadState* __tstate = wxPyBeginAllowThreads();
35709 (arg1)->Clear();
35710 wxPyEndAllowThreads(__tstate);
35711 if (PyErr_Occurred()) SWIG_fail;
35712 }
35713 resultobj = SWIG_Py_Void();
35714 return resultobj;
35715 fail:
35716 return NULL;
35717 }
35718
35719
35720 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35721 PyObject *resultobj = 0;
35722 wxClipboard *arg1 = (wxClipboard *) 0 ;
35723 bool result;
35724 void *argp1 = 0 ;
35725 int res1 = 0 ;
35726 PyObject *swig_obj[1] ;
35727
35728 if (!args) SWIG_fail;
35729 swig_obj[0] = args;
35730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35731 if (!SWIG_IsOK(res1)) {
35732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35733 }
35734 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35735 {
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 result = (bool)(arg1)->Flush();
35738 wxPyEndAllowThreads(__tstate);
35739 if (PyErr_Occurred()) SWIG_fail;
35740 }
35741 {
35742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35743 }
35744 return resultobj;
35745 fail:
35746 return NULL;
35747 }
35748
35749
35750 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35751 PyObject *resultobj = 0;
35752 wxClipboard *arg1 = (wxClipboard *) 0 ;
35753 bool arg2 = (bool) true ;
35754 void *argp1 = 0 ;
35755 int res1 = 0 ;
35756 bool val2 ;
35757 int ecode2 = 0 ;
35758 PyObject * obj0 = 0 ;
35759 PyObject * obj1 = 0 ;
35760 char * kwnames[] = {
35761 (char *) "self",(char *) "primary", NULL
35762 };
35763
35764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35766 if (!SWIG_IsOK(res1)) {
35767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35768 }
35769 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35770 if (obj1) {
35771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35772 if (!SWIG_IsOK(ecode2)) {
35773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35774 }
35775 arg2 = static_cast< bool >(val2);
35776 }
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 (arg1)->UsePrimarySelection(arg2);
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 resultobj = SWIG_Py_Void();
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35791 PyObject *resultobj = 0;
35792 wxClipboard *result = 0 ;
35793
35794 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35795 {
35796 PyThreadState* __tstate = wxPyBeginAllowThreads();
35797 result = (wxClipboard *)wxClipboard::Get();
35798 wxPyEndAllowThreads(__tstate);
35799 if (PyErr_Occurred()) SWIG_fail;
35800 }
35801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35802 return resultobj;
35803 fail:
35804 return NULL;
35805 }
35806
35807
35808 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35809 PyObject *obj;
35810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35811 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35812 return SWIG_Py_Void();
35813 }
35814
35815 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35816 return SWIG_Python_InitShadowInstance(args);
35817 }
35818
35819 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj = 0;
35821 wxClipboard *arg1 = (wxClipboard *) NULL ;
35822 wxClipboardLocker *result = 0 ;
35823 void *argp1 = 0 ;
35824 int res1 = 0 ;
35825 PyObject * obj0 = 0 ;
35826 char * kwnames[] = {
35827 (char *) "clipboard", NULL
35828 };
35829
35830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35831 if (obj0) {
35832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35833 if (!SWIG_IsOK(res1)) {
35834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35835 }
35836 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35837 }
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35841 wxPyEndAllowThreads(__tstate);
35842 if (PyErr_Occurred()) SWIG_fail;
35843 }
35844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35845 return resultobj;
35846 fail:
35847 return NULL;
35848 }
35849
35850
35851 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35852 PyObject *resultobj = 0;
35853 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35854 void *argp1 = 0 ;
35855 int res1 = 0 ;
35856 PyObject *swig_obj[1] ;
35857
35858 if (!args) SWIG_fail;
35859 swig_obj[0] = args;
35860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35861 if (!SWIG_IsOK(res1)) {
35862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35863 }
35864 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35865 {
35866 PyThreadState* __tstate = wxPyBeginAllowThreads();
35867 delete arg1;
35868
35869 wxPyEndAllowThreads(__tstate);
35870 if (PyErr_Occurred()) SWIG_fail;
35871 }
35872 resultobj = SWIG_Py_Void();
35873 return resultobj;
35874 fail:
35875 return NULL;
35876 }
35877
35878
35879 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35880 PyObject *resultobj = 0;
35881 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35882 bool result;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 PyObject *swig_obj[1] ;
35886
35887 if (!args) SWIG_fail;
35888 swig_obj[0] = args;
35889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35890 if (!SWIG_IsOK(res1)) {
35891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35892 }
35893 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35894 {
35895 PyThreadState* __tstate = wxPyBeginAllowThreads();
35896 result = (bool)wxClipboardLocker___nonzero__(arg1);
35897 wxPyEndAllowThreads(__tstate);
35898 if (PyErr_Occurred()) SWIG_fail;
35899 }
35900 {
35901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35902 }
35903 return resultobj;
35904 fail:
35905 return NULL;
35906 }
35907
35908
35909 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35910 PyObject *obj;
35911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35912 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35913 return SWIG_Py_Void();
35914 }
35915
35916 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35917 return SWIG_Python_InitShadowInstance(args);
35918 }
35919
35920 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35921 PyObject *resultobj = 0;
35922 int arg1 = (int) 0 ;
35923 int arg2 = (int) 0 ;
35924 int arg3 = (int) 0 ;
35925 int arg4 = (int) 0 ;
35926 wxVideoMode *result = 0 ;
35927 int val1 ;
35928 int ecode1 = 0 ;
35929 int val2 ;
35930 int ecode2 = 0 ;
35931 int val3 ;
35932 int ecode3 = 0 ;
35933 int val4 ;
35934 int ecode4 = 0 ;
35935 PyObject * obj0 = 0 ;
35936 PyObject * obj1 = 0 ;
35937 PyObject * obj2 = 0 ;
35938 PyObject * obj3 = 0 ;
35939 char * kwnames[] = {
35940 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35941 };
35942
35943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35944 if (obj0) {
35945 ecode1 = SWIG_AsVal_int(obj0, &val1);
35946 if (!SWIG_IsOK(ecode1)) {
35947 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35948 }
35949 arg1 = static_cast< int >(val1);
35950 }
35951 if (obj1) {
35952 ecode2 = SWIG_AsVal_int(obj1, &val2);
35953 if (!SWIG_IsOK(ecode2)) {
35954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35955 }
35956 arg2 = static_cast< int >(val2);
35957 }
35958 if (obj2) {
35959 ecode3 = SWIG_AsVal_int(obj2, &val3);
35960 if (!SWIG_IsOK(ecode3)) {
35961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35962 }
35963 arg3 = static_cast< int >(val3);
35964 }
35965 if (obj3) {
35966 ecode4 = SWIG_AsVal_int(obj3, &val4);
35967 if (!SWIG_IsOK(ecode4)) {
35968 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35969 }
35970 arg4 = static_cast< int >(val4);
35971 }
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35986 PyObject *resultobj = 0;
35987 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35988 void *argp1 = 0 ;
35989 int res1 = 0 ;
35990 PyObject *swig_obj[1] ;
35991
35992 if (!args) SWIG_fail;
35993 swig_obj[0] = args;
35994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35995 if (!SWIG_IsOK(res1)) {
35996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35997 }
35998 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 delete arg1;
36002
36003 wxPyEndAllowThreads(__tstate);
36004 if (PyErr_Occurred()) SWIG_fail;
36005 }
36006 resultobj = SWIG_Py_Void();
36007 return resultobj;
36008 fail:
36009 return NULL;
36010 }
36011
36012
36013 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36014 PyObject *resultobj = 0;
36015 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36016 wxVideoMode *arg2 = 0 ;
36017 bool result;
36018 void *argp1 = 0 ;
36019 int res1 = 0 ;
36020 void *argp2 = 0 ;
36021 int res2 = 0 ;
36022 PyObject * obj0 = 0 ;
36023 PyObject * obj1 = 0 ;
36024 char * kwnames[] = {
36025 (char *) "self",(char *) "other", NULL
36026 };
36027
36028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
36029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36030 if (!SWIG_IsOK(res1)) {
36031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36032 }
36033 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36034 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36035 if (!SWIG_IsOK(res2)) {
36036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36037 }
36038 if (!argp2) {
36039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36040 }
36041 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36042 {
36043 PyThreadState* __tstate = wxPyBeginAllowThreads();
36044 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 {
36049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36050 }
36051 return resultobj;
36052 fail:
36053 return NULL;
36054 }
36055
36056
36057 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36058 PyObject *resultobj = 0;
36059 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36060 int result;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 PyObject *swig_obj[1] ;
36064
36065 if (!args) SWIG_fail;
36066 swig_obj[0] = args;
36067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36068 if (!SWIG_IsOK(res1)) {
36069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36070 }
36071 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 resultobj = SWIG_From_int(static_cast< int >(result));
36079 return resultobj;
36080 fail:
36081 return NULL;
36082 }
36083
36084
36085 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36086 PyObject *resultobj = 0;
36087 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36088 int result;
36089 void *argp1 = 0 ;
36090 int res1 = 0 ;
36091 PyObject *swig_obj[1] ;
36092
36093 if (!args) SWIG_fail;
36094 swig_obj[0] = args;
36095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36096 if (!SWIG_IsOK(res1)) {
36097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36098 }
36099 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36100 {
36101 PyThreadState* __tstate = wxPyBeginAllowThreads();
36102 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36103 wxPyEndAllowThreads(__tstate);
36104 if (PyErr_Occurred()) SWIG_fail;
36105 }
36106 resultobj = SWIG_From_int(static_cast< int >(result));
36107 return resultobj;
36108 fail:
36109 return NULL;
36110 }
36111
36112
36113 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36114 PyObject *resultobj = 0;
36115 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36116 int result;
36117 void *argp1 = 0 ;
36118 int res1 = 0 ;
36119 PyObject *swig_obj[1] ;
36120
36121 if (!args) SWIG_fail;
36122 swig_obj[0] = args;
36123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36124 if (!SWIG_IsOK(res1)) {
36125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36126 }
36127 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36128 {
36129 PyThreadState* __tstate = wxPyBeginAllowThreads();
36130 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36131 wxPyEndAllowThreads(__tstate);
36132 if (PyErr_Occurred()) SWIG_fail;
36133 }
36134 resultobj = SWIG_From_int(static_cast< int >(result));
36135 return resultobj;
36136 fail:
36137 return NULL;
36138 }
36139
36140
36141 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36142 PyObject *resultobj = 0;
36143 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36144 bool result;
36145 void *argp1 = 0 ;
36146 int res1 = 0 ;
36147 PyObject *swig_obj[1] ;
36148
36149 if (!args) SWIG_fail;
36150 swig_obj[0] = args;
36151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36152 if (!SWIG_IsOK(res1)) {
36153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36154 }
36155 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36156 {
36157 PyThreadState* __tstate = wxPyBeginAllowThreads();
36158 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36159 wxPyEndAllowThreads(__tstate);
36160 if (PyErr_Occurred()) SWIG_fail;
36161 }
36162 {
36163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36164 }
36165 return resultobj;
36166 fail:
36167 return NULL;
36168 }
36169
36170
36171 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36172 PyObject *resultobj = 0;
36173 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36174 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36175 bool result;
36176 void *argp1 = 0 ;
36177 int res1 = 0 ;
36178 void *argp2 = 0 ;
36179 int res2 = 0 ;
36180 PyObject * obj0 = 0 ;
36181 PyObject * obj1 = 0 ;
36182 char * kwnames[] = {
36183 (char *) "self",(char *) "other", NULL
36184 };
36185
36186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36188 if (!SWIG_IsOK(res1)) {
36189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36190 }
36191 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36193 if (!SWIG_IsOK(res2)) {
36194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36195 }
36196 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36197 {
36198 PyThreadState* __tstate = wxPyBeginAllowThreads();
36199 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36200 wxPyEndAllowThreads(__tstate);
36201 if (PyErr_Occurred()) SWIG_fail;
36202 }
36203 {
36204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36205 }
36206 return resultobj;
36207 fail:
36208 return NULL;
36209 }
36210
36211
36212 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36213 PyObject *resultobj = 0;
36214 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36215 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36216 bool result;
36217 void *argp1 = 0 ;
36218 int res1 = 0 ;
36219 void *argp2 = 0 ;
36220 int res2 = 0 ;
36221 PyObject * obj0 = 0 ;
36222 PyObject * obj1 = 0 ;
36223 char * kwnames[] = {
36224 (char *) "self",(char *) "other", NULL
36225 };
36226
36227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36229 if (!SWIG_IsOK(res1)) {
36230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36231 }
36232 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36234 if (!SWIG_IsOK(res2)) {
36235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36236 }
36237 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36238 {
36239 PyThreadState* __tstate = wxPyBeginAllowThreads();
36240 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36241 wxPyEndAllowThreads(__tstate);
36242 if (PyErr_Occurred()) SWIG_fail;
36243 }
36244 {
36245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36246 }
36247 return resultobj;
36248 fail:
36249 return NULL;
36250 }
36251
36252
36253 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36254 PyObject *resultobj = 0;
36255 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36256 int arg2 ;
36257 void *argp1 = 0 ;
36258 int res1 = 0 ;
36259 int val2 ;
36260 int ecode2 = 0 ;
36261 PyObject *swig_obj[2] ;
36262
36263 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36265 if (!SWIG_IsOK(res1)) {
36266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36267 }
36268 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36269 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36270 if (!SWIG_IsOK(ecode2)) {
36271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36272 }
36273 arg2 = static_cast< int >(val2);
36274 if (arg1) (arg1)->w = arg2;
36275
36276 resultobj = SWIG_Py_Void();
36277 return resultobj;
36278 fail:
36279 return NULL;
36280 }
36281
36282
36283 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36284 PyObject *resultobj = 0;
36285 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36286 int result;
36287 void *argp1 = 0 ;
36288 int res1 = 0 ;
36289 PyObject *swig_obj[1] ;
36290
36291 if (!args) SWIG_fail;
36292 swig_obj[0] = args;
36293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36294 if (!SWIG_IsOK(res1)) {
36295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36296 }
36297 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36298 result = (int) ((arg1)->w);
36299 resultobj = SWIG_From_int(static_cast< int >(result));
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36307 PyObject *resultobj = 0;
36308 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36309 int arg2 ;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 int val2 ;
36313 int ecode2 = 0 ;
36314 PyObject *swig_obj[2] ;
36315
36316 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36318 if (!SWIG_IsOK(res1)) {
36319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36320 }
36321 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36322 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36323 if (!SWIG_IsOK(ecode2)) {
36324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36325 }
36326 arg2 = static_cast< int >(val2);
36327 if (arg1) (arg1)->h = arg2;
36328
36329 resultobj = SWIG_Py_Void();
36330 return resultobj;
36331 fail:
36332 return NULL;
36333 }
36334
36335
36336 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36337 PyObject *resultobj = 0;
36338 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36339 int result;
36340 void *argp1 = 0 ;
36341 int res1 = 0 ;
36342 PyObject *swig_obj[1] ;
36343
36344 if (!args) SWIG_fail;
36345 swig_obj[0] = args;
36346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36347 if (!SWIG_IsOK(res1)) {
36348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36349 }
36350 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36351 result = (int) ((arg1)->h);
36352 resultobj = SWIG_From_int(static_cast< int >(result));
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36360 PyObject *resultobj = 0;
36361 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36362 int arg2 ;
36363 void *argp1 = 0 ;
36364 int res1 = 0 ;
36365 int val2 ;
36366 int ecode2 = 0 ;
36367 PyObject *swig_obj[2] ;
36368
36369 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36371 if (!SWIG_IsOK(res1)) {
36372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36373 }
36374 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36375 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36376 if (!SWIG_IsOK(ecode2)) {
36377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36378 }
36379 arg2 = static_cast< int >(val2);
36380 if (arg1) (arg1)->bpp = arg2;
36381
36382 resultobj = SWIG_Py_Void();
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36390 PyObject *resultobj = 0;
36391 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36392 int result;
36393 void *argp1 = 0 ;
36394 int res1 = 0 ;
36395 PyObject *swig_obj[1] ;
36396
36397 if (!args) SWIG_fail;
36398 swig_obj[0] = args;
36399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36400 if (!SWIG_IsOK(res1)) {
36401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36402 }
36403 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36404 result = (int) ((arg1)->bpp);
36405 resultobj = SWIG_From_int(static_cast< int >(result));
36406 return resultobj;
36407 fail:
36408 return NULL;
36409 }
36410
36411
36412 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36413 PyObject *resultobj = 0;
36414 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36415 int arg2 ;
36416 void *argp1 = 0 ;
36417 int res1 = 0 ;
36418 int val2 ;
36419 int ecode2 = 0 ;
36420 PyObject *swig_obj[2] ;
36421
36422 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36424 if (!SWIG_IsOK(res1)) {
36425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36426 }
36427 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36428 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36429 if (!SWIG_IsOK(ecode2)) {
36430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36431 }
36432 arg2 = static_cast< int >(val2);
36433 if (arg1) (arg1)->refresh = arg2;
36434
36435 resultobj = SWIG_Py_Void();
36436 return resultobj;
36437 fail:
36438 return NULL;
36439 }
36440
36441
36442 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36443 PyObject *resultobj = 0;
36444 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36445 int result;
36446 void *argp1 = 0 ;
36447 int res1 = 0 ;
36448 PyObject *swig_obj[1] ;
36449
36450 if (!args) SWIG_fail;
36451 swig_obj[0] = args;
36452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36453 if (!SWIG_IsOK(res1)) {
36454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36455 }
36456 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36457 result = (int) ((arg1)->refresh);
36458 resultobj = SWIG_From_int(static_cast< int >(result));
36459 return resultobj;
36460 fail:
36461 return NULL;
36462 }
36463
36464
36465 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36466 PyObject *obj;
36467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36468 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36469 return SWIG_Py_Void();
36470 }
36471
36472 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36473 return SWIG_Python_InitShadowInstance(args);
36474 }
36475
36476 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36477 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36478 return 1;
36479 }
36480
36481
36482 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36483 PyObject *pyobj = 0;
36484
36485 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36486 return pyobj;
36487 }
36488
36489
36490 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36491 PyObject *resultobj = 0;
36492 unsigned int arg1 = (unsigned int) 0 ;
36493 wxDisplay *result = 0 ;
36494 unsigned int val1 ;
36495 int ecode1 = 0 ;
36496 PyObject * obj0 = 0 ;
36497 char * kwnames[] = {
36498 (char *) "index", NULL
36499 };
36500
36501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36502 if (obj0) {
36503 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36504 if (!SWIG_IsOK(ecode1)) {
36505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36506 }
36507 arg1 = static_cast< unsigned int >(val1);
36508 }
36509 {
36510 PyThreadState* __tstate = wxPyBeginAllowThreads();
36511 result = (wxDisplay *)new wxDisplay(arg1);
36512 wxPyEndAllowThreads(__tstate);
36513 if (PyErr_Occurred()) SWIG_fail;
36514 }
36515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36516 return resultobj;
36517 fail:
36518 return NULL;
36519 }
36520
36521
36522 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36523 PyObject *resultobj = 0;
36524 wxDisplay *arg1 = (wxDisplay *) 0 ;
36525 void *argp1 = 0 ;
36526 int res1 = 0 ;
36527 PyObject *swig_obj[1] ;
36528
36529 if (!args) SWIG_fail;
36530 swig_obj[0] = args;
36531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36532 if (!SWIG_IsOK(res1)) {
36533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36534 }
36535 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 delete arg1;
36539
36540 wxPyEndAllowThreads(__tstate);
36541 if (PyErr_Occurred()) SWIG_fail;
36542 }
36543 resultobj = SWIG_Py_Void();
36544 return resultobj;
36545 fail:
36546 return NULL;
36547 }
36548
36549
36550 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36551 PyObject *resultobj = 0;
36552 unsigned int result;
36553
36554 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36555 {
36556 PyThreadState* __tstate = wxPyBeginAllowThreads();
36557 result = (unsigned int)wxDisplay::GetCount();
36558 wxPyEndAllowThreads(__tstate);
36559 if (PyErr_Occurred()) SWIG_fail;
36560 }
36561 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36562 return resultobj;
36563 fail:
36564 return NULL;
36565 }
36566
36567
36568 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36569 PyObject *resultobj = 0;
36570 wxPoint *arg1 = 0 ;
36571 int result;
36572 wxPoint temp1 ;
36573 PyObject * obj0 = 0 ;
36574 char * kwnames[] = {
36575 (char *) "pt", NULL
36576 };
36577
36578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36579 {
36580 arg1 = &temp1;
36581 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36582 }
36583 {
36584 PyThreadState* __tstate = wxPyBeginAllowThreads();
36585 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36586 wxPyEndAllowThreads(__tstate);
36587 if (PyErr_Occurred()) SWIG_fail;
36588 }
36589 resultobj = SWIG_From_int(static_cast< int >(result));
36590 return resultobj;
36591 fail:
36592 return NULL;
36593 }
36594
36595
36596 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36597 PyObject *resultobj = 0;
36598 wxWindow *arg1 = (wxWindow *) 0 ;
36599 int result;
36600 void *argp1 = 0 ;
36601 int res1 = 0 ;
36602 PyObject * obj0 = 0 ;
36603 char * kwnames[] = {
36604 (char *) "window", NULL
36605 };
36606
36607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36609 if (!SWIG_IsOK(res1)) {
36610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36611 }
36612 arg1 = reinterpret_cast< wxWindow * >(argp1);
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 result = (int)wxDisplay::GetFromWindow(arg1);
36616 wxPyEndAllowThreads(__tstate);
36617 if (PyErr_Occurred()) SWIG_fail;
36618 }
36619 resultobj = SWIG_From_int(static_cast< int >(result));
36620 return resultobj;
36621 fail:
36622 return NULL;
36623 }
36624
36625
36626 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36627 PyObject *resultobj = 0;
36628 wxDisplay *arg1 = (wxDisplay *) 0 ;
36629 bool result;
36630 void *argp1 = 0 ;
36631 int res1 = 0 ;
36632 PyObject *swig_obj[1] ;
36633
36634 if (!args) SWIG_fail;
36635 swig_obj[0] = args;
36636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36637 if (!SWIG_IsOK(res1)) {
36638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36639 }
36640 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36641 {
36642 PyThreadState* __tstate = wxPyBeginAllowThreads();
36643 result = (bool)((wxDisplay const *)arg1)->IsOk();
36644 wxPyEndAllowThreads(__tstate);
36645 if (PyErr_Occurred()) SWIG_fail;
36646 }
36647 {
36648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36649 }
36650 return resultobj;
36651 fail:
36652 return NULL;
36653 }
36654
36655
36656 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36657 PyObject *resultobj = 0;
36658 wxDisplay *arg1 = (wxDisplay *) 0 ;
36659 wxRect result;
36660 void *argp1 = 0 ;
36661 int res1 = 0 ;
36662 PyObject *swig_obj[1] ;
36663
36664 if (!args) SWIG_fail;
36665 swig_obj[0] = args;
36666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36669 }
36670 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36671 {
36672 PyThreadState* __tstate = wxPyBeginAllowThreads();
36673 result = ((wxDisplay const *)arg1)->GetGeometry();
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36685 PyObject *resultobj = 0;
36686 wxDisplay *arg1 = (wxDisplay *) 0 ;
36687 wxRect result;
36688 void *argp1 = 0 ;
36689 int res1 = 0 ;
36690 PyObject *swig_obj[1] ;
36691
36692 if (!args) SWIG_fail;
36693 swig_obj[0] = args;
36694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36695 if (!SWIG_IsOK(res1)) {
36696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36697 }
36698 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36699 {
36700 PyThreadState* __tstate = wxPyBeginAllowThreads();
36701 result = ((wxDisplay const *)arg1)->GetClientArea();
36702 wxPyEndAllowThreads(__tstate);
36703 if (PyErr_Occurred()) SWIG_fail;
36704 }
36705 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36713 PyObject *resultobj = 0;
36714 wxDisplay *arg1 = (wxDisplay *) 0 ;
36715 wxString result;
36716 void *argp1 = 0 ;
36717 int res1 = 0 ;
36718 PyObject *swig_obj[1] ;
36719
36720 if (!args) SWIG_fail;
36721 swig_obj[0] = args;
36722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36725 }
36726 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36727 {
36728 PyThreadState* __tstate = wxPyBeginAllowThreads();
36729 result = ((wxDisplay const *)arg1)->GetName();
36730 wxPyEndAllowThreads(__tstate);
36731 if (PyErr_Occurred()) SWIG_fail;
36732 }
36733 {
36734 #if wxUSE_UNICODE
36735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36736 #else
36737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36738 #endif
36739 }
36740 return resultobj;
36741 fail:
36742 return NULL;
36743 }
36744
36745
36746 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36747 PyObject *resultobj = 0;
36748 wxDisplay *arg1 = (wxDisplay *) 0 ;
36749 bool result;
36750 void *argp1 = 0 ;
36751 int res1 = 0 ;
36752 PyObject *swig_obj[1] ;
36753
36754 if (!args) SWIG_fail;
36755 swig_obj[0] = args;
36756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36757 if (!SWIG_IsOK(res1)) {
36758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36759 }
36760 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36761 {
36762 PyThreadState* __tstate = wxPyBeginAllowThreads();
36763 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36764 wxPyEndAllowThreads(__tstate);
36765 if (PyErr_Occurred()) SWIG_fail;
36766 }
36767 {
36768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36769 }
36770 return resultobj;
36771 fail:
36772 return NULL;
36773 }
36774
36775
36776 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36777 PyObject *resultobj = 0;
36778 wxDisplay *arg1 = (wxDisplay *) 0 ;
36779 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36780 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36781 PyObject *result = 0 ;
36782 void *argp1 = 0 ;
36783 int res1 = 0 ;
36784 void *argp2 = 0 ;
36785 int res2 = 0 ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char * kwnames[] = {
36789 (char *) "self",(char *) "mode", NULL
36790 };
36791
36792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36796 }
36797 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36798 if (obj1) {
36799 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36800 if (!SWIG_IsOK(res2)) {
36801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36802 }
36803 if (!argp2) {
36804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36805 }
36806 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36807 }
36808 {
36809 PyThreadState* __tstate = wxPyBeginAllowThreads();
36810 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36811 wxPyEndAllowThreads(__tstate);
36812 if (PyErr_Occurred()) SWIG_fail;
36813 }
36814 resultobj = result;
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36822 PyObject *resultobj = 0;
36823 wxDisplay *arg1 = (wxDisplay *) 0 ;
36824 wxVideoMode result;
36825 void *argp1 = 0 ;
36826 int res1 = 0 ;
36827 PyObject *swig_obj[1] ;
36828
36829 if (!args) SWIG_fail;
36830 swig_obj[0] = args;
36831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36832 if (!SWIG_IsOK(res1)) {
36833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36834 }
36835 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36839 wxPyEndAllowThreads(__tstate);
36840 if (PyErr_Occurred()) SWIG_fail;
36841 }
36842 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36843 return resultobj;
36844 fail:
36845 return NULL;
36846 }
36847
36848
36849 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36850 PyObject *resultobj = 0;
36851 wxDisplay *arg1 = (wxDisplay *) 0 ;
36852 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36853 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36854 bool result;
36855 void *argp1 = 0 ;
36856 int res1 = 0 ;
36857 void *argp2 = 0 ;
36858 int res2 = 0 ;
36859 PyObject * obj0 = 0 ;
36860 PyObject * obj1 = 0 ;
36861 char * kwnames[] = {
36862 (char *) "self",(char *) "mode", NULL
36863 };
36864
36865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36869 }
36870 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36871 if (obj1) {
36872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36873 if (!SWIG_IsOK(res2)) {
36874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36875 }
36876 if (!argp2) {
36877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36878 }
36879 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36880 }
36881 {
36882 PyThreadState* __tstate = wxPyBeginAllowThreads();
36883 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36884 wxPyEndAllowThreads(__tstate);
36885 if (PyErr_Occurred()) SWIG_fail;
36886 }
36887 {
36888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36889 }
36890 return resultobj;
36891 fail:
36892 return NULL;
36893 }
36894
36895
36896 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36897 PyObject *resultobj = 0;
36898 wxDisplay *arg1 = (wxDisplay *) 0 ;
36899 void *argp1 = 0 ;
36900 int res1 = 0 ;
36901 PyObject *swig_obj[1] ;
36902
36903 if (!args) SWIG_fail;
36904 swig_obj[0] = args;
36905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36906 if (!SWIG_IsOK(res1)) {
36907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36908 }
36909 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 wxDisplay_ResetMode(arg1);
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 resultobj = SWIG_Py_Void();
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36924 PyObject *obj;
36925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36926 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36927 return SWIG_Py_Void();
36928 }
36929
36930 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36931 return SWIG_Python_InitShadowInstance(args);
36932 }
36933
36934 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36935 PyObject *resultobj = 0;
36936 wxStandardPaths *result = 0 ;
36937
36938 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 result = (wxStandardPaths *)wxStandardPaths_Get();
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36946 return resultobj;
36947 fail:
36948 return NULL;
36949 }
36950
36951
36952 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36953 PyObject *resultobj = 0;
36954 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36955 wxString result;
36956 void *argp1 = 0 ;
36957 int res1 = 0 ;
36958 PyObject *swig_obj[1] ;
36959
36960 if (!args) SWIG_fail;
36961 swig_obj[0] = args;
36962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36963 if (!SWIG_IsOK(res1)) {
36964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36965 }
36966 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36970 wxPyEndAllowThreads(__tstate);
36971 if (PyErr_Occurred()) SWIG_fail;
36972 }
36973 {
36974 #if wxUSE_UNICODE
36975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36976 #else
36977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36978 #endif
36979 }
36980 return resultobj;
36981 fail:
36982 return NULL;
36983 }
36984
36985
36986 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36987 PyObject *resultobj = 0;
36988 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36989 wxString result;
36990 void *argp1 = 0 ;
36991 int res1 = 0 ;
36992 PyObject *swig_obj[1] ;
36993
36994 if (!args) SWIG_fail;
36995 swig_obj[0] = args;
36996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36997 if (!SWIG_IsOK(res1)) {
36998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36999 }
37000 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37001 {
37002 PyThreadState* __tstate = wxPyBeginAllowThreads();
37003 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
37004 wxPyEndAllowThreads(__tstate);
37005 if (PyErr_Occurred()) SWIG_fail;
37006 }
37007 {
37008 #if wxUSE_UNICODE
37009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37010 #else
37011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37012 #endif
37013 }
37014 return resultobj;
37015 fail:
37016 return NULL;
37017 }
37018
37019
37020 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37021 PyObject *resultobj = 0;
37022 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37023 wxString result;
37024 void *argp1 = 0 ;
37025 int res1 = 0 ;
37026 PyObject *swig_obj[1] ;
37027
37028 if (!args) SWIG_fail;
37029 swig_obj[0] = args;
37030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37031 if (!SWIG_IsOK(res1)) {
37032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37033 }
37034 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
37038 wxPyEndAllowThreads(__tstate);
37039 if (PyErr_Occurred()) SWIG_fail;
37040 }
37041 {
37042 #if wxUSE_UNICODE
37043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37044 #else
37045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37046 #endif
37047 }
37048 return resultobj;
37049 fail:
37050 return NULL;
37051 }
37052
37053
37054 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37055 PyObject *resultobj = 0;
37056 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37057 wxString result;
37058 void *argp1 = 0 ;
37059 int res1 = 0 ;
37060 PyObject *swig_obj[1] ;
37061
37062 if (!args) SWIG_fail;
37063 swig_obj[0] = args;
37064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37065 if (!SWIG_IsOK(res1)) {
37066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37067 }
37068 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37069 {
37070 PyThreadState* __tstate = wxPyBeginAllowThreads();
37071 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37072 wxPyEndAllowThreads(__tstate);
37073 if (PyErr_Occurred()) SWIG_fail;
37074 }
37075 {
37076 #if wxUSE_UNICODE
37077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37078 #else
37079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37080 #endif
37081 }
37082 return resultobj;
37083 fail:
37084 return NULL;
37085 }
37086
37087
37088 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37089 PyObject *resultobj = 0;
37090 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37091 wxString result;
37092 void *argp1 = 0 ;
37093 int res1 = 0 ;
37094 PyObject *swig_obj[1] ;
37095
37096 if (!args) SWIG_fail;
37097 swig_obj[0] = args;
37098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37099 if (!SWIG_IsOK(res1)) {
37100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37101 }
37102 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37103 {
37104 PyThreadState* __tstate = wxPyBeginAllowThreads();
37105 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37106 wxPyEndAllowThreads(__tstate);
37107 if (PyErr_Occurred()) SWIG_fail;
37108 }
37109 {
37110 #if wxUSE_UNICODE
37111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37112 #else
37113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37114 #endif
37115 }
37116 return resultobj;
37117 fail:
37118 return NULL;
37119 }
37120
37121
37122 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37123 PyObject *resultobj = 0;
37124 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37125 wxString result;
37126 void *argp1 = 0 ;
37127 int res1 = 0 ;
37128 PyObject *swig_obj[1] ;
37129
37130 if (!args) SWIG_fail;
37131 swig_obj[0] = args;
37132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37133 if (!SWIG_IsOK(res1)) {
37134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37135 }
37136 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37137 {
37138 PyThreadState* __tstate = wxPyBeginAllowThreads();
37139 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 {
37144 #if wxUSE_UNICODE
37145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37146 #else
37147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37148 #endif
37149 }
37150 return resultobj;
37151 fail:
37152 return NULL;
37153 }
37154
37155
37156 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37157 PyObject *resultobj = 0;
37158 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37159 wxString result;
37160 void *argp1 = 0 ;
37161 int res1 = 0 ;
37162 PyObject *swig_obj[1] ;
37163
37164 if (!args) SWIG_fail;
37165 swig_obj[0] = args;
37166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37167 if (!SWIG_IsOK(res1)) {
37168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37169 }
37170 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37171 {
37172 PyThreadState* __tstate = wxPyBeginAllowThreads();
37173 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37174 wxPyEndAllowThreads(__tstate);
37175 if (PyErr_Occurred()) SWIG_fail;
37176 }
37177 {
37178 #if wxUSE_UNICODE
37179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37180 #else
37181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37182 #endif
37183 }
37184 return resultobj;
37185 fail:
37186 return NULL;
37187 }
37188
37189
37190 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37191 PyObject *resultobj = 0;
37192 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37193 wxString result;
37194 void *argp1 = 0 ;
37195 int res1 = 0 ;
37196 PyObject *swig_obj[1] ;
37197
37198 if (!args) SWIG_fail;
37199 swig_obj[0] = args;
37200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37201 if (!SWIG_IsOK(res1)) {
37202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37203 }
37204 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37205 {
37206 PyThreadState* __tstate = wxPyBeginAllowThreads();
37207 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37208 wxPyEndAllowThreads(__tstate);
37209 if (PyErr_Occurred()) SWIG_fail;
37210 }
37211 {
37212 #if wxUSE_UNICODE
37213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37214 #else
37215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37216 #endif
37217 }
37218 return resultobj;
37219 fail:
37220 return NULL;
37221 }
37222
37223
37224 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37225 PyObject *resultobj = 0;
37226 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37227 wxString result;
37228 void *argp1 = 0 ;
37229 int res1 = 0 ;
37230 PyObject *swig_obj[1] ;
37231
37232 if (!args) SWIG_fail;
37233 swig_obj[0] = args;
37234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37235 if (!SWIG_IsOK(res1)) {
37236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37237 }
37238 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37239 {
37240 PyThreadState* __tstate = wxPyBeginAllowThreads();
37241 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 {
37246 #if wxUSE_UNICODE
37247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37248 #else
37249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37250 #endif
37251 }
37252 return resultobj;
37253 fail:
37254 return NULL;
37255 }
37256
37257
37258 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37259 PyObject *resultobj = 0;
37260 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37261 wxString *arg2 = 0 ;
37262 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37263 wxString result;
37264 void *argp1 = 0 ;
37265 int res1 = 0 ;
37266 bool temp2 = false ;
37267 int val3 ;
37268 int ecode3 = 0 ;
37269 PyObject * obj0 = 0 ;
37270 PyObject * obj1 = 0 ;
37271 PyObject * obj2 = 0 ;
37272 char * kwnames[] = {
37273 (char *) "self",(char *) "lang",(char *) "category", NULL
37274 };
37275
37276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37278 if (!SWIG_IsOK(res1)) {
37279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37280 }
37281 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37282 {
37283 arg2 = wxString_in_helper(obj1);
37284 if (arg2 == NULL) SWIG_fail;
37285 temp2 = true;
37286 }
37287 if (obj2) {
37288 ecode3 = SWIG_AsVal_int(obj2, &val3);
37289 if (!SWIG_IsOK(ecode3)) {
37290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37291 }
37292 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37293 }
37294 {
37295 PyThreadState* __tstate = wxPyBeginAllowThreads();
37296 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37297 wxPyEndAllowThreads(__tstate);
37298 if (PyErr_Occurred()) SWIG_fail;
37299 }
37300 {
37301 #if wxUSE_UNICODE
37302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37303 #else
37304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37305 #endif
37306 }
37307 {
37308 if (temp2)
37309 delete arg2;
37310 }
37311 return resultobj;
37312 fail:
37313 {
37314 if (temp2)
37315 delete arg2;
37316 }
37317 return NULL;
37318 }
37319
37320
37321 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37322 PyObject *resultobj = 0;
37323 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37324 wxString result;
37325 void *argp1 = 0 ;
37326 int res1 = 0 ;
37327 PyObject *swig_obj[1] ;
37328
37329 if (!args) SWIG_fail;
37330 swig_obj[0] = args;
37331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37332 if (!SWIG_IsOK(res1)) {
37333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37334 }
37335 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37336 {
37337 PyThreadState* __tstate = wxPyBeginAllowThreads();
37338 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37339 wxPyEndAllowThreads(__tstate);
37340 if (PyErr_Occurred()) SWIG_fail;
37341 }
37342 {
37343 #if wxUSE_UNICODE
37344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37345 #else
37346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37347 #endif
37348 }
37349 return resultobj;
37350 fail:
37351 return NULL;
37352 }
37353
37354
37355 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37356 PyObject *resultobj = 0;
37357 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37358 wxString result;
37359 void *argp1 = 0 ;
37360 int res1 = 0 ;
37361 PyObject *swig_obj[1] ;
37362
37363 if (!args) SWIG_fail;
37364 swig_obj[0] = args;
37365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37366 if (!SWIG_IsOK(res1)) {
37367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37368 }
37369 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37370 {
37371 PyThreadState* __tstate = wxPyBeginAllowThreads();
37372 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37373 wxPyEndAllowThreads(__tstate);
37374 if (PyErr_Occurred()) SWIG_fail;
37375 }
37376 {
37377 #if wxUSE_UNICODE
37378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37379 #else
37380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37381 #endif
37382 }
37383 return resultobj;
37384 fail:
37385 return NULL;
37386 }
37387
37388
37389 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37390 PyObject *resultobj = 0;
37391 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37392 wxString *arg2 = 0 ;
37393 void *argp1 = 0 ;
37394 int res1 = 0 ;
37395 bool temp2 = false ;
37396 PyObject * obj0 = 0 ;
37397 PyObject * obj1 = 0 ;
37398 char * kwnames[] = {
37399 (char *) "self",(char *) "prefix", NULL
37400 };
37401
37402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37404 if (!SWIG_IsOK(res1)) {
37405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37406 }
37407 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37408 {
37409 arg2 = wxString_in_helper(obj1);
37410 if (arg2 == NULL) SWIG_fail;
37411 temp2 = true;
37412 }
37413 {
37414 PyThreadState* __tstate = wxPyBeginAllowThreads();
37415 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37416 wxPyEndAllowThreads(__tstate);
37417 if (PyErr_Occurred()) SWIG_fail;
37418 }
37419 resultobj = SWIG_Py_Void();
37420 {
37421 if (temp2)
37422 delete arg2;
37423 }
37424 return resultobj;
37425 fail:
37426 {
37427 if (temp2)
37428 delete arg2;
37429 }
37430 return NULL;
37431 }
37432
37433
37434 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37435 PyObject *resultobj = 0;
37436 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37437 wxString result;
37438 void *argp1 = 0 ;
37439 int res1 = 0 ;
37440 PyObject *swig_obj[1] ;
37441
37442 if (!args) SWIG_fail;
37443 swig_obj[0] = args;
37444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37445 if (!SWIG_IsOK(res1)) {
37446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37447 }
37448 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37449 {
37450 PyThreadState* __tstate = wxPyBeginAllowThreads();
37451 result = wxStandardPaths_GetInstallPrefix(arg1);
37452 wxPyEndAllowThreads(__tstate);
37453 if (PyErr_Occurred()) SWIG_fail;
37454 }
37455 {
37456 #if wxUSE_UNICODE
37457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37458 #else
37459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37460 #endif
37461 }
37462 return resultobj;
37463 fail:
37464 return NULL;
37465 }
37466
37467
37468 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37469 PyObject *obj;
37470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37471 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37472 return SWIG_Py_Void();
37473 }
37474
37475 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37476 PyObject *resultobj = 0;
37477 wxEventType arg1 ;
37478 wxPowerEvent *result = 0 ;
37479 int val1 ;
37480 int ecode1 = 0 ;
37481 PyObject * obj0 = 0 ;
37482 char * kwnames[] = {
37483 (char *) "evtType", NULL
37484 };
37485
37486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37487 ecode1 = SWIG_AsVal_int(obj0, &val1);
37488 if (!SWIG_IsOK(ecode1)) {
37489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37490 }
37491 arg1 = static_cast< wxEventType >(val1);
37492 {
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37506 PyObject *resultobj = 0;
37507 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37508 void *argp1 = 0 ;
37509 int res1 = 0 ;
37510 PyObject *swig_obj[1] ;
37511
37512 if (!args) SWIG_fail;
37513 swig_obj[0] = args;
37514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37515 if (!SWIG_IsOK(res1)) {
37516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37517 }
37518 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 (arg1)->Veto();
37522 wxPyEndAllowThreads(__tstate);
37523 if (PyErr_Occurred()) SWIG_fail;
37524 }
37525 resultobj = SWIG_Py_Void();
37526 return resultobj;
37527 fail:
37528 return NULL;
37529 }
37530
37531
37532 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37533 PyObject *resultobj = 0;
37534 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37535 bool result;
37536 void *argp1 = 0 ;
37537 int res1 = 0 ;
37538 PyObject *swig_obj[1] ;
37539
37540 if (!args) SWIG_fail;
37541 swig_obj[0] = args;
37542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37543 if (!SWIG_IsOK(res1)) {
37544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37545 }
37546 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37547 {
37548 PyThreadState* __tstate = wxPyBeginAllowThreads();
37549 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37550 wxPyEndAllowThreads(__tstate);
37551 if (PyErr_Occurred()) SWIG_fail;
37552 }
37553 {
37554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37555 }
37556 return resultobj;
37557 fail:
37558 return NULL;
37559 }
37560
37561
37562 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37563 PyObject *obj;
37564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37565 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37566 return SWIG_Py_Void();
37567 }
37568
37569 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37570 return SWIG_Python_InitShadowInstance(args);
37571 }
37572
37573 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37574 PyObject *resultobj = 0;
37575 wxPowerType result;
37576
37577 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37578 {
37579 PyThreadState* __tstate = wxPyBeginAllowThreads();
37580 result = (wxPowerType)wxGetPowerType();
37581 wxPyEndAllowThreads(__tstate);
37582 if (PyErr_Occurred()) SWIG_fail;
37583 }
37584 resultobj = SWIG_From_int(static_cast< int >(result));
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37592 PyObject *resultobj = 0;
37593 wxBatteryState result;
37594
37595 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37596 {
37597 PyThreadState* __tstate = wxPyBeginAllowThreads();
37598 result = (wxBatteryState)wxGetBatteryState();
37599 wxPyEndAllowThreads(__tstate);
37600 if (PyErr_Occurred()) SWIG_fail;
37601 }
37602 resultobj = SWIG_From_int(static_cast< int >(result));
37603 return resultobj;
37604 fail:
37605 return NULL;
37606 }
37607
37608
37609 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37610 PyObject *resultobj = 0;
37611 wxAboutDialogInfo *result = 0 ;
37612
37613 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37621 return resultobj;
37622 fail:
37623 return NULL;
37624 }
37625
37626
37627 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37628 PyObject *resultobj = 0;
37629 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37630 void *argp1 = 0 ;
37631 int res1 = 0 ;
37632 PyObject *swig_obj[1] ;
37633
37634 if (!args) SWIG_fail;
37635 swig_obj[0] = args;
37636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37637 if (!SWIG_IsOK(res1)) {
37638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37639 }
37640 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37641 {
37642 PyThreadState* __tstate = wxPyBeginAllowThreads();
37643 delete arg1;
37644
37645 wxPyEndAllowThreads(__tstate);
37646 if (PyErr_Occurred()) SWIG_fail;
37647 }
37648 resultobj = SWIG_Py_Void();
37649 return resultobj;
37650 fail:
37651 return NULL;
37652 }
37653
37654
37655 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37656 PyObject *resultobj = 0;
37657 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37658 wxString *arg2 = 0 ;
37659 void *argp1 = 0 ;
37660 int res1 = 0 ;
37661 bool temp2 = false ;
37662 PyObject * obj0 = 0 ;
37663 PyObject * obj1 = 0 ;
37664 char * kwnames[] = {
37665 (char *) "self",(char *) "name", NULL
37666 };
37667
37668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37670 if (!SWIG_IsOK(res1)) {
37671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37672 }
37673 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37674 {
37675 arg2 = wxString_in_helper(obj1);
37676 if (arg2 == NULL) SWIG_fail;
37677 temp2 = true;
37678 }
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 (arg1)->SetName((wxString const &)*arg2);
37682 wxPyEndAllowThreads(__tstate);
37683 if (PyErr_Occurred()) SWIG_fail;
37684 }
37685 resultobj = SWIG_Py_Void();
37686 {
37687 if (temp2)
37688 delete arg2;
37689 }
37690 return resultobj;
37691 fail:
37692 {
37693 if (temp2)
37694 delete arg2;
37695 }
37696 return NULL;
37697 }
37698
37699
37700 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37701 PyObject *resultobj = 0;
37702 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37703 wxString result;
37704 void *argp1 = 0 ;
37705 int res1 = 0 ;
37706 PyObject *swig_obj[1] ;
37707
37708 if (!args) SWIG_fail;
37709 swig_obj[0] = args;
37710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37711 if (!SWIG_IsOK(res1)) {
37712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37713 }
37714 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37715 {
37716 PyThreadState* __tstate = wxPyBeginAllowThreads();
37717 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37718 wxPyEndAllowThreads(__tstate);
37719 if (PyErr_Occurred()) SWIG_fail;
37720 }
37721 {
37722 #if wxUSE_UNICODE
37723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37724 #else
37725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37726 #endif
37727 }
37728 return resultobj;
37729 fail:
37730 return NULL;
37731 }
37732
37733
37734 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37735 PyObject *resultobj = 0;
37736 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37737 wxString *arg2 = 0 ;
37738 void *argp1 = 0 ;
37739 int res1 = 0 ;
37740 bool temp2 = false ;
37741 PyObject * obj0 = 0 ;
37742 PyObject * obj1 = 0 ;
37743 char * kwnames[] = {
37744 (char *) "self",(char *) "version", NULL
37745 };
37746
37747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37749 if (!SWIG_IsOK(res1)) {
37750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37751 }
37752 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37753 {
37754 arg2 = wxString_in_helper(obj1);
37755 if (arg2 == NULL) SWIG_fail;
37756 temp2 = true;
37757 }
37758 {
37759 PyThreadState* __tstate = wxPyBeginAllowThreads();
37760 (arg1)->SetVersion((wxString const &)*arg2);
37761 wxPyEndAllowThreads(__tstate);
37762 if (PyErr_Occurred()) SWIG_fail;
37763 }
37764 resultobj = SWIG_Py_Void();
37765 {
37766 if (temp2)
37767 delete arg2;
37768 }
37769 return resultobj;
37770 fail:
37771 {
37772 if (temp2)
37773 delete arg2;
37774 }
37775 return NULL;
37776 }
37777
37778
37779 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37780 PyObject *resultobj = 0;
37781 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37782 bool result;
37783 void *argp1 = 0 ;
37784 int res1 = 0 ;
37785 PyObject *swig_obj[1] ;
37786
37787 if (!args) SWIG_fail;
37788 swig_obj[0] = args;
37789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37790 if (!SWIG_IsOK(res1)) {
37791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37792 }
37793 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37794 {
37795 PyThreadState* __tstate = wxPyBeginAllowThreads();
37796 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37797 wxPyEndAllowThreads(__tstate);
37798 if (PyErr_Occurred()) SWIG_fail;
37799 }
37800 {
37801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37802 }
37803 return resultobj;
37804 fail:
37805 return NULL;
37806 }
37807
37808
37809 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37810 PyObject *resultobj = 0;
37811 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37812 wxString result;
37813 void *argp1 = 0 ;
37814 int res1 = 0 ;
37815 PyObject *swig_obj[1] ;
37816
37817 if (!args) SWIG_fail;
37818 swig_obj[0] = args;
37819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37820 if (!SWIG_IsOK(res1)) {
37821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37822 }
37823 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37824 {
37825 PyThreadState* __tstate = wxPyBeginAllowThreads();
37826 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37827 wxPyEndAllowThreads(__tstate);
37828 if (PyErr_Occurred()) SWIG_fail;
37829 }
37830 {
37831 #if wxUSE_UNICODE
37832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37833 #else
37834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37835 #endif
37836 }
37837 return resultobj;
37838 fail:
37839 return NULL;
37840 }
37841
37842
37843 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37844 PyObject *resultobj = 0;
37845 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37846 wxString *arg2 = 0 ;
37847 void *argp1 = 0 ;
37848 int res1 = 0 ;
37849 bool temp2 = false ;
37850 PyObject * obj0 = 0 ;
37851 PyObject * obj1 = 0 ;
37852 char * kwnames[] = {
37853 (char *) "self",(char *) "desc", NULL
37854 };
37855
37856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37858 if (!SWIG_IsOK(res1)) {
37859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37860 }
37861 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37862 {
37863 arg2 = wxString_in_helper(obj1);
37864 if (arg2 == NULL) SWIG_fail;
37865 temp2 = true;
37866 }
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 (arg1)->SetDescription((wxString const &)*arg2);
37870 wxPyEndAllowThreads(__tstate);
37871 if (PyErr_Occurred()) SWIG_fail;
37872 }
37873 resultobj = SWIG_Py_Void();
37874 {
37875 if (temp2)
37876 delete arg2;
37877 }
37878 return resultobj;
37879 fail:
37880 {
37881 if (temp2)
37882 delete arg2;
37883 }
37884 return NULL;
37885 }
37886
37887
37888 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37889 PyObject *resultobj = 0;
37890 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37891 bool result;
37892 void *argp1 = 0 ;
37893 int res1 = 0 ;
37894 PyObject *swig_obj[1] ;
37895
37896 if (!args) SWIG_fail;
37897 swig_obj[0] = args;
37898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37899 if (!SWIG_IsOK(res1)) {
37900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37901 }
37902 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37903 {
37904 PyThreadState* __tstate = wxPyBeginAllowThreads();
37905 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37906 wxPyEndAllowThreads(__tstate);
37907 if (PyErr_Occurred()) SWIG_fail;
37908 }
37909 {
37910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37911 }
37912 return resultobj;
37913 fail:
37914 return NULL;
37915 }
37916
37917
37918 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37919 PyObject *resultobj = 0;
37920 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37921 wxString result;
37922 void *argp1 = 0 ;
37923 int res1 = 0 ;
37924 PyObject *swig_obj[1] ;
37925
37926 if (!args) SWIG_fail;
37927 swig_obj[0] = args;
37928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37929 if (!SWIG_IsOK(res1)) {
37930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37931 }
37932 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37933 {
37934 PyThreadState* __tstate = wxPyBeginAllowThreads();
37935 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37936 wxPyEndAllowThreads(__tstate);
37937 if (PyErr_Occurred()) SWIG_fail;
37938 }
37939 {
37940 #if wxUSE_UNICODE
37941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37942 #else
37943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37944 #endif
37945 }
37946 return resultobj;
37947 fail:
37948 return NULL;
37949 }
37950
37951
37952 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37953 PyObject *resultobj = 0;
37954 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37955 wxString *arg2 = 0 ;
37956 void *argp1 = 0 ;
37957 int res1 = 0 ;
37958 bool temp2 = false ;
37959 PyObject * obj0 = 0 ;
37960 PyObject * obj1 = 0 ;
37961 char * kwnames[] = {
37962 (char *) "self",(char *) "copyright", NULL
37963 };
37964
37965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37967 if (!SWIG_IsOK(res1)) {
37968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37969 }
37970 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37971 {
37972 arg2 = wxString_in_helper(obj1);
37973 if (arg2 == NULL) SWIG_fail;
37974 temp2 = true;
37975 }
37976 {
37977 PyThreadState* __tstate = wxPyBeginAllowThreads();
37978 (arg1)->SetCopyright((wxString const &)*arg2);
37979 wxPyEndAllowThreads(__tstate);
37980 if (PyErr_Occurred()) SWIG_fail;
37981 }
37982 resultobj = SWIG_Py_Void();
37983 {
37984 if (temp2)
37985 delete arg2;
37986 }
37987 return resultobj;
37988 fail:
37989 {
37990 if (temp2)
37991 delete arg2;
37992 }
37993 return NULL;
37994 }
37995
37996
37997 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37998 PyObject *resultobj = 0;
37999 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38000 bool result;
38001 void *argp1 = 0 ;
38002 int res1 = 0 ;
38003 PyObject *swig_obj[1] ;
38004
38005 if (!args) SWIG_fail;
38006 swig_obj[0] = args;
38007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38008 if (!SWIG_IsOK(res1)) {
38009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38010 }
38011 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38012 {
38013 PyThreadState* __tstate = wxPyBeginAllowThreads();
38014 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
38015 wxPyEndAllowThreads(__tstate);
38016 if (PyErr_Occurred()) SWIG_fail;
38017 }
38018 {
38019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38020 }
38021 return resultobj;
38022 fail:
38023 return NULL;
38024 }
38025
38026
38027 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38028 PyObject *resultobj = 0;
38029 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38030 wxString result;
38031 void *argp1 = 0 ;
38032 int res1 = 0 ;
38033 PyObject *swig_obj[1] ;
38034
38035 if (!args) SWIG_fail;
38036 swig_obj[0] = args;
38037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38038 if (!SWIG_IsOK(res1)) {
38039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38040 }
38041 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38042 {
38043 PyThreadState* __tstate = wxPyBeginAllowThreads();
38044 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
38045 wxPyEndAllowThreads(__tstate);
38046 if (PyErr_Occurred()) SWIG_fail;
38047 }
38048 {
38049 #if wxUSE_UNICODE
38050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38051 #else
38052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38053 #endif
38054 }
38055 return resultobj;
38056 fail:
38057 return NULL;
38058 }
38059
38060
38061 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38062 PyObject *resultobj = 0;
38063 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38064 wxString *arg2 = 0 ;
38065 void *argp1 = 0 ;
38066 int res1 = 0 ;
38067 bool temp2 = false ;
38068 PyObject * obj0 = 0 ;
38069 PyObject * obj1 = 0 ;
38070 char * kwnames[] = {
38071 (char *) "self",(char *) "licence", NULL
38072 };
38073
38074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38076 if (!SWIG_IsOK(res1)) {
38077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38078 }
38079 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38080 {
38081 arg2 = wxString_in_helper(obj1);
38082 if (arg2 == NULL) SWIG_fail;
38083 temp2 = true;
38084 }
38085 {
38086 PyThreadState* __tstate = wxPyBeginAllowThreads();
38087 (arg1)->SetLicence((wxString const &)*arg2);
38088 wxPyEndAllowThreads(__tstate);
38089 if (PyErr_Occurred()) SWIG_fail;
38090 }
38091 resultobj = SWIG_Py_Void();
38092 {
38093 if (temp2)
38094 delete arg2;
38095 }
38096 return resultobj;
38097 fail:
38098 {
38099 if (temp2)
38100 delete arg2;
38101 }
38102 return NULL;
38103 }
38104
38105
38106 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38107 PyObject *resultobj = 0;
38108 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38109 wxString *arg2 = 0 ;
38110 void *argp1 = 0 ;
38111 int res1 = 0 ;
38112 bool temp2 = false ;
38113 PyObject * obj0 = 0 ;
38114 PyObject * obj1 = 0 ;
38115 char * kwnames[] = {
38116 (char *) "self",(char *) "licence", NULL
38117 };
38118
38119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38121 if (!SWIG_IsOK(res1)) {
38122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38123 }
38124 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38125 {
38126 arg2 = wxString_in_helper(obj1);
38127 if (arg2 == NULL) SWIG_fail;
38128 temp2 = true;
38129 }
38130 {
38131 PyThreadState* __tstate = wxPyBeginAllowThreads();
38132 (arg1)->SetLicense((wxString const &)*arg2);
38133 wxPyEndAllowThreads(__tstate);
38134 if (PyErr_Occurred()) SWIG_fail;
38135 }
38136 resultobj = SWIG_Py_Void();
38137 {
38138 if (temp2)
38139 delete arg2;
38140 }
38141 return resultobj;
38142 fail:
38143 {
38144 if (temp2)
38145 delete arg2;
38146 }
38147 return NULL;
38148 }
38149
38150
38151 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38152 PyObject *resultobj = 0;
38153 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38154 bool result;
38155 void *argp1 = 0 ;
38156 int res1 = 0 ;
38157 PyObject *swig_obj[1] ;
38158
38159 if (!args) SWIG_fail;
38160 swig_obj[0] = args;
38161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38162 if (!SWIG_IsOK(res1)) {
38163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38164 }
38165 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38166 {
38167 PyThreadState* __tstate = wxPyBeginAllowThreads();
38168 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38169 wxPyEndAllowThreads(__tstate);
38170 if (PyErr_Occurred()) SWIG_fail;
38171 }
38172 {
38173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38174 }
38175 return resultobj;
38176 fail:
38177 return NULL;
38178 }
38179
38180
38181 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38182 PyObject *resultobj = 0;
38183 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38184 wxString result;
38185 void *argp1 = 0 ;
38186 int res1 = 0 ;
38187 PyObject *swig_obj[1] ;
38188
38189 if (!args) SWIG_fail;
38190 swig_obj[0] = args;
38191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38192 if (!SWIG_IsOK(res1)) {
38193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38194 }
38195 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38196 {
38197 PyThreadState* __tstate = wxPyBeginAllowThreads();
38198 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38199 wxPyEndAllowThreads(__tstate);
38200 if (PyErr_Occurred()) SWIG_fail;
38201 }
38202 {
38203 #if wxUSE_UNICODE
38204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38205 #else
38206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38207 #endif
38208 }
38209 return resultobj;
38210 fail:
38211 return NULL;
38212 }
38213
38214
38215 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj = 0;
38217 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38218 wxIcon *arg2 = 0 ;
38219 void *argp1 = 0 ;
38220 int res1 = 0 ;
38221 void *argp2 = 0 ;
38222 int res2 = 0 ;
38223 PyObject * obj0 = 0 ;
38224 PyObject * obj1 = 0 ;
38225 char * kwnames[] = {
38226 (char *) "self",(char *) "icon", NULL
38227 };
38228
38229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38231 if (!SWIG_IsOK(res1)) {
38232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38233 }
38234 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38236 if (!SWIG_IsOK(res2)) {
38237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38238 }
38239 if (!argp2) {
38240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38241 }
38242 arg2 = reinterpret_cast< wxIcon * >(argp2);
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 (arg1)->SetIcon((wxIcon const &)*arg2);
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 resultobj = SWIG_Py_Void();
38250 return resultobj;
38251 fail:
38252 return NULL;
38253 }
38254
38255
38256 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38257 PyObject *resultobj = 0;
38258 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38259 bool result;
38260 void *argp1 = 0 ;
38261 int res1 = 0 ;
38262 PyObject *swig_obj[1] ;
38263
38264 if (!args) SWIG_fail;
38265 swig_obj[0] = args;
38266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38267 if (!SWIG_IsOK(res1)) {
38268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38269 }
38270 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38271 {
38272 PyThreadState* __tstate = wxPyBeginAllowThreads();
38273 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38274 wxPyEndAllowThreads(__tstate);
38275 if (PyErr_Occurred()) SWIG_fail;
38276 }
38277 {
38278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38279 }
38280 return resultobj;
38281 fail:
38282 return NULL;
38283 }
38284
38285
38286 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38287 PyObject *resultobj = 0;
38288 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38289 wxIcon result;
38290 void *argp1 = 0 ;
38291 int res1 = 0 ;
38292 PyObject *swig_obj[1] ;
38293
38294 if (!args) SWIG_fail;
38295 swig_obj[0] = args;
38296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38297 if (!SWIG_IsOK(res1)) {
38298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38299 }
38300 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38301 {
38302 PyThreadState* __tstate = wxPyBeginAllowThreads();
38303 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38304 wxPyEndAllowThreads(__tstate);
38305 if (PyErr_Occurred()) SWIG_fail;
38306 }
38307 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38308 return resultobj;
38309 fail:
38310 return NULL;
38311 }
38312
38313
38314 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38315 PyObject *resultobj = 0;
38316 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38317 wxString *arg2 = 0 ;
38318 wxString const &arg3_defvalue = wxEmptyString ;
38319 wxString *arg3 = (wxString *) &arg3_defvalue ;
38320 void *argp1 = 0 ;
38321 int res1 = 0 ;
38322 bool temp2 = false ;
38323 bool temp3 = false ;
38324 PyObject * obj0 = 0 ;
38325 PyObject * obj1 = 0 ;
38326 PyObject * obj2 = 0 ;
38327 char * kwnames[] = {
38328 (char *) "self",(char *) "url",(char *) "desc", NULL
38329 };
38330
38331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38333 if (!SWIG_IsOK(res1)) {
38334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38335 }
38336 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38337 {
38338 arg2 = wxString_in_helper(obj1);
38339 if (arg2 == NULL) SWIG_fail;
38340 temp2 = true;
38341 }
38342 if (obj2) {
38343 {
38344 arg3 = wxString_in_helper(obj2);
38345 if (arg3 == NULL) SWIG_fail;
38346 temp3 = true;
38347 }
38348 }
38349 {
38350 PyThreadState* __tstate = wxPyBeginAllowThreads();
38351 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38352 wxPyEndAllowThreads(__tstate);
38353 if (PyErr_Occurred()) SWIG_fail;
38354 }
38355 resultobj = SWIG_Py_Void();
38356 {
38357 if (temp2)
38358 delete arg2;
38359 }
38360 {
38361 if (temp3)
38362 delete arg3;
38363 }
38364 return resultobj;
38365 fail:
38366 {
38367 if (temp2)
38368 delete arg2;
38369 }
38370 {
38371 if (temp3)
38372 delete arg3;
38373 }
38374 return NULL;
38375 }
38376
38377
38378 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38379 PyObject *resultobj = 0;
38380 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38381 wxString result;
38382 void *argp1 = 0 ;
38383 int res1 = 0 ;
38384 PyObject *swig_obj[1] ;
38385
38386 if (!args) SWIG_fail;
38387 swig_obj[0] = args;
38388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38389 if (!SWIG_IsOK(res1)) {
38390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38391 }
38392 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38393 {
38394 PyThreadState* __tstate = wxPyBeginAllowThreads();
38395 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38396 wxPyEndAllowThreads(__tstate);
38397 if (PyErr_Occurred()) SWIG_fail;
38398 }
38399 {
38400 #if wxUSE_UNICODE
38401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38402 #else
38403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38404 #endif
38405 }
38406 return resultobj;
38407 fail:
38408 return NULL;
38409 }
38410
38411
38412 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38413 PyObject *resultobj = 0;
38414 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38415 wxString result;
38416 void *argp1 = 0 ;
38417 int res1 = 0 ;
38418 PyObject *swig_obj[1] ;
38419
38420 if (!args) SWIG_fail;
38421 swig_obj[0] = args;
38422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38423 if (!SWIG_IsOK(res1)) {
38424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38425 }
38426 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38427 {
38428 PyThreadState* __tstate = wxPyBeginAllowThreads();
38429 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38430 wxPyEndAllowThreads(__tstate);
38431 if (PyErr_Occurred()) SWIG_fail;
38432 }
38433 {
38434 #if wxUSE_UNICODE
38435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38436 #else
38437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38438 #endif
38439 }
38440 return resultobj;
38441 fail:
38442 return NULL;
38443 }
38444
38445
38446 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38447 PyObject *resultobj = 0;
38448 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38449 bool result;
38450 void *argp1 = 0 ;
38451 int res1 = 0 ;
38452 PyObject *swig_obj[1] ;
38453
38454 if (!args) SWIG_fail;
38455 swig_obj[0] = args;
38456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38457 if (!SWIG_IsOK(res1)) {
38458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38459 }
38460 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38461 {
38462 PyThreadState* __tstate = wxPyBeginAllowThreads();
38463 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38464 wxPyEndAllowThreads(__tstate);
38465 if (PyErr_Occurred()) SWIG_fail;
38466 }
38467 {
38468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38469 }
38470 return resultobj;
38471 fail:
38472 return NULL;
38473 }
38474
38475
38476 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38477 PyObject *resultobj = 0;
38478 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38479 wxArrayString *arg2 = 0 ;
38480 void *argp1 = 0 ;
38481 int res1 = 0 ;
38482 bool temp2 = false ;
38483 PyObject * obj0 = 0 ;
38484 PyObject * obj1 = 0 ;
38485 char * kwnames[] = {
38486 (char *) "self",(char *) "developers", NULL
38487 };
38488
38489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38491 if (!SWIG_IsOK(res1)) {
38492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38493 }
38494 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38495 {
38496 if (! PySequence_Check(obj1)) {
38497 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38498 SWIG_fail;
38499 }
38500 arg2 = new wxArrayString;
38501 temp2 = true;
38502 int i, len=PySequence_Length(obj1);
38503 for (i=0; i<len; i++) {
38504 PyObject* item = PySequence_GetItem(obj1, i);
38505 wxString* s = wxString_in_helper(item);
38506 if (PyErr_Occurred()) SWIG_fail;
38507 arg2->Add(*s);
38508 delete s;
38509 Py_DECREF(item);
38510 }
38511 }
38512 {
38513 PyThreadState* __tstate = wxPyBeginAllowThreads();
38514 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38515 wxPyEndAllowThreads(__tstate);
38516 if (PyErr_Occurred()) SWIG_fail;
38517 }
38518 resultobj = SWIG_Py_Void();
38519 {
38520 if (temp2) delete arg2;
38521 }
38522 return resultobj;
38523 fail:
38524 {
38525 if (temp2) delete arg2;
38526 }
38527 return NULL;
38528 }
38529
38530
38531 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38532 PyObject *resultobj = 0;
38533 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38534 wxString *arg2 = 0 ;
38535 void *argp1 = 0 ;
38536 int res1 = 0 ;
38537 bool temp2 = false ;
38538 PyObject * obj0 = 0 ;
38539 PyObject * obj1 = 0 ;
38540 char * kwnames[] = {
38541 (char *) "self",(char *) "developer", NULL
38542 };
38543
38544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38546 if (!SWIG_IsOK(res1)) {
38547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38548 }
38549 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38550 {
38551 arg2 = wxString_in_helper(obj1);
38552 if (arg2 == NULL) SWIG_fail;
38553 temp2 = true;
38554 }
38555 {
38556 PyThreadState* __tstate = wxPyBeginAllowThreads();
38557 (arg1)->AddDeveloper((wxString const &)*arg2);
38558 wxPyEndAllowThreads(__tstate);
38559 if (PyErr_Occurred()) SWIG_fail;
38560 }
38561 resultobj = SWIG_Py_Void();
38562 {
38563 if (temp2)
38564 delete arg2;
38565 }
38566 return resultobj;
38567 fail:
38568 {
38569 if (temp2)
38570 delete arg2;
38571 }
38572 return NULL;
38573 }
38574
38575
38576 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38577 PyObject *resultobj = 0;
38578 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38579 bool result;
38580 void *argp1 = 0 ;
38581 int res1 = 0 ;
38582 PyObject *swig_obj[1] ;
38583
38584 if (!args) SWIG_fail;
38585 swig_obj[0] = args;
38586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38587 if (!SWIG_IsOK(res1)) {
38588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38589 }
38590 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38591 {
38592 PyThreadState* __tstate = wxPyBeginAllowThreads();
38593 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38594 wxPyEndAllowThreads(__tstate);
38595 if (PyErr_Occurred()) SWIG_fail;
38596 }
38597 {
38598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38599 }
38600 return resultobj;
38601 fail:
38602 return NULL;
38603 }
38604
38605
38606 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38607 PyObject *resultobj = 0;
38608 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38609 wxArrayString *result = 0 ;
38610 void *argp1 = 0 ;
38611 int res1 = 0 ;
38612 PyObject *swig_obj[1] ;
38613
38614 if (!args) SWIG_fail;
38615 swig_obj[0] = args;
38616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38617 if (!SWIG_IsOK(res1)) {
38618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38619 }
38620 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38621 {
38622 PyThreadState* __tstate = wxPyBeginAllowThreads();
38623 {
38624 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38625 result = (wxArrayString *) &_result_ref;
38626 }
38627 wxPyEndAllowThreads(__tstate);
38628 if (PyErr_Occurred()) SWIG_fail;
38629 }
38630 {
38631 resultobj = wxArrayString2PyList_helper(*result);
38632 }
38633 return resultobj;
38634 fail:
38635 return NULL;
38636 }
38637
38638
38639 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38640 PyObject *resultobj = 0;
38641 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38642 wxArrayString *arg2 = 0 ;
38643 void *argp1 = 0 ;
38644 int res1 = 0 ;
38645 bool temp2 = false ;
38646 PyObject * obj0 = 0 ;
38647 PyObject * obj1 = 0 ;
38648 char * kwnames[] = {
38649 (char *) "self",(char *) "docwriters", NULL
38650 };
38651
38652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38654 if (!SWIG_IsOK(res1)) {
38655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38656 }
38657 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38658 {
38659 if (! PySequence_Check(obj1)) {
38660 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38661 SWIG_fail;
38662 }
38663 arg2 = new wxArrayString;
38664 temp2 = true;
38665 int i, len=PySequence_Length(obj1);
38666 for (i=0; i<len; i++) {
38667 PyObject* item = PySequence_GetItem(obj1, i);
38668 wxString* s = wxString_in_helper(item);
38669 if (PyErr_Occurred()) SWIG_fail;
38670 arg2->Add(*s);
38671 delete s;
38672 Py_DECREF(item);
38673 }
38674 }
38675 {
38676 PyThreadState* __tstate = wxPyBeginAllowThreads();
38677 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38678 wxPyEndAllowThreads(__tstate);
38679 if (PyErr_Occurred()) SWIG_fail;
38680 }
38681 resultobj = SWIG_Py_Void();
38682 {
38683 if (temp2) delete arg2;
38684 }
38685 return resultobj;
38686 fail:
38687 {
38688 if (temp2) delete arg2;
38689 }
38690 return NULL;
38691 }
38692
38693
38694 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38695 PyObject *resultobj = 0;
38696 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38697 wxString *arg2 = 0 ;
38698 void *argp1 = 0 ;
38699 int res1 = 0 ;
38700 bool temp2 = false ;
38701 PyObject * obj0 = 0 ;
38702 PyObject * obj1 = 0 ;
38703 char * kwnames[] = {
38704 (char *) "self",(char *) "docwriter", NULL
38705 };
38706
38707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38709 if (!SWIG_IsOK(res1)) {
38710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38711 }
38712 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38713 {
38714 arg2 = wxString_in_helper(obj1);
38715 if (arg2 == NULL) SWIG_fail;
38716 temp2 = true;
38717 }
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 (arg1)->AddDocWriter((wxString const &)*arg2);
38721 wxPyEndAllowThreads(__tstate);
38722 if (PyErr_Occurred()) SWIG_fail;
38723 }
38724 resultobj = SWIG_Py_Void();
38725 {
38726 if (temp2)
38727 delete arg2;
38728 }
38729 return resultobj;
38730 fail:
38731 {
38732 if (temp2)
38733 delete arg2;
38734 }
38735 return NULL;
38736 }
38737
38738
38739 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38740 PyObject *resultobj = 0;
38741 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38742 bool result;
38743 void *argp1 = 0 ;
38744 int res1 = 0 ;
38745 PyObject *swig_obj[1] ;
38746
38747 if (!args) SWIG_fail;
38748 swig_obj[0] = args;
38749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38750 if (!SWIG_IsOK(res1)) {
38751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38752 }
38753 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38754 {
38755 PyThreadState* __tstate = wxPyBeginAllowThreads();
38756 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38757 wxPyEndAllowThreads(__tstate);
38758 if (PyErr_Occurred()) SWIG_fail;
38759 }
38760 {
38761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38762 }
38763 return resultobj;
38764 fail:
38765 return NULL;
38766 }
38767
38768
38769 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38770 PyObject *resultobj = 0;
38771 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38772 wxArrayString *result = 0 ;
38773 void *argp1 = 0 ;
38774 int res1 = 0 ;
38775 PyObject *swig_obj[1] ;
38776
38777 if (!args) SWIG_fail;
38778 swig_obj[0] = args;
38779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38780 if (!SWIG_IsOK(res1)) {
38781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38782 }
38783 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38784 {
38785 PyThreadState* __tstate = wxPyBeginAllowThreads();
38786 {
38787 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38788 result = (wxArrayString *) &_result_ref;
38789 }
38790 wxPyEndAllowThreads(__tstate);
38791 if (PyErr_Occurred()) SWIG_fail;
38792 }
38793 {
38794 resultobj = wxArrayString2PyList_helper(*result);
38795 }
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38803 PyObject *resultobj = 0;
38804 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38805 wxArrayString *arg2 = 0 ;
38806 void *argp1 = 0 ;
38807 int res1 = 0 ;
38808 bool temp2 = false ;
38809 PyObject * obj0 = 0 ;
38810 PyObject * obj1 = 0 ;
38811 char * kwnames[] = {
38812 (char *) "self",(char *) "artists", NULL
38813 };
38814
38815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38817 if (!SWIG_IsOK(res1)) {
38818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38819 }
38820 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38821 {
38822 if (! PySequence_Check(obj1)) {
38823 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38824 SWIG_fail;
38825 }
38826 arg2 = new wxArrayString;
38827 temp2 = true;
38828 int i, len=PySequence_Length(obj1);
38829 for (i=0; i<len; i++) {
38830 PyObject* item = PySequence_GetItem(obj1, i);
38831 wxString* s = wxString_in_helper(item);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 arg2->Add(*s);
38834 delete s;
38835 Py_DECREF(item);
38836 }
38837 }
38838 {
38839 PyThreadState* __tstate = wxPyBeginAllowThreads();
38840 (arg1)->SetArtists((wxArrayString const &)*arg2);
38841 wxPyEndAllowThreads(__tstate);
38842 if (PyErr_Occurred()) SWIG_fail;
38843 }
38844 resultobj = SWIG_Py_Void();
38845 {
38846 if (temp2) delete arg2;
38847 }
38848 return resultobj;
38849 fail:
38850 {
38851 if (temp2) delete arg2;
38852 }
38853 return NULL;
38854 }
38855
38856
38857 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38858 PyObject *resultobj = 0;
38859 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38860 wxString *arg2 = 0 ;
38861 void *argp1 = 0 ;
38862 int res1 = 0 ;
38863 bool temp2 = false ;
38864 PyObject * obj0 = 0 ;
38865 PyObject * obj1 = 0 ;
38866 char * kwnames[] = {
38867 (char *) "self",(char *) "artist", NULL
38868 };
38869
38870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38872 if (!SWIG_IsOK(res1)) {
38873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38874 }
38875 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38876 {
38877 arg2 = wxString_in_helper(obj1);
38878 if (arg2 == NULL) SWIG_fail;
38879 temp2 = true;
38880 }
38881 {
38882 PyThreadState* __tstate = wxPyBeginAllowThreads();
38883 (arg1)->AddArtist((wxString const &)*arg2);
38884 wxPyEndAllowThreads(__tstate);
38885 if (PyErr_Occurred()) SWIG_fail;
38886 }
38887 resultobj = SWIG_Py_Void();
38888 {
38889 if (temp2)
38890 delete arg2;
38891 }
38892 return resultobj;
38893 fail:
38894 {
38895 if (temp2)
38896 delete arg2;
38897 }
38898 return NULL;
38899 }
38900
38901
38902 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38903 PyObject *resultobj = 0;
38904 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38905 bool result;
38906 void *argp1 = 0 ;
38907 int res1 = 0 ;
38908 PyObject *swig_obj[1] ;
38909
38910 if (!args) SWIG_fail;
38911 swig_obj[0] = args;
38912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38913 if (!SWIG_IsOK(res1)) {
38914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38915 }
38916 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38917 {
38918 PyThreadState* __tstate = wxPyBeginAllowThreads();
38919 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38920 wxPyEndAllowThreads(__tstate);
38921 if (PyErr_Occurred()) SWIG_fail;
38922 }
38923 {
38924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38925 }
38926 return resultobj;
38927 fail:
38928 return NULL;
38929 }
38930
38931
38932 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38933 PyObject *resultobj = 0;
38934 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38935 wxArrayString *result = 0 ;
38936 void *argp1 = 0 ;
38937 int res1 = 0 ;
38938 PyObject *swig_obj[1] ;
38939
38940 if (!args) SWIG_fail;
38941 swig_obj[0] = args;
38942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38943 if (!SWIG_IsOK(res1)) {
38944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38945 }
38946 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38947 {
38948 PyThreadState* __tstate = wxPyBeginAllowThreads();
38949 {
38950 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38951 result = (wxArrayString *) &_result_ref;
38952 }
38953 wxPyEndAllowThreads(__tstate);
38954 if (PyErr_Occurred()) SWIG_fail;
38955 }
38956 {
38957 resultobj = wxArrayString2PyList_helper(*result);
38958 }
38959 return resultobj;
38960 fail:
38961 return NULL;
38962 }
38963
38964
38965 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38966 PyObject *resultobj = 0;
38967 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38968 wxArrayString *arg2 = 0 ;
38969 void *argp1 = 0 ;
38970 int res1 = 0 ;
38971 bool temp2 = false ;
38972 PyObject * obj0 = 0 ;
38973 PyObject * obj1 = 0 ;
38974 char * kwnames[] = {
38975 (char *) "self",(char *) "translators", NULL
38976 };
38977
38978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38980 if (!SWIG_IsOK(res1)) {
38981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38982 }
38983 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38984 {
38985 if (! PySequence_Check(obj1)) {
38986 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38987 SWIG_fail;
38988 }
38989 arg2 = new wxArrayString;
38990 temp2 = true;
38991 int i, len=PySequence_Length(obj1);
38992 for (i=0; i<len; i++) {
38993 PyObject* item = PySequence_GetItem(obj1, i);
38994 wxString* s = wxString_in_helper(item);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 arg2->Add(*s);
38997 delete s;
38998 Py_DECREF(item);
38999 }
39000 }
39001 {
39002 PyThreadState* __tstate = wxPyBeginAllowThreads();
39003 (arg1)->SetTranslators((wxArrayString const &)*arg2);
39004 wxPyEndAllowThreads(__tstate);
39005 if (PyErr_Occurred()) SWIG_fail;
39006 }
39007 resultobj = SWIG_Py_Void();
39008 {
39009 if (temp2) delete arg2;
39010 }
39011 return resultobj;
39012 fail:
39013 {
39014 if (temp2) delete arg2;
39015 }
39016 return NULL;
39017 }
39018
39019
39020 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39021 PyObject *resultobj = 0;
39022 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39023 wxString *arg2 = 0 ;
39024 void *argp1 = 0 ;
39025 int res1 = 0 ;
39026 bool temp2 = false ;
39027 PyObject * obj0 = 0 ;
39028 PyObject * obj1 = 0 ;
39029 char * kwnames[] = {
39030 (char *) "self",(char *) "translator", NULL
39031 };
39032
39033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
39034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39035 if (!SWIG_IsOK(res1)) {
39036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
39037 }
39038 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39039 {
39040 arg2 = wxString_in_helper(obj1);
39041 if (arg2 == NULL) SWIG_fail;
39042 temp2 = true;
39043 }
39044 {
39045 PyThreadState* __tstate = wxPyBeginAllowThreads();
39046 (arg1)->AddTranslator((wxString const &)*arg2);
39047 wxPyEndAllowThreads(__tstate);
39048 if (PyErr_Occurred()) SWIG_fail;
39049 }
39050 resultobj = SWIG_Py_Void();
39051 {
39052 if (temp2)
39053 delete arg2;
39054 }
39055 return resultobj;
39056 fail:
39057 {
39058 if (temp2)
39059 delete arg2;
39060 }
39061 return NULL;
39062 }
39063
39064
39065 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39066 PyObject *resultobj = 0;
39067 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39068 bool result;
39069 void *argp1 = 0 ;
39070 int res1 = 0 ;
39071 PyObject *swig_obj[1] ;
39072
39073 if (!args) SWIG_fail;
39074 swig_obj[0] = args;
39075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39076 if (!SWIG_IsOK(res1)) {
39077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39078 }
39079 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39080 {
39081 PyThreadState* __tstate = wxPyBeginAllowThreads();
39082 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39083 wxPyEndAllowThreads(__tstate);
39084 if (PyErr_Occurred()) SWIG_fail;
39085 }
39086 {
39087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39088 }
39089 return resultobj;
39090 fail:
39091 return NULL;
39092 }
39093
39094
39095 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39096 PyObject *resultobj = 0;
39097 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39098 wxArrayString *result = 0 ;
39099 void *argp1 = 0 ;
39100 int res1 = 0 ;
39101 PyObject *swig_obj[1] ;
39102
39103 if (!args) SWIG_fail;
39104 swig_obj[0] = args;
39105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39106 if (!SWIG_IsOK(res1)) {
39107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39108 }
39109 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39110 {
39111 PyThreadState* __tstate = wxPyBeginAllowThreads();
39112 {
39113 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39114 result = (wxArrayString *) &_result_ref;
39115 }
39116 wxPyEndAllowThreads(__tstate);
39117 if (PyErr_Occurred()) SWIG_fail;
39118 }
39119 {
39120 resultobj = wxArrayString2PyList_helper(*result);
39121 }
39122 return resultobj;
39123 fail:
39124 return NULL;
39125 }
39126
39127
39128 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39129 PyObject *resultobj = 0;
39130 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39131 bool result;
39132 void *argp1 = 0 ;
39133 int res1 = 0 ;
39134 PyObject *swig_obj[1] ;
39135
39136 if (!args) SWIG_fail;
39137 swig_obj[0] = args;
39138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39139 if (!SWIG_IsOK(res1)) {
39140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39141 }
39142 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39143 {
39144 PyThreadState* __tstate = wxPyBeginAllowThreads();
39145 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39146 wxPyEndAllowThreads(__tstate);
39147 if (PyErr_Occurred()) SWIG_fail;
39148 }
39149 {
39150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39151 }
39152 return resultobj;
39153 fail:
39154 return NULL;
39155 }
39156
39157
39158 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39159 PyObject *resultobj = 0;
39160 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39161 wxString result;
39162 void *argp1 = 0 ;
39163 int res1 = 0 ;
39164 PyObject *swig_obj[1] ;
39165
39166 if (!args) SWIG_fail;
39167 swig_obj[0] = args;
39168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39169 if (!SWIG_IsOK(res1)) {
39170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39171 }
39172 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39173 {
39174 PyThreadState* __tstate = wxPyBeginAllowThreads();
39175 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39176 wxPyEndAllowThreads(__tstate);
39177 if (PyErr_Occurred()) SWIG_fail;
39178 }
39179 {
39180 #if wxUSE_UNICODE
39181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39182 #else
39183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39184 #endif
39185 }
39186 return resultobj;
39187 fail:
39188 return NULL;
39189 }
39190
39191
39192 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39193 PyObject *obj;
39194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39195 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39196 return SWIG_Py_Void();
39197 }
39198
39199 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39200 return SWIG_Python_InitShadowInstance(args);
39201 }
39202
39203 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39204 PyObject *resultobj = 0;
39205 wxAboutDialogInfo *arg1 = 0 ;
39206 void *argp1 = 0 ;
39207 int res1 = 0 ;
39208 PyObject * obj0 = 0 ;
39209 char * kwnames[] = {
39210 (char *) "info", NULL
39211 };
39212
39213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39214 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39215 if (!SWIG_IsOK(res1)) {
39216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39217 }
39218 if (!argp1) {
39219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39220 }
39221 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39222 {
39223 PyThreadState* __tstate = wxPyBeginAllowThreads();
39224 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39225 wxPyEndAllowThreads(__tstate);
39226 if (PyErr_Occurred()) SWIG_fail;
39227 }
39228 resultobj = SWIG_Py_Void();
39229 return resultobj;
39230 fail:
39231 return NULL;
39232 }
39233
39234
39235 static PyMethodDef SwigMethods[] = {
39236 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39238 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39239 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39241 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39242 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39243 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39244 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39245 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39250 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39251 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39252 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39253 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39255 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39256 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39257 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39258 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39259 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39260 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39261 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39263 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39264 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39266 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39267 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39268 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39269 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39270 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39271 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39274 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39275 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39276 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39277 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39278 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39279 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39280 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39281 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39282 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39283 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39284 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39285 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39286 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39291 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39292 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39293 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39295 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39296 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39297 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39298 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39299 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39300 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39301 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39302 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39303 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39304 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39305 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39306 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39307 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39309 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39310 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39311 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39312 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39313 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39314 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39317 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39318 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39319 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39320 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39321 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39322 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39323 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39324 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39325 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39326 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39327 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39328 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39329 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39330 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39333 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39334 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39335 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39336 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39337 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39338 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39339 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39340 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39341 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39342 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39343 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39344 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39345 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39346 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39347 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39348 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39349 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39350 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39351 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39352 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39353 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39354 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39355 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39356 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39357 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39359 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39360 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39361 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39362 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39363 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39364 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39365 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39366 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39367 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39368 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39369 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39370 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39371 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39372 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39373 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39374 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39375 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39376 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39377 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39379 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39380 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39381 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39383 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39384 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39385 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39387 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39388 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39389 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39390 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39391 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39393 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39394 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39395 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39396 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39397 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39398 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39399 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39402 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39407 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39410 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39411 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39412 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39414 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39415 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39417 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39418 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39419 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39420 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39421 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39422 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39423 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39424 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39426 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39427 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39428 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39429 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39430 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39431 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39432 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39433 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39434 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39435 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39436 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39437 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39438 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39439 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39440 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39442 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39443 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39446 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39447 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39448 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39450 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39451 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39452 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39454 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39456 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39457 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39458 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39459 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39460 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39461 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39462 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39465 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39467 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39468 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39469 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39470 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39471 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39472 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39473 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39474 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39475 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39476 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39477 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39478 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39479 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39480 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39481 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39482 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39483 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39484 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39485 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39486 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39487 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39488 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39489 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39490 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39491 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39492 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39493 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39494 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39495 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39497 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39498 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39499 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39500 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39501 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39502 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39503 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39504 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39506 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39507 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39509 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39510 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39511 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39512 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39513 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39514 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39515 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39516 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39517 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39518 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39519 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39520 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39521 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39522 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39523 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39526 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39527 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39528 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39529 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39530 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39531 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39532 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39533 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39534 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39535 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39536 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39537 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39538 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39539 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39540 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39541 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39542 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39543 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39544 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39545 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39546 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39548 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39551 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39552 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39553 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39554 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39555 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39556 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39558 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39559 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39560 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39561 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39562 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39563 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39564 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39565 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39566 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39570 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39572 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39574 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39575 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39576 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39577 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39578 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39579 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39580 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39581 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39582 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39583 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39584 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39585 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39586 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39587 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39588 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39589 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39590 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39591 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39592 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39593 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39594 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39595 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39598 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39599 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39600 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39601 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39602 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39603 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39604 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39605 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39606 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39607 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39609 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39610 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39611 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39612 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39613 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39614 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39615 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39616 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39617 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39618 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39619 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39620 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39621 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39622 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39623 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39624 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39625 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39626 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39627 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39628 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39629 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39630 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39631 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39632 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39633 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39634 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39635 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39636 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39637 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39638 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39640 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39641 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39642 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39643 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39644 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39645 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39646 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39647 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39648 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39654 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39655 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39656 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39660 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39661 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39664 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39667 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39670 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39671 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39672 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39675 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39676 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39679 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39680 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39681 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39682 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39683 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39684 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39685 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39686 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39687 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39688 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39689 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39691 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39692 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39693 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39694 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39695 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39696 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39697 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39703 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39705 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39706 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39708 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39710 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39715 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39719 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39720 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39721 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39722 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39723 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39727 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39732 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39733 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39734 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39735 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39738 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39739 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39741 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39742 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39744 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39765 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39767 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39769 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39771 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39772 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39776 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39777 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39779 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39780 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39781 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39783 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39784 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39785 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39787 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39788 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39789 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39790 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39793 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39804 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39808 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39809 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39810 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39811 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39817 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39818 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39823 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39824 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39848 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39849 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39850 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39851 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39852 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39864 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39865 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39891 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39892 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39893 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39894 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39907 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39908 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39909 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39910 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39911 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39912 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39913 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39914 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39915 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39916 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39917 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39918 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39919 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39920 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39921 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39922 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39924 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39926 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39930 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39931 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39935 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39946 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39947 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39948 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39949 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39952 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39953 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39954 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39955 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39956 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39957 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39959 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39960 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39962 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39964 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39965 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39966 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39968 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39970 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39975 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39976 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39977 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39978 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39979 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39980 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39982 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39986 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39992 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39994 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39995 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39996 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39997 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39998 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39999 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
40002 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
40003 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
40004 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
40005 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
40006 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
40007 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
40008 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
40009 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
40010 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
40011 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40012 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
40016 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
40019 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40020 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
40021 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
40023 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
40024 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
40026 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
40027 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40028 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
40030 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
40031 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
40032 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
40034 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
40035 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
40036 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40037 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
40038 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
40039 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
40040 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
40041 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
40042 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40043 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
40045 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
40046 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
40048 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
40049 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
40050 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
40051 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40052 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40053 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
40054 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
40055 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
40056 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
40057 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
40059 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40060 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40061 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40062 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40063 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40064 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40065 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40066 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40068 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40069 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40070 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40071 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40072 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
40073 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
40074 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40075 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40076 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40077 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40078 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40080 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40082 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40083 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40084 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40085 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40086 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40087 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40088 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40090 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40091 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40092 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40093 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40094 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40095 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40096 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40097 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40098 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40099 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40100 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40101 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40102 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40103 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40105 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40106 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40107 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40108 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40109 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40110 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40111 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40112 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40113 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40114 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40115 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40116 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40117 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40118 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40119 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40120 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40121 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40122 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40123 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40124 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40125 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40126 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40127 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40128 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40129 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40130 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40131 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40132 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40133 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40134 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40135 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40136 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40137 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40138 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40139 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40140 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40141 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40142 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40143 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40144 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40145 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40146 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40147 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40148 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40149 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40150 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40151 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40152 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40153 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40154 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40155 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40156 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40157 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40158 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40159 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40160 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40161 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40162 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40163 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40164 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40165 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40166 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40167 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40168 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40169 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40170 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40171 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40172 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40173 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40174 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40175 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40176 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40177 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40178 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40179 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40180 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40181 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40182 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40183 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40184 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40185 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40186 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40187 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40188 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40189 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40190 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40191 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40192 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40193 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40194 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40195 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40196 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40197 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40198 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40199 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40200 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40201 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40202 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40203 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40204 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40205 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40206 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40207 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40208 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40209 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40210 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40211 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40212 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40213 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40214 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40215 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40216 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40217 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40218 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40219 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40220 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40221 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40222 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40223 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40224 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40225 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40226 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40227 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40228 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40229 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40230 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40231 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40232 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40233 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40234 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40235 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40236 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40237 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40238 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40239 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40240 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40241 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40242 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40243 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40244 { NULL, NULL, 0, NULL }
40245 };
40246
40247
40248 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40249
40250 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40251 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40252 }
40253 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40254 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40255 }
40256 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40257 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40258 }
40259 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40260 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40261 }
40262 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40263 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40264 }
40265 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40266 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40267 }
40268 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40269 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40270 }
40271 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40272 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40273 }
40274 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40275 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40276 }
40277 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40278 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40279 }
40280 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40281 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40282 }
40283 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40284 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40285 }
40286 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40287 return (void *)((wxEvent *) ((wxPyEvent *) x));
40288 }
40289 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40290 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40291 }
40292 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40293 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40294 }
40295 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40296 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40297 }
40298 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40299 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40300 }
40301 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40302 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40303 }
40304 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40305 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40306 }
40307 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40308 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40309 }
40310 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40311 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40312 }
40313 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40314 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40315 }
40316 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40317 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40318 }
40319 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40320 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40321 }
40322 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40323 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40324 }
40325 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40326 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40327 }
40328 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40329 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40330 }
40331 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40332 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40333 }
40334 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40335 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40336 }
40337 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40338 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40339 }
40340 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40341 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40342 }
40343 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40344 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40345 }
40346 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40347 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40348 }
40349 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40350 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40351 }
40352 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40353 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40354 }
40355 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40356 return (void *)((wxEvent *) ((wxShowEvent *) x));
40357 }
40358 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40359 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40360 }
40361 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40362 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40363 }
40364 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40365 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40366 }
40367 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40368 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40369 }
40370 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40371 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40372 }
40373 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40374 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40375 }
40376 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40377 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40378 }
40379 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40380 return (void *)((wxConfigBase *) ((wxConfig *) x));
40381 }
40382 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40383 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40384 }
40385 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40386 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40387 }
40388 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40389 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40390 }
40391 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40392 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40393 }
40394 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40395 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40396 }
40397 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40398 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40399 }
40400 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40401 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40402 }
40403 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40404 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40405 }
40406 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40407 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40408 }
40409 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40410 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40411 }
40412 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40413 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40414 }
40415 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40416 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40417 }
40418 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40419 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40420 }
40421 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40422 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40423 }
40424 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40425 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40426 }
40427 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40428 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40429 }
40430 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40431 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40432 }
40433 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40434 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40435 }
40436 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40437 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40438 }
40439 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40440 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40441 }
40442 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40443 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40444 }
40445 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40446 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40447 }
40448 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40449 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40450 }
40451 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40452 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40453 }
40454 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40455 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40456 }
40457 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40458 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40459 }
40460 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40461 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40462 }
40463 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40464 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40465 }
40466 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40467 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40468 }
40469 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40470 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40471 }
40472 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40473 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40474 }
40475 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40476 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40477 }
40478 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40479 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40480 }
40481 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40482 return (void *)((wxObject *) ((wxSizerItem *) x));
40483 }
40484 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40485 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40486 }
40487 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40489 }
40490 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40491 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40492 }
40493 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40494 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40495 }
40496 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40497 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40498 }
40499 static void *_p_wxSizerTo_p_wxObject(void *x) {
40500 return (void *)((wxObject *) ((wxSizer *) x));
40501 }
40502 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40503 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40504 }
40505 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40506 return (void *)((wxObject *) ((wxFileHistory *) x));
40507 }
40508 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40509 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40510 }
40511 static void *_p_wxEventTo_p_wxObject(void *x) {
40512 return (void *)((wxObject *) ((wxEvent *) x));
40513 }
40514 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40515 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40516 }
40517 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40518 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40519 }
40520 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40521 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40522 }
40523 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40524 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40525 }
40526 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40527 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40528 }
40529 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40530 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40531 }
40532 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40533 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40534 }
40535 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40536 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40537 }
40538 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40539 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40540 }
40541 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40542 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40543 }
40544 static void *_p_wxControlTo_p_wxObject(void *x) {
40545 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40546 }
40547 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40548 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40549 }
40550 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40551 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40552 }
40553 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40554 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40555 }
40556 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40557 return (void *)((wxObject *) ((wxFSFile *) x));
40558 }
40559 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40560 return (void *)((wxObject *) ((wxClipboard *) x));
40561 }
40562 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40563 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40564 }
40565 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40566 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40567 }
40568 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40569 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40570 }
40571 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40572 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40573 }
40574 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40575 return (void *)((wxObject *) ((wxToolTip *) x));
40576 }
40577 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40578 return (void *)((wxObject *) ((wxMenuItem *) x));
40579 }
40580 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40581 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40582 }
40583 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40584 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40585 }
40586 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40587 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40588 }
40589 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40590 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40591 }
40592 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40593 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40594 }
40595 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40596 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40597 }
40598 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40599 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40600 }
40601 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40602 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40603 }
40604 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40605 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40606 }
40607 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40608 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40609 }
40610 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40611 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40612 }
40613 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40614 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40615 }
40616 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40617 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40618 }
40619 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40620 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40621 }
40622 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40623 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40624 }
40625 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40626 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40627 }
40628 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40629 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40630 }
40631 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40632 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40633 }
40634 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40635 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40636 }
40637 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40638 return (void *)((wxObject *) ((wxImageHandler *) x));
40639 }
40640 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40641 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40642 }
40643 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40644 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40645 }
40646 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40647 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40648 }
40649 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40650 return (void *)((wxObject *) ((wxEvtHandler *) x));
40651 }
40652 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40653 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40654 }
40655 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40656 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40657 }
40658 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40659 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40660 }
40661 static void *_p_wxImageTo_p_wxObject(void *x) {
40662 return (void *)((wxObject *) ((wxImage *) x));
40663 }
40664 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40665 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40666 }
40667 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40668 return (void *)((wxObject *) ((wxSystemOptions *) x));
40669 }
40670 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40671 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40672 }
40673 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40674 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40675 }
40676 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40677 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40678 }
40679 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40680 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40681 }
40682 static void *_p_wxWindowTo_p_wxObject(void *x) {
40683 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40684 }
40685 static void *_p_wxMenuTo_p_wxObject(void *x) {
40686 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40687 }
40688 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40689 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40690 }
40691 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40692 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40693 }
40694 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40695 return (void *)((wxObject *) ((wxFileSystem *) x));
40696 }
40697 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40698 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40699 }
40700 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40701 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40702 }
40703 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40704 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40705 }
40706 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40707 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40708 }
40709 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40710 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40711 }
40712 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40713 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40714 }
40715 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40716 return (void *)((wxObject *) ((wxBusyInfo *) x));
40717 }
40718 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40719 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40720 }
40721 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40722 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40723 }
40724 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40725 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40726 }
40727 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40728 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40729 }
40730 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40731 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40732 }
40733 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40734 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40735 }
40736 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40737 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40738 }
40739 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40740 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40741 }
40742 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40743 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40744 }
40745 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40746 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40747 }
40748 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40749 return (void *)((wxLog *) ((wxLogBuffer *) x));
40750 }
40751 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40752 return (void *)((wxLog *) ((wxLogStderr *) x));
40753 }
40754 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40755 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40756 }
40757 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40758 return (void *)((wxLog *) ((wxLogWindow *) x));
40759 }
40760 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40761 return (void *)((wxLog *) ((wxLogChain *) x));
40762 }
40763 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40764 return (void *)((wxLog *) ((wxLogGui *) x));
40765 }
40766 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40767 return (void *)((wxLog *) ((wxPyLog *) x));
40768 }
40769 static void *_p_wxControlTo_p_wxWindow(void *x) {
40770 return (void *)((wxWindow *) ((wxControl *) x));
40771 }
40772 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40773 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40774 }
40775 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40776 return (void *)((wxWindow *) ((wxMenuBar *) x));
40777 }
40778 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40779 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40780 }
40781 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40782 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40783 }
40784 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40785 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};
40786 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40812 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40813 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40814 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40815 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40816 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40818 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40825 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40828 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40832 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40833 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40835 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40836 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40837 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40838 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40839 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40840 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40841 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40842 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40843 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40844 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40845 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40846 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40847 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40848 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40849 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40850 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40851 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40852 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40853 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40854 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40855 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40856 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40857 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40858 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40859 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40860 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40861 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40862 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40863 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40866 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40867 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40868 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40870 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40871 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40875 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40876 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40877 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40878 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40879 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40880 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40881 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40882 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40883 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40884 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40885 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40886 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40887 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40888 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40889 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40890 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40891 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40892 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40893 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40894 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40895 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40896 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40897 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40898 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40899 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40900 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40901 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40902 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40903 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40904 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40905 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40906 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40907 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40908 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40909 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40910 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40911 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40912 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40913 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40914 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40915 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40916 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40917 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40918 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40919 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40920 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40921 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40922 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40923 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40924 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40925 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40926 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40927 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40928 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40929 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40930 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40931 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40932 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40933 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40934 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40935 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40936 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40937 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40938 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40939 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40940 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40941 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40942 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40943 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40944 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40945 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40946 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40947 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40948 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40949 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40950 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40951 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40952 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40953 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40954 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40955 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40956 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40957 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40958 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40959
40960 static swig_type_info *swig_type_initial[] = {
40961 &_swigt__p_char,
40962 &_swigt__p_form_ops_t,
40963 &_swigt__p_int,
40964 &_swigt__p_unsigned_char,
40965 &_swigt__p_unsigned_int,
40966 &_swigt__p_unsigned_long,
40967 &_swigt__p_void,
40968 &_swigt__p_wxANIHandler,
40969 &_swigt__p_wxAboutDialogInfo,
40970 &_swigt__p_wxAcceleratorTable,
40971 &_swigt__p_wxActivateEvent,
40972 &_swigt__p_wxArrayString,
40973 &_swigt__p_wxBMPHandler,
40974 &_swigt__p_wxBitmap,
40975 &_swigt__p_wxBitmapDataObject,
40976 &_swigt__p_wxBoxSizer,
40977 &_swigt__p_wxBusyCursor,
40978 &_swigt__p_wxBusyInfo,
40979 &_swigt__p_wxCURHandler,
40980 &_swigt__p_wxCaret,
40981 &_swigt__p_wxChar,
40982 &_swigt__p_wxChildFocusEvent,
40983 &_swigt__p_wxClipboard,
40984 &_swigt__p_wxClipboardLocker,
40985 &_swigt__p_wxClipboardTextEvent,
40986 &_swigt__p_wxCloseEvent,
40987 &_swigt__p_wxColour,
40988 &_swigt__p_wxCommandEvent,
40989 &_swigt__p_wxConfig,
40990 &_swigt__p_wxConfigBase,
40991 &_swigt__p_wxConfigPathChanger,
40992 &_swigt__p_wxContextMenuEvent,
40993 &_swigt__p_wxControl,
40994 &_swigt__p_wxControlWithItems,
40995 &_swigt__p_wxCursor,
40996 &_swigt__p_wxCustomDataObject,
40997 &_swigt__p_wxDC,
40998 &_swigt__p_wxDataFormat,
40999 &_swigt__p_wxDataObject,
41000 &_swigt__p_wxDataObjectComposite,
41001 &_swigt__p_wxDataObjectSimple,
41002 &_swigt__p_wxDateEvent,
41003 &_swigt__p_wxDateSpan,
41004 &_swigt__p_wxDateTime,
41005 &_swigt__p_wxDateTime__TimeZone,
41006 &_swigt__p_wxDisplay,
41007 &_swigt__p_wxDisplayChangedEvent,
41008 &_swigt__p_wxDropFilesEvent,
41009 &_swigt__p_wxDuplexMode,
41010 &_swigt__p_wxEraseEvent,
41011 &_swigt__p_wxEvent,
41012 &_swigt__p_wxEvtHandler,
41013 &_swigt__p_wxFSFile,
41014 &_swigt__p_wxFileConfig,
41015 &_swigt__p_wxFileDataObject,
41016 &_swigt__p_wxFileHistory,
41017 &_swigt__p_wxFileSystem,
41018 &_swigt__p_wxFileType,
41019 &_swigt__p_wxFileTypeInfo,
41020 &_swigt__p_wxFlexGridSizer,
41021 &_swigt__p_wxFocusEvent,
41022 &_swigt__p_wxFont,
41023 &_swigt__p_wxFrame,
41024 &_swigt__p_wxGBSizerItem,
41025 &_swigt__p_wxGIFHandler,
41026 &_swigt__p_wxGridBagSizer,
41027 &_swigt__p_wxGridSizer,
41028 &_swigt__p_wxICOHandler,
41029 &_swigt__p_wxIcon,
41030 &_swigt__p_wxIconizeEvent,
41031 &_swigt__p_wxIdleEvent,
41032 &_swigt__p_wxImage,
41033 &_swigt__p_wxImageHandler,
41034 &_swigt__p_wxIndividualLayoutConstraint,
41035 &_swigt__p_wxInitDialogEvent,
41036 &_swigt__p_wxJPEGHandler,
41037 &_swigt__p_wxJoystick,
41038 &_swigt__p_wxJoystickEvent,
41039 &_swigt__p_wxKeyEvent,
41040 &_swigt__p_wxKillError,
41041 &_swigt__p_wxLayoutConstraints,
41042 &_swigt__p_wxLog,
41043 &_swigt__p_wxLogBuffer,
41044 &_swigt__p_wxLogChain,
41045 &_swigt__p_wxLogGui,
41046 &_swigt__p_wxLogNull,
41047 &_swigt__p_wxLogStderr,
41048 &_swigt__p_wxLogTextCtrl,
41049 &_swigt__p_wxLogWindow,
41050 &_swigt__p_wxMaximizeEvent,
41051 &_swigt__p_wxMenu,
41052 &_swigt__p_wxMenuBar,
41053 &_swigt__p_wxMenuEvent,
41054 &_swigt__p_wxMenuItem,
41055 &_swigt__p_wxMetafile,
41056 &_swigt__p_wxMetafileDataObject,
41057 &_swigt__p_wxMimeTypesManager,
41058 &_swigt__p_wxMouseCaptureChangedEvent,
41059 &_swigt__p_wxMouseCaptureLostEvent,
41060 &_swigt__p_wxMouseEvent,
41061 &_swigt__p_wxMouseState,
41062 &_swigt__p_wxMoveEvent,
41063 &_swigt__p_wxMutexGuiLocker,
41064 &_swigt__p_wxNavigationKeyEvent,
41065 &_swigt__p_wxNcPaintEvent,
41066 &_swigt__p_wxNotifyEvent,
41067 &_swigt__p_wxObject,
41068 &_swigt__p_wxOutputStream,
41069 &_swigt__p_wxPCXHandler,
41070 &_swigt__p_wxPNGHandler,
41071 &_swigt__p_wxPNMHandler,
41072 &_swigt__p_wxPaintEvent,
41073 &_swigt__p_wxPaletteChangedEvent,
41074 &_swigt__p_wxPaperSize,
41075 &_swigt__p_wxPlatformInfo,
41076 &_swigt__p_wxPoint,
41077 &_swigt__p_wxPowerEvent,
41078 &_swigt__p_wxProcessEvent,
41079 &_swigt__p_wxPyApp,
41080 &_swigt__p_wxPyArtProvider,
41081 &_swigt__p_wxPyBitmapDataObject,
41082 &_swigt__p_wxPyCommandEvent,
41083 &_swigt__p_wxPyDataObjectSimple,
41084 &_swigt__p_wxPyDropSource,
41085 &_swigt__p_wxPyDropTarget,
41086 &_swigt__p_wxPyEvent,
41087 &_swigt__p_wxPyFileDropTarget,
41088 &_swigt__p_wxPyImageHandler,
41089 &_swigt__p_wxPyLog,
41090 &_swigt__p_wxPyProcess,
41091 &_swigt__p_wxPySizer,
41092 &_swigt__p_wxPyTextDataObject,
41093 &_swigt__p_wxPyTextDropTarget,
41094 &_swigt__p_wxPyTimer,
41095 &_swigt__p_wxPyTipProvider,
41096 &_swigt__p_wxPyValidator,
41097 &_swigt__p_wxQueryNewPaletteEvent,
41098 &_swigt__p_wxRect,
41099 &_swigt__p_wxScrollEvent,
41100 &_swigt__p_wxScrollWinEvent,
41101 &_swigt__p_wxSetCursorEvent,
41102 &_swigt__p_wxShowEvent,
41103 &_swigt__p_wxSingleInstanceChecker,
41104 &_swigt__p_wxSize,
41105 &_swigt__p_wxSizeEvent,
41106 &_swigt__p_wxSizer,
41107 &_swigt__p_wxSizerItem,
41108 &_swigt__p_wxSound,
41109 &_swigt__p_wxStandardPaths,
41110 &_swigt__p_wxStaticBoxSizer,
41111 &_swigt__p_wxStdDialogButtonSizer,
41112 &_swigt__p_wxStopWatch,
41113 &_swigt__p_wxString,
41114 &_swigt__p_wxSysColourChangedEvent,
41115 &_swigt__p_wxSystemOptions,
41116 &_swigt__p_wxSystemSettings,
41117 &_swigt__p_wxTGAHandler,
41118 &_swigt__p_wxTIFFHandler,
41119 &_swigt__p_wxTextCtrl,
41120 &_swigt__p_wxTextDataObject,
41121 &_swigt__p_wxTimeSpan,
41122 &_swigt__p_wxTimer,
41123 &_swigt__p_wxTimerEvent,
41124 &_swigt__p_wxTimerRunner,
41125 &_swigt__p_wxTipProvider,
41126 &_swigt__p_wxToolTip,
41127 &_swigt__p_wxURLDataObject,
41128 &_swigt__p_wxUpdateUIEvent,
41129 &_swigt__p_wxValidator,
41130 &_swigt__p_wxVideoMode,
41131 &_swigt__p_wxWindow,
41132 &_swigt__p_wxWindowCreateEvent,
41133 &_swigt__p_wxWindowDestroyEvent,
41134 &_swigt__p_wxWindowDisabler,
41135 &_swigt__p_wxXPMHandler,
41136 };
41137
41138 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41148 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}};
41149 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41157 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}};
41158 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41163 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}};
41164 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41165 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}};
41166 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41209 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}};
41210 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41219 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41228 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}};
41229 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41232 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41233 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41237 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41241 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41244 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41245 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41246 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41247 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41248 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41251 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41252 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41255 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41256 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41257 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41258 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41259 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41260 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41261 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41262 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41263 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41264 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41265 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41266 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41267 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41268 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41269 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41270 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41271 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41272 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41273 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41274 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41275 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41276 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41277 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41278 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41279 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41280 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41281 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41282 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41283 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41284 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}};
41285 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41286 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41287 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41288 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41289 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41290 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41291 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41292 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41293 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41294 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41295 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41296 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41297 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41298 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41299 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41300 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41301 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41302 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}};
41303 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41304 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41305 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41306 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41307 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}};
41308 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41309 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41310 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41311 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}};
41312 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41313
41314 static swig_cast_info *swig_cast_initial[] = {
41315 _swigc__p_char,
41316 _swigc__p_form_ops_t,
41317 _swigc__p_int,
41318 _swigc__p_unsigned_char,
41319 _swigc__p_unsigned_int,
41320 _swigc__p_unsigned_long,
41321 _swigc__p_void,
41322 _swigc__p_wxANIHandler,
41323 _swigc__p_wxAboutDialogInfo,
41324 _swigc__p_wxAcceleratorTable,
41325 _swigc__p_wxActivateEvent,
41326 _swigc__p_wxArrayString,
41327 _swigc__p_wxBMPHandler,
41328 _swigc__p_wxBitmap,
41329 _swigc__p_wxBitmapDataObject,
41330 _swigc__p_wxBoxSizer,
41331 _swigc__p_wxBusyCursor,
41332 _swigc__p_wxBusyInfo,
41333 _swigc__p_wxCURHandler,
41334 _swigc__p_wxCaret,
41335 _swigc__p_wxChar,
41336 _swigc__p_wxChildFocusEvent,
41337 _swigc__p_wxClipboard,
41338 _swigc__p_wxClipboardLocker,
41339 _swigc__p_wxClipboardTextEvent,
41340 _swigc__p_wxCloseEvent,
41341 _swigc__p_wxColour,
41342 _swigc__p_wxCommandEvent,
41343 _swigc__p_wxConfig,
41344 _swigc__p_wxConfigBase,
41345 _swigc__p_wxConfigPathChanger,
41346 _swigc__p_wxContextMenuEvent,
41347 _swigc__p_wxControl,
41348 _swigc__p_wxControlWithItems,
41349 _swigc__p_wxCursor,
41350 _swigc__p_wxCustomDataObject,
41351 _swigc__p_wxDC,
41352 _swigc__p_wxDataFormat,
41353 _swigc__p_wxDataObject,
41354 _swigc__p_wxDataObjectComposite,
41355 _swigc__p_wxDataObjectSimple,
41356 _swigc__p_wxDateEvent,
41357 _swigc__p_wxDateSpan,
41358 _swigc__p_wxDateTime,
41359 _swigc__p_wxDateTime__TimeZone,
41360 _swigc__p_wxDisplay,
41361 _swigc__p_wxDisplayChangedEvent,
41362 _swigc__p_wxDropFilesEvent,
41363 _swigc__p_wxDuplexMode,
41364 _swigc__p_wxEraseEvent,
41365 _swigc__p_wxEvent,
41366 _swigc__p_wxEvtHandler,
41367 _swigc__p_wxFSFile,
41368 _swigc__p_wxFileConfig,
41369 _swigc__p_wxFileDataObject,
41370 _swigc__p_wxFileHistory,
41371 _swigc__p_wxFileSystem,
41372 _swigc__p_wxFileType,
41373 _swigc__p_wxFileTypeInfo,
41374 _swigc__p_wxFlexGridSizer,
41375 _swigc__p_wxFocusEvent,
41376 _swigc__p_wxFont,
41377 _swigc__p_wxFrame,
41378 _swigc__p_wxGBSizerItem,
41379 _swigc__p_wxGIFHandler,
41380 _swigc__p_wxGridBagSizer,
41381 _swigc__p_wxGridSizer,
41382 _swigc__p_wxICOHandler,
41383 _swigc__p_wxIcon,
41384 _swigc__p_wxIconizeEvent,
41385 _swigc__p_wxIdleEvent,
41386 _swigc__p_wxImage,
41387 _swigc__p_wxImageHandler,
41388 _swigc__p_wxIndividualLayoutConstraint,
41389 _swigc__p_wxInitDialogEvent,
41390 _swigc__p_wxJPEGHandler,
41391 _swigc__p_wxJoystick,
41392 _swigc__p_wxJoystickEvent,
41393 _swigc__p_wxKeyEvent,
41394 _swigc__p_wxKillError,
41395 _swigc__p_wxLayoutConstraints,
41396 _swigc__p_wxLog,
41397 _swigc__p_wxLogBuffer,
41398 _swigc__p_wxLogChain,
41399 _swigc__p_wxLogGui,
41400 _swigc__p_wxLogNull,
41401 _swigc__p_wxLogStderr,
41402 _swigc__p_wxLogTextCtrl,
41403 _swigc__p_wxLogWindow,
41404 _swigc__p_wxMaximizeEvent,
41405 _swigc__p_wxMenu,
41406 _swigc__p_wxMenuBar,
41407 _swigc__p_wxMenuEvent,
41408 _swigc__p_wxMenuItem,
41409 _swigc__p_wxMetafile,
41410 _swigc__p_wxMetafileDataObject,
41411 _swigc__p_wxMimeTypesManager,
41412 _swigc__p_wxMouseCaptureChangedEvent,
41413 _swigc__p_wxMouseCaptureLostEvent,
41414 _swigc__p_wxMouseEvent,
41415 _swigc__p_wxMouseState,
41416 _swigc__p_wxMoveEvent,
41417 _swigc__p_wxMutexGuiLocker,
41418 _swigc__p_wxNavigationKeyEvent,
41419 _swigc__p_wxNcPaintEvent,
41420 _swigc__p_wxNotifyEvent,
41421 _swigc__p_wxObject,
41422 _swigc__p_wxOutputStream,
41423 _swigc__p_wxPCXHandler,
41424 _swigc__p_wxPNGHandler,
41425 _swigc__p_wxPNMHandler,
41426 _swigc__p_wxPaintEvent,
41427 _swigc__p_wxPaletteChangedEvent,
41428 _swigc__p_wxPaperSize,
41429 _swigc__p_wxPlatformInfo,
41430 _swigc__p_wxPoint,
41431 _swigc__p_wxPowerEvent,
41432 _swigc__p_wxProcessEvent,
41433 _swigc__p_wxPyApp,
41434 _swigc__p_wxPyArtProvider,
41435 _swigc__p_wxPyBitmapDataObject,
41436 _swigc__p_wxPyCommandEvent,
41437 _swigc__p_wxPyDataObjectSimple,
41438 _swigc__p_wxPyDropSource,
41439 _swigc__p_wxPyDropTarget,
41440 _swigc__p_wxPyEvent,
41441 _swigc__p_wxPyFileDropTarget,
41442 _swigc__p_wxPyImageHandler,
41443 _swigc__p_wxPyLog,
41444 _swigc__p_wxPyProcess,
41445 _swigc__p_wxPySizer,
41446 _swigc__p_wxPyTextDataObject,
41447 _swigc__p_wxPyTextDropTarget,
41448 _swigc__p_wxPyTimer,
41449 _swigc__p_wxPyTipProvider,
41450 _swigc__p_wxPyValidator,
41451 _swigc__p_wxQueryNewPaletteEvent,
41452 _swigc__p_wxRect,
41453 _swigc__p_wxScrollEvent,
41454 _swigc__p_wxScrollWinEvent,
41455 _swigc__p_wxSetCursorEvent,
41456 _swigc__p_wxShowEvent,
41457 _swigc__p_wxSingleInstanceChecker,
41458 _swigc__p_wxSize,
41459 _swigc__p_wxSizeEvent,
41460 _swigc__p_wxSizer,
41461 _swigc__p_wxSizerItem,
41462 _swigc__p_wxSound,
41463 _swigc__p_wxStandardPaths,
41464 _swigc__p_wxStaticBoxSizer,
41465 _swigc__p_wxStdDialogButtonSizer,
41466 _swigc__p_wxStopWatch,
41467 _swigc__p_wxString,
41468 _swigc__p_wxSysColourChangedEvent,
41469 _swigc__p_wxSystemOptions,
41470 _swigc__p_wxSystemSettings,
41471 _swigc__p_wxTGAHandler,
41472 _swigc__p_wxTIFFHandler,
41473 _swigc__p_wxTextCtrl,
41474 _swigc__p_wxTextDataObject,
41475 _swigc__p_wxTimeSpan,
41476 _swigc__p_wxTimer,
41477 _swigc__p_wxTimerEvent,
41478 _swigc__p_wxTimerRunner,
41479 _swigc__p_wxTipProvider,
41480 _swigc__p_wxToolTip,
41481 _swigc__p_wxURLDataObject,
41482 _swigc__p_wxUpdateUIEvent,
41483 _swigc__p_wxValidator,
41484 _swigc__p_wxVideoMode,
41485 _swigc__p_wxWindow,
41486 _swigc__p_wxWindowCreateEvent,
41487 _swigc__p_wxWindowDestroyEvent,
41488 _swigc__p_wxWindowDisabler,
41489 _swigc__p_wxXPMHandler,
41490 };
41491
41492
41493 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41494
41495 static swig_const_info swig_const_table[] = {
41496 {0, 0, 0, 0.0, 0, 0}};
41497
41498 #ifdef __cplusplus
41499 }
41500 #endif
41501 /* -----------------------------------------------------------------------------
41502 * Type initialization:
41503 * This problem is tough by the requirement that no dynamic
41504 * memory is used. Also, since swig_type_info structures store pointers to
41505 * swig_cast_info structures and swig_cast_info structures store pointers back
41506 * to swig_type_info structures, we need some lookup code at initialization.
41507 * The idea is that swig generates all the structures that are needed.
41508 * The runtime then collects these partially filled structures.
41509 * The SWIG_InitializeModule function takes these initial arrays out of
41510 * swig_module, and does all the lookup, filling in the swig_module.types
41511 * array with the correct data and linking the correct swig_cast_info
41512 * structures together.
41513 *
41514 * The generated swig_type_info structures are assigned staticly to an initial
41515 * array. We just loop though that array, and handle each type individually.
41516 * First we lookup if this type has been already loaded, and if so, use the
41517 * loaded structure instead of the generated one. Then we have to fill in the
41518 * cast linked list. The cast data is initially stored in something like a
41519 * two-dimensional array. Each row corresponds to a type (there are the same
41520 * number of rows as there are in the swig_type_initial array). Each entry in
41521 * a column is one of the swig_cast_info structures for that type.
41522 * The cast_initial array is actually an array of arrays, because each row has
41523 * a variable number of columns. So to actually build the cast linked list,
41524 * we find the array of casts associated with the type, and loop through it
41525 * adding the casts to the list. The one last trick we need to do is making
41526 * sure the type pointer in the swig_cast_info struct is correct.
41527 *
41528 * First off, we lookup the cast->type name to see if it is already loaded.
41529 * There are three cases to handle:
41530 * 1) If the cast->type has already been loaded AND the type we are adding
41531 * casting info to has not been loaded (it is in this module), THEN we
41532 * replace the cast->type pointer with the type pointer that has already
41533 * been loaded.
41534 * 2) If BOTH types (the one we are adding casting info to, and the
41535 * cast->type) are loaded, THEN the cast info has already been loaded by
41536 * the previous module so we just ignore it.
41537 * 3) Finally, if cast->type has not already been loaded, then we add that
41538 * swig_cast_info to the linked list (because the cast->type) pointer will
41539 * be correct.
41540 * ----------------------------------------------------------------------------- */
41541
41542 #ifdef __cplusplus
41543 extern "C" {
41544 #if 0
41545 } /* c-mode */
41546 #endif
41547 #endif
41548
41549 #if 0
41550 #define SWIGRUNTIME_DEBUG
41551 #endif
41552
41553 SWIGRUNTIME void
41554 SWIG_InitializeModule(void *clientdata) {
41555 size_t i;
41556 swig_module_info *module_head;
41557 static int init_run = 0;
41558
41559 clientdata = clientdata;
41560
41561 if (init_run) return;
41562 init_run = 1;
41563
41564 /* Initialize the swig_module */
41565 swig_module.type_initial = swig_type_initial;
41566 swig_module.cast_initial = swig_cast_initial;
41567
41568 /* Try and load any already created modules */
41569 module_head = SWIG_GetModule(clientdata);
41570 if (module_head) {
41571 swig_module.next = module_head->next;
41572 module_head->next = &swig_module;
41573 } else {
41574 /* This is the first module loaded */
41575 swig_module.next = &swig_module;
41576 SWIG_SetModule(clientdata, &swig_module);
41577 }
41578
41579 /* Now work on filling in swig_module.types */
41580 #ifdef SWIGRUNTIME_DEBUG
41581 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41582 #endif
41583 for (i = 0; i < swig_module.size; ++i) {
41584 swig_type_info *type = 0;
41585 swig_type_info *ret;
41586 swig_cast_info *cast;
41587
41588 #ifdef SWIGRUNTIME_DEBUG
41589 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41590 #endif
41591
41592 /* if there is another module already loaded */
41593 if (swig_module.next != &swig_module) {
41594 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41595 }
41596 if (type) {
41597 /* Overwrite clientdata field */
41598 #ifdef SWIGRUNTIME_DEBUG
41599 printf("SWIG_InitializeModule: found type %s\n", type->name);
41600 #endif
41601 if (swig_module.type_initial[i]->clientdata) {
41602 type->clientdata = swig_module.type_initial[i]->clientdata;
41603 #ifdef SWIGRUNTIME_DEBUG
41604 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41605 #endif
41606 }
41607 } else {
41608 type = swig_module.type_initial[i];
41609 }
41610
41611 /* Insert casting types */
41612 cast = swig_module.cast_initial[i];
41613 while (cast->type) {
41614 /* Don't need to add information already in the list */
41615 ret = 0;
41616 #ifdef SWIGRUNTIME_DEBUG
41617 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41618 #endif
41619 if (swig_module.next != &swig_module) {
41620 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41621 #ifdef SWIGRUNTIME_DEBUG
41622 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41623 #endif
41624 }
41625 if (ret) {
41626 if (type == swig_module.type_initial[i]) {
41627 #ifdef SWIGRUNTIME_DEBUG
41628 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41629 #endif
41630 cast->type = ret;
41631 ret = 0;
41632 } else {
41633 /* Check for casting already in the list */
41634 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41635 #ifdef SWIGRUNTIME_DEBUG
41636 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41637 #endif
41638 if (!ocast) ret = 0;
41639 }
41640 }
41641
41642 if (!ret) {
41643 #ifdef SWIGRUNTIME_DEBUG
41644 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41645 #endif
41646 if (type->cast) {
41647 type->cast->prev = cast;
41648 cast->next = type->cast;
41649 }
41650 type->cast = cast;
41651 }
41652 cast++;
41653 }
41654 /* Set entry in modules->types array equal to the type */
41655 swig_module.types[i] = type;
41656 }
41657 swig_module.types[i] = 0;
41658
41659 #ifdef SWIGRUNTIME_DEBUG
41660 printf("**** SWIG_InitializeModule: Cast List ******\n");
41661 for (i = 0; i < swig_module.size; ++i) {
41662 int j = 0;
41663 swig_cast_info *cast = swig_module.cast_initial[i];
41664 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41665 while (cast->type) {
41666 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41667 cast++;
41668 ++j;
41669 }
41670 printf("---- Total casts: %d\n",j);
41671 }
41672 printf("**** SWIG_InitializeModule: Cast List ******\n");
41673 #endif
41674 }
41675
41676 /* This function will propagate the clientdata field of type to
41677 * any new swig_type_info structures that have been added into the list
41678 * of equivalent types. It is like calling
41679 * SWIG_TypeClientData(type, clientdata) a second time.
41680 */
41681 SWIGRUNTIME void
41682 SWIG_PropagateClientData(void) {
41683 size_t i;
41684 swig_cast_info *equiv;
41685 static int init_run = 0;
41686
41687 if (init_run) return;
41688 init_run = 1;
41689
41690 for (i = 0; i < swig_module.size; i++) {
41691 if (swig_module.types[i]->clientdata) {
41692 equiv = swig_module.types[i]->cast;
41693 while (equiv) {
41694 if (!equiv->converter) {
41695 if (equiv->type && !equiv->type->clientdata)
41696 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41697 }
41698 equiv = equiv->next;
41699 }
41700 }
41701 }
41702 }
41703
41704 #ifdef __cplusplus
41705 #if 0
41706 {
41707 /* c-mode */
41708 #endif
41709 }
41710 #endif
41711
41712
41713
41714 #ifdef __cplusplus
41715 extern "C" {
41716 #endif
41717
41718 /* Python-specific SWIG API */
41719 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41720 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41721 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41722
41723 /* -----------------------------------------------------------------------------
41724 * global variable support code.
41725 * ----------------------------------------------------------------------------- */
41726
41727 typedef struct swig_globalvar {
41728 char *name; /* Name of global variable */
41729 PyObject *(*get_attr)(void); /* Return the current value */
41730 int (*set_attr)(PyObject *); /* Set the value */
41731 struct swig_globalvar *next;
41732 } swig_globalvar;
41733
41734 typedef struct swig_varlinkobject {
41735 PyObject_HEAD
41736 swig_globalvar *vars;
41737 } swig_varlinkobject;
41738
41739 SWIGINTERN PyObject *
41740 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41741 return PyString_FromString("<Swig global variables>");
41742 }
41743
41744 SWIGINTERN PyObject *
41745 swig_varlink_str(swig_varlinkobject *v) {
41746 PyObject *str = PyString_FromString("(");
41747 swig_globalvar *var;
41748 for (var = v->vars; var; var=var->next) {
41749 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41750 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41751 }
41752 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41753 return str;
41754 }
41755
41756 SWIGINTERN int
41757 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41758 PyObject *str = swig_varlink_str(v);
41759 fprintf(fp,"Swig global variables ");
41760 fprintf(fp,"%s\n", PyString_AsString(str));
41761 Py_DECREF(str);
41762 return 0;
41763 }
41764
41765 SWIGINTERN void
41766 swig_varlink_dealloc(swig_varlinkobject *v) {
41767 swig_globalvar *var = v->vars;
41768 while (var) {
41769 swig_globalvar *n = var->next;
41770 free(var->name);
41771 free(var);
41772 var = n;
41773 }
41774 }
41775
41776 SWIGINTERN PyObject *
41777 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41778 PyObject *res = NULL;
41779 swig_globalvar *var = v->vars;
41780 while (var) {
41781 if (strcmp(var->name,n) == 0) {
41782 res = (*var->get_attr)();
41783 break;
41784 }
41785 var = var->next;
41786 }
41787 if (res == NULL && !PyErr_Occurred()) {
41788 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41789 }
41790 return res;
41791 }
41792
41793 SWIGINTERN int
41794 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41795 int res = 1;
41796 swig_globalvar *var = v->vars;
41797 while (var) {
41798 if (strcmp(var->name,n) == 0) {
41799 res = (*var->set_attr)(p);
41800 break;
41801 }
41802 var = var->next;
41803 }
41804 if (res == 1 && !PyErr_Occurred()) {
41805 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41806 }
41807 return res;
41808 }
41809
41810 SWIGINTERN PyTypeObject*
41811 swig_varlink_type(void) {
41812 static char varlink__doc__[] = "Swig var link object";
41813 static PyTypeObject varlink_type;
41814 static int type_init = 0;
41815 if (!type_init) {
41816 const PyTypeObject tmp
41817 = {
41818 PyObject_HEAD_INIT(NULL)
41819 0, /* Number of items in variable part (ob_size) */
41820 (char *)"swigvarlink", /* Type name (tp_name) */
41821 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41822 0, /* Itemsize (tp_itemsize) */
41823 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41824 (printfunc) swig_varlink_print, /* Print (tp_print) */
41825 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41826 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41827 0, /* tp_compare */
41828 (reprfunc) swig_varlink_repr, /* tp_repr */
41829 0, /* tp_as_number */
41830 0, /* tp_as_sequence */
41831 0, /* tp_as_mapping */
41832 0, /* tp_hash */
41833 0, /* tp_call */
41834 (reprfunc)swig_varlink_str, /* tp_str */
41835 0, /* tp_getattro */
41836 0, /* tp_setattro */
41837 0, /* tp_as_buffer */
41838 0, /* tp_flags */
41839 varlink__doc__, /* tp_doc */
41840 0, /* tp_traverse */
41841 0, /* tp_clear */
41842 0, /* tp_richcompare */
41843 0, /* tp_weaklistoffset */
41844 #if PY_VERSION_HEX >= 0x02020000
41845 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41846 #endif
41847 #if PY_VERSION_HEX >= 0x02030000
41848 0, /* tp_del */
41849 #endif
41850 #ifdef COUNT_ALLOCS
41851 0,0,0,0 /* tp_alloc -> tp_next */
41852 #endif
41853 };
41854 varlink_type = tmp;
41855 varlink_type.ob_type = &PyType_Type;
41856 type_init = 1;
41857 }
41858 return &varlink_type;
41859 }
41860
41861 /* Create a variable linking object for use later */
41862 SWIGINTERN PyObject *
41863 SWIG_Python_newvarlink(void) {
41864 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41865 if (result) {
41866 result->vars = 0;
41867 }
41868 return ((PyObject*) result);
41869 }
41870
41871 SWIGINTERN void
41872 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41873 swig_varlinkobject *v = (swig_varlinkobject *) p;
41874 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41875 if (gv) {
41876 size_t size = strlen(name)+1;
41877 gv->name = (char *)malloc(size);
41878 if (gv->name) {
41879 strncpy(gv->name,name,size);
41880 gv->get_attr = get_attr;
41881 gv->set_attr = set_attr;
41882 gv->next = v->vars;
41883 }
41884 }
41885 v->vars = gv;
41886 }
41887
41888 SWIGINTERN PyObject *
41889 SWIG_globals() {
41890 static PyObject *_SWIG_globals = 0;
41891 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41892 return _SWIG_globals;
41893 }
41894
41895 /* -----------------------------------------------------------------------------
41896 * constants/methods manipulation
41897 * ----------------------------------------------------------------------------- */
41898
41899 /* Install Constants */
41900 SWIGINTERN void
41901 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41902 PyObject *obj = 0;
41903 size_t i;
41904 for (i = 0; constants[i].type; ++i) {
41905 switch(constants[i].type) {
41906 case SWIG_PY_POINTER:
41907 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41908 break;
41909 case SWIG_PY_BINARY:
41910 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41911 break;
41912 default:
41913 obj = 0;
41914 break;
41915 }
41916 if (obj) {
41917 PyDict_SetItemString(d, constants[i].name, obj);
41918 Py_DECREF(obj);
41919 }
41920 }
41921 }
41922
41923 /* -----------------------------------------------------------------------------*/
41924 /* Fix SwigMethods to carry the callback ptrs when needed */
41925 /* -----------------------------------------------------------------------------*/
41926
41927 SWIGINTERN void
41928 SWIG_Python_FixMethods(PyMethodDef *methods,
41929 swig_const_info *const_table,
41930 swig_type_info **types,
41931 swig_type_info **types_initial) {
41932 size_t i;
41933 for (i = 0; methods[i].ml_name; ++i) {
41934 const char *c = methods[i].ml_doc;
41935 if (c && (c = strstr(c, "swig_ptr: "))) {
41936 int j;
41937 swig_const_info *ci = 0;
41938 const char *name = c + 10;
41939 for (j = 0; const_table[j].type; ++j) {
41940 if (strncmp(const_table[j].name, name,
41941 strlen(const_table[j].name)) == 0) {
41942 ci = &(const_table[j]);
41943 break;
41944 }
41945 }
41946 if (ci) {
41947 size_t shift = (ci->ptype) - types;
41948 swig_type_info *ty = types_initial[shift];
41949 size_t ldoc = (c - methods[i].ml_doc);
41950 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41951 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41952 if (ndoc) {
41953 char *buff = ndoc;
41954 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41955 if (ptr) {
41956 strncpy(buff, methods[i].ml_doc, ldoc);
41957 buff += ldoc;
41958 strncpy(buff, "swig_ptr: ", 10);
41959 buff += 10;
41960 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41961 methods[i].ml_doc = ndoc;
41962 }
41963 }
41964 }
41965 }
41966 }
41967 }
41968
41969 #ifdef __cplusplus
41970 }
41971 #endif
41972
41973 /* -----------------------------------------------------------------------------*
41974 * Partial Init method
41975 * -----------------------------------------------------------------------------*/
41976
41977 #ifdef __cplusplus
41978 extern "C"
41979 #endif
41980 SWIGEXPORT void SWIG_init(void) {
41981 PyObject *m, *d;
41982
41983 /* Fix SwigMethods to carry the callback ptrs when needed */
41984 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41985
41986 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41987 d = PyModule_GetDict(m);
41988
41989 SWIG_InitializeModule(0);
41990 SWIG_InstallConstants(d,swig_const_table);
41991
41992
41993 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41994 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41995 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41996 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41997 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41998 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41999 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
42000 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
42001 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
42002 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
42003 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
42004 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
42005 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
42006 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
42007 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
42008 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
42009 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
42010 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
42011 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
42012 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
42013 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
42014 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
42015 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
42016 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
42017 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
42018 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
42019 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
42020 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
42021 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
42022 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
42023 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
42024 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
42025 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
42026 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
42027 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
42028 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
42029 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
42030 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
42031 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
42032 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
42033 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
42034 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
42035 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
42036 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
42037 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
42038 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
42039 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
42040 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
42041 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
42042 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
42043 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
42044 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
42045 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
42046 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
42047 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
42048 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
42049 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
42050 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
42051 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
42052 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
42053 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
42054 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
42055 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42056 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42057 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42058 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42059 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42060 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42061 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42062 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42063 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42064 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42065 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42066 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42067 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42068 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42069 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42070 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42071 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42072 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42073 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42074 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42075 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42076 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42077 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42078 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42079 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42080 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42081 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42082 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42083 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42084 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42085 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42086 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42087 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42088 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42089 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42090 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42091 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42092 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42093 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42094 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42095 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42096 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42097 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42098 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42099 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42100 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42101 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42102 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42103 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42104 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42105 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42106 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42107 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42108 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42109 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42110 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42111 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42112 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42113 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42114 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42115 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42116 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42117 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42118 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42119 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42120 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42121 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42122 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42123 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42124 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42125 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42126 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42127 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42128 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42129 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42130 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42131 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42132 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42133 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42134 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42135 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42136 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42137 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42138 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42139 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42140 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42141
42142 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42143
42144 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42145 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42146 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42147 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42148 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42149 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42150 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42151 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42152 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42153 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42154 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42155 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42156 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42157 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42158 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42159 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42160 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42161 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42162 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42163 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42164 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42165 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42166 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42167 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42168 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42169 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42170 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42171 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42172 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42173 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42174 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42175 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42176 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42177 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42178 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42179 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42180 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42181 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42182 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42183 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42184 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42185 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42186 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42187 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42188 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42189 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42190 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42191 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42192 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42193 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42194 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42195 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42196 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42197
42198 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42199
42200 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42201 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42202 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42203 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42204 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42205 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42206 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42207 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42208 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42209 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42210 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42211 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42212 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42213 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42214 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42215 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42216 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42217 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42218 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42219 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42220 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42221 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42222 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42223 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42224 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42225 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42226 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42227 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42240 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42241 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42242 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42243 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42244 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42245 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42246 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42247 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42248 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42249 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42250 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42251 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42252 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42253 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42254 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42255 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42256 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42257 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42258 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42259 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42260 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42261 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42262 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42263 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42264 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42265 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42266 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42267 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42268 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42269 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42270 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42271 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42272 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42273 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42274 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42275 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42276
42277 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42278
42279 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42280 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42281 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42282 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42283 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42284 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42285 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42286 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42287 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42288 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42289 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42290 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42291 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42292 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42293 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42294 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42295 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42296 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42297 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42298 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42299 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42300 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42301 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42302 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42303 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42304 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42305 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42306 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42307 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42308 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42309 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42310 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42311 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42312 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42313 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42314 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42315 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42316 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42317 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42318 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42319 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42320 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42321 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42322 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42323 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42324 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42325 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42326 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42327 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42328 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42329 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42330 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42331 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42332 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42333 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42334 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42335 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42336 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42337 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42338 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42339 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42340 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42341 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42342 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42343 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42344 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42345 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42346 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42347 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42348 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42349 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42350 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42351 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42352 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42353 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42354 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42355 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42356 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42357 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42358 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42359 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42360 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42361 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42362 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42363 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42364 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42365 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42366 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42367 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42368 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42369 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42370 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42371 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42372 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42373 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42374 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42375 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42376 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42377 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42378 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42379 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42380 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42381 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42382 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42383 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42384 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42385 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42386 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42387 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42388 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42389 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42390 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42391 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42392 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42393 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42394 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42395 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42396 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42397 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42398 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42399 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42400 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42401 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42402 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42403 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42404 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42405 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42406 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42407 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42408 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42409 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42410 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42411 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42412 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42413 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42414 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42415 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42416 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42417 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42418 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42419 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42420 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42421 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42422 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42423 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42424 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42425 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42426 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42427 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42428 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42429 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42430 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42431 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42432 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42433 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42434 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42435 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42436 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42437 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42438 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42439 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42440 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42441 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42442 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42443 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42444 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42445 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42446 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42447 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42448 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42449 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42450 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42451 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42452 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42453 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42454 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42455 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42456 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42457 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42458 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42459 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42460 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42461 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42462 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42463 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42464 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42465 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42466 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42467 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42468 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42469 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42470 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42471 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42472 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42473 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42474 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42475 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42476 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42477 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42478 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42479 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42480 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42481 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42482
42483 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42484 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42485 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42486 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42487
42488 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42489 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42490 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42491 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42492 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42493 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42494 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42495 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42496 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42497 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42498 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42499 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42500 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42501 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42502 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42503 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42504 }
42505
wxWidgets (Impactor)