]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:


0a6cc76cf3f11e0ebfd82fbb74fb6dac19c29445
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_unsigned_char swig_types[3]
2466 #define SWIGTYPE_p_unsigned_int swig_types[4]
2467 #define SWIGTYPE_p_unsigned_long swig_types[5]
2468 #define SWIGTYPE_p_void swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBitmap swig_types[12]
2475 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2476 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2477 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2478 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2480 #define SWIGTYPE_p_wxCaret swig_types[18]
2481 #define SWIGTYPE_p_wxChar swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboard swig_types[21]
2484 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2485 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2486 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2487 #define SWIGTYPE_p_wxColour swig_types[25]
2488 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2489 #define SWIGTYPE_p_wxConfig swig_types[27]
2490 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2491 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2492 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2493 #define SWIGTYPE_p_wxControl swig_types[31]
2494 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2495 #define SWIGTYPE_p_wxCursor swig_types[33]
2496 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2497 #define SWIGTYPE_p_wxDC swig_types[35]
2498 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2499 #define SWIGTYPE_p_wxDataObject swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2501 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2502 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2503 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime swig_types[42]
2505 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2506 #define SWIGTYPE_p_wxDisplay swig_types[44]
2507 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2509 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2510 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvent swig_types[49]
2512 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2513 #define SWIGTYPE_p_wxFSFile swig_types[51]
2514 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2515 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2516 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2517 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2518 #define SWIGTYPE_p_wxFileType swig_types[56]
2519 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2520 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2521 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2522 #define SWIGTYPE_p_wxFont swig_types[60]
2523 #define SWIGTYPE_p_wxFrame swig_types[61]
2524 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2525 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2526 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2527 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2528 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2529 #define SWIGTYPE_p_wxIcon swig_types[67]
2530 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2532 #define SWIGTYPE_p_wxImage swig_types[70]
2533 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2534 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2535 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2536 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2537 #define SWIGTYPE_p_wxJoystick swig_types[75]
2538 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2540 #define SWIGTYPE_p_wxKillError swig_types[78]
2541 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2542 #define SWIGTYPE_p_wxLog swig_types[80]
2543 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2544 #define SWIGTYPE_p_wxLogChain swig_types[82]
2545 #define SWIGTYPE_p_wxLogGui swig_types[83]
2546 #define SWIGTYPE_p_wxLogNull swig_types[84]
2547 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2548 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2549 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2550 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2551 #define SWIGTYPE_p_wxMemorySize swig_types[89]
2552 #define SWIGTYPE_p_wxMenu swig_types[90]
2553 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2554 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2555 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2556 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2557 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2558 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2560 #define SWIGTYPE_p_wxMouseState swig_types[98]
2561 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2563 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2566 #define SWIGTYPE_p_wxObject swig_types[104]
2567 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2568 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2573 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2574 #define SWIGTYPE_p_wxPoint swig_types[112]
2575 #define SWIGTYPE_p_wxProcessEvent swig_types[113]
2576 #define SWIGTYPE_p_wxPyApp swig_types[114]
2577 #define SWIGTYPE_p_wxPyArtProvider swig_types[115]
2578 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[116]
2579 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
2580 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[118]
2581 #define SWIGTYPE_p_wxPyDropSource swig_types[119]
2582 #define SWIGTYPE_p_wxPyDropTarget swig_types[120]
2583 #define SWIGTYPE_p_wxPyEvent swig_types[121]
2584 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[122]
2585 #define SWIGTYPE_p_wxPyImageHandler swig_types[123]
2586 #define SWIGTYPE_p_wxPyLog swig_types[124]
2587 #define SWIGTYPE_p_wxPyProcess swig_types[125]
2588 #define SWIGTYPE_p_wxPySizer swig_types[126]
2589 #define SWIGTYPE_p_wxPyTextDataObject swig_types[127]
2590 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[128]
2591 #define SWIGTYPE_p_wxPyTimer swig_types[129]
2592 #define SWIGTYPE_p_wxPyTipProvider swig_types[130]
2593 #define SWIGTYPE_p_wxPyValidator swig_types[131]
2594 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[132]
2595 #define SWIGTYPE_p_wxRect swig_types[133]
2596 #define SWIGTYPE_p_wxScrollEvent swig_types[134]
2597 #define SWIGTYPE_p_wxScrollWinEvent swig_types[135]
2598 #define SWIGTYPE_p_wxSetCursorEvent swig_types[136]
2599 #define SWIGTYPE_p_wxShowEvent swig_types[137]
2600 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[138]
2601 #define SWIGTYPE_p_wxSize swig_types[139]
2602 #define SWIGTYPE_p_wxSizeEvent swig_types[140]
2603 #define SWIGTYPE_p_wxSizer swig_types[141]
2604 #define SWIGTYPE_p_wxSizerItem swig_types[142]
2605 #define SWIGTYPE_p_wxSound swig_types[143]
2606 #define SWIGTYPE_p_wxStandardPaths swig_types[144]
2607 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[145]
2608 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[146]
2609 #define SWIGTYPE_p_wxStopWatch swig_types[147]
2610 #define SWIGTYPE_p_wxString swig_types[148]
2611 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[149]
2612 #define SWIGTYPE_p_wxSystemOptions swig_types[150]
2613 #define SWIGTYPE_p_wxSystemSettings swig_types[151]
2614 #define SWIGTYPE_p_wxTIFFHandler swig_types[152]
2615 #define SWIGTYPE_p_wxTextCtrl swig_types[153]
2616 #define SWIGTYPE_p_wxTextDataObject swig_types[154]
2617 #define SWIGTYPE_p_wxTimeSpan swig_types[155]
2618 #define SWIGTYPE_p_wxTimer swig_types[156]
2619 #define SWIGTYPE_p_wxTimerEvent swig_types[157]
2620 #define SWIGTYPE_p_wxTimerRunner swig_types[158]
2621 #define SWIGTYPE_p_wxTipProvider swig_types[159]
2622 #define SWIGTYPE_p_wxToolTip swig_types[160]
2623 #define SWIGTYPE_p_wxURLDataObject swig_types[161]
2624 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[162]
2625 #define SWIGTYPE_p_wxValidator swig_types[163]
2626 #define SWIGTYPE_p_wxVideoMode swig_types[164]
2627 #define SWIGTYPE_p_wxWindow swig_types[165]
2628 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[166]
2629 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[167]
2630 #define SWIGTYPE_p_wxWindowDisabler swig_types[168]
2631 #define SWIGTYPE_p_wxXPMHandler swig_types[169]
2632 static swig_type_info *swig_types[171];
2633 static swig_module_info swig_module = {swig_types, 170, 0, 0, 0, 0};
2634 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2635 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2636
2637 /* -------- TYPES TABLE (END) -------- */
2638
2639 #if (PY_VERSION_HEX <= 0x02000000)
2640 # if !defined(SWIG_PYTHON_CLASSIC)
2641 # error "This python version requires to use swig with the '-classic' option"
2642 # endif
2643 #endif
2644 #if (PY_VERSION_HEX <= 0x02020000)
2645 # error "This python version requires to use swig with the '-nomodern' option"
2646 #endif
2647 #if (PY_VERSION_HEX <= 0x02020000)
2648 # error "This python version requires to use swig with the '-nomodernargs' option"
2649 #endif
2650 #ifndef METH_O
2651 # error "This python version requires to use swig with the '-nofastunpack' option"
2652 #endif
2653
2654 /*-----------------------------------------------
2655 @(target):= _misc_.so
2656 ------------------------------------------------*/
2657 #define SWIG_init init_misc_
2658
2659 #define SWIG_name "_misc_"
2660
2661 #define SWIGVERSION 0x010329
2662
2663
2664 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2665 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2666
2667
2668 #include <stdexcept>
2669
2670
2671 namespace swig {
2672 class PyObject_ptr {
2673 protected:
2674 PyObject *_obj;
2675
2676 public:
2677 PyObject_ptr() :_obj(0)
2678 {
2679 }
2680
2681 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2682 {
2683 Py_XINCREF(_obj);
2684 }
2685
2686 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2687 {
2688 if (initial_ref) Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr & operator=(const PyObject_ptr& item)
2692 {
2693 Py_XINCREF(item._obj);
2694 Py_XDECREF(_obj);
2695 _obj = item._obj;
2696 return *this;
2697 }
2698
2699 ~PyObject_ptr()
2700 {
2701 Py_XDECREF(_obj);
2702 }
2703
2704 operator PyObject *() const
2705 {
2706 return _obj;
2707 }
2708
2709 PyObject *operator->() const
2710 {
2711 return _obj;
2712 }
2713 };
2714 }
2715
2716
2717 namespace swig {
2718 struct PyObject_var : PyObject_ptr {
2719 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2720
2721 PyObject_var & operator = (PyObject* obj)
2722 {
2723 Py_XDECREF(_obj);
2724 _obj = obj;
2725 return *this;
2726 }
2727 };
2728 }
2729
2730
2731 #include "wx/wxPython/wxPython.h"
2732 #include "wx/wxPython/pyclasses.h"
2733 #include "wx/wxPython/pyistream.h"
2734
2735 static const wxString wxPyEmptyString(wxEmptyString);
2736
2737
2738
2739 #define SWIG_From_long PyInt_FromLong
2740
2741
2742 SWIGINTERNINLINE PyObject *
2743 SWIG_From_int (int value)
2744 {
2745 return SWIG_From_long (value);
2746 }
2747
2748
2749 #include <limits.h>
2750 #ifndef LLONG_MIN
2751 # define LLONG_MIN LONG_LONG_MIN
2752 #endif
2753 #ifndef LLONG_MAX
2754 # define LLONG_MAX LONG_LONG_MAX
2755 #endif
2756 #ifndef ULLONG_MAX
2757 # define ULLONG_MAX ULONG_LONG_MAX
2758 #endif
2759
2760
2761 SWIGINTERN int
2762 SWIG_AsVal_long (PyObject* obj, long* val)
2763 {
2764 if (PyNumber_Check(obj)) {
2765 if (val) *val = PyInt_AsLong(obj);
2766 return SWIG_OK;
2767 }
2768 return SWIG_TypeError;
2769 }
2770
2771
2772 SWIGINTERN int
2773 SWIG_AsVal_int (PyObject * obj, int *val)
2774 {
2775 long v;
2776 int res = SWIG_AsVal_long (obj, &v);
2777 if (SWIG_IsOK(res)) {
2778 if ((v < INT_MIN || v > INT_MAX)) {
2779 return SWIG_OverflowError;
2780 } else {
2781 if (val) *val = static_cast< int >(v);
2782 }
2783 }
2784 return res;
2785 }
2786
2787 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2788
2789 #include <wx/stockitem.h>
2790
2791 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2792 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2793 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2794
2795 SWIGINTERN int
2796 SWIG_AsVal_bool (PyObject *obj, bool *val)
2797 {
2798 if (obj == Py_True) {
2799 if (val) *val = true;
2800 return SWIG_OK;
2801 } else if (obj == Py_False) {
2802 if (val) *val = false;
2803 return SWIG_OK;
2804 } else {
2805 long v = 0;
2806 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2807 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2808 return res;
2809 }
2810 }
2811
2812
2813 wxMemorySize wxGetFreeMemory()
2814 { wxPyRaiseNotImplemented(); return 0; }
2815
2816
2817 SWIGINTERN int
2818 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2819 {
2820 long v = 0;
2821 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2822 return SWIG_TypeError;
2823 }
2824 else if (val)
2825 *val = (unsigned long)v;
2826 return SWIG_OK;
2827 }
2828
2829
2830 SWIGINTERNINLINE PyObject*
2831 SWIG_From_unsigned_SS_long (unsigned long value)
2832 {
2833 return (value > LONG_MAX) ?
2834 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2835 }
2836
2837
2838 void* wxGetXDisplay()
2839 {
2840 #ifdef __WXGTK__
2841 return wxGetDisplay();
2842 #else
2843 return NULL;
2844 #endif
2845 }
2846
2847
2848 wxWindow* FindWindowAtPointer() {
2849 wxPoint unused;
2850 return wxFindWindowAtPointer(unused);
2851 }
2852
2853
2854 void wxWakeUpMainThread() {}
2855
2856
2857 bool wxThread_IsMain() {
2858 #ifdef WXP_WITH_THREAD
2859 return wxThread::IsMain();
2860 #else
2861 return true;
2862 #endif
2863 }
2864
2865 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2866 delete self;
2867 }
2868
2869 #include <wx/snglinst.h>
2870
2871
2872 #ifdef __WXMSW__
2873 #include <wx/msw/private.h>
2874 #include <wx/dynload.h>
2875 #endif
2876
2877
2878
2879 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2880 #if 0
2881 , int method
2882 #endif
2883 )
2884 {
2885 #ifdef __WXMSW__
2886 #if 0
2887 switch (method)
2888 {
2889 case 1:
2890 // This one only partially works. Appears to be an undocumented
2891 // "standard" convention that not all widgets adhear to. For
2892 // example, for some widgets backgrounds or non-client areas may
2893 // not be painted.
2894 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2895 break;
2896
2897 case 2:
2898 #endif
2899 // This one works much better, nearly all widgets and their
2900 // children are captured correctly[**]. Prior to the big
2901 // background erase changes that Vadim did in 2004-2005 this
2902 // method failed badly on XP with Themes activated, most native
2903 // widgets draw only partially, if at all. Without themes it
2904 // worked just like on Win2k. After those changes this method
2905 // works very well.
2906 //
2907 // ** For example the radio buttons in a wxRadioBox are not its
2908 // children by default, but you can capture it via the panel
2909 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2910 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2911 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2912 PRF_ERASEBKGND | PRF_OWNED );
2913 return true;
2914 #if 0
2915 break;
2916
2917 case 3:
2918 // This one is only defined in the latest SDK and is only
2919 // available on XP. MSDN says it is similar to sending WM_PRINT
2920 // so I expect that it will work similar to the above. Since it
2921 // is avaialble only on XP, it can't be compiled like this and
2922 // will have to be loaded dynamically.
2923 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2924
2925 // fall through
2926
2927 case 4:
2928 // Use PrintWindow if available, or fallback to WM_PRINT
2929 // otherwise. Unfortunately using PrintWindow is even worse than
2930 // WM_PRINT. For most native widgets nothing is drawn to the dc
2931 // at all, with or without Themes.
2932 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2933 static bool s_triedToLoad = false;
2934 static PrintWindow_t pfnPrintWindow = NULL;
2935 if ( !s_triedToLoad )
2936 {
2937
2938 s_triedToLoad = true;
2939 wxDynamicLibrary dllUser32(_T("user32.dll"));
2940 if ( dllUser32.IsLoaded() )
2941 {
2942 wxLogNull nolog; // Don't report errors here
2943 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2944 }
2945 }
2946 if (pfnPrintWindow)
2947 {
2948 //printf("Using PrintWindow\n");
2949 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2950 }
2951 else
2952 {
2953 //printf("Using WM_PRINT\n");
2954 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2955 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2956 PRF_ERASEBKGND | PRF_OWNED );
2957 }
2958 }
2959 #endif // 0
2960 #else
2961 return false;
2962 #endif // __WXMSW__
2963 }
2964
2965
2966
2967 #include <wx/tipdlg.h>
2968
2969
2970 SWIGINTERNINLINE PyObject *
2971 SWIG_From_size_t (size_t value)
2972 {
2973 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2974 }
2975
2976
2977 class wxPyTipProvider : public wxTipProvider {
2978 public:
2979 wxPyTipProvider(size_t currentTip)
2980 : wxTipProvider(currentTip) {}
2981
2982 DEC_PYCALLBACK_STRING__pure(GetTip);
2983 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2984 PYPRIVATE;
2985 };
2986
2987 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2988 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2989
2990
2991 SWIGINTERNINLINE int
2992 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2993 {
2994 unsigned long v;
2995 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2996 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2997 return res;
2998 }
2999
3000
3001 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3002
3003 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3004
3005 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3006 : wxTimer(owner, id)
3007 {
3008 if (owner == NULL)
3009 SetOwner(this);
3010 }
3011
3012
3013 SWIGINTERN swig_type_info*
3014 SWIG_pchar_descriptor()
3015 {
3016 static int init = 0;
3017 static swig_type_info* info = 0;
3018 if (!init) {
3019 info = SWIG_TypeQuery("_p_char");
3020 init = 1;
3021 }
3022 return info;
3023 }
3024
3025
3026 SWIGINTERNINLINE PyObject *
3027 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3028 {
3029 if (carray) {
3030 if (size > INT_MAX) {
3031 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3032 return pchar_descriptor ?
3033 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3034 } else {
3035 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3036 }
3037 } else {
3038 return SWIG_Py_Void();
3039 }
3040 }
3041
3042
3043 SWIGINTERNINLINE PyObject *
3044 SWIG_FromCharPtr(const char *cptr)
3045 {
3046 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3047 }
3048
3049
3050 SWIGINTERN int
3051 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3052 {
3053 unsigned long v;
3054 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3055 if (SWIG_IsOK(res)) {
3056 if ((v > UINT_MAX)) {
3057 return SWIG_OverflowError;
3058 } else {
3059 if (val) *val = static_cast< unsigned int >(v);
3060 }
3061 }
3062 return res;
3063 }
3064
3065 SWIGINTERN wxString wxLog_TimeStamp(){
3066 wxString msg;
3067 wxLog::TimeStamp(&msg);
3068 return msg;
3069 }
3070 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3071 // Make some wrappers that double any % signs so they are 'escaped'
3072 void wxPyLogFatalError(const wxString& msg)
3073 {
3074 wxString m(msg);
3075 m.Replace(wxT("%"), wxT("%%"));
3076 wxLogFatalError(m);
3077 }
3078
3079 void wxPyLogError(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogError(m);
3084 }
3085
3086 void wxPyLogWarning(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogWarning(m);
3091 }
3092
3093 void wxPyLogMessage(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogMessage(m);
3098 }
3099
3100 void wxPyLogInfo(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogInfo(m);
3105 }
3106
3107 void wxPyLogDebug(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogDebug(m);
3112 }
3113
3114 void wxPyLogVerbose(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogVerbose(m);
3119 }
3120
3121 void wxPyLogStatus(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogStatus(m);
3126 }
3127
3128 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogStatus(pFrame, m);
3133 }
3134
3135 void wxPyLogSysError(const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogSysError(m);
3140 }
3141
3142 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogGeneric(level, m);
3147 }
3148
3149 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogTrace(mask, m);
3154 }
3155
3156 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogTrace(mask, m);
3161 }
3162
3163
3164
3165 // A wxLog class that can be derived from in wxPython
3166 class wxPyLog : public wxLog {
3167 public:
3168 wxPyLog() : wxLog() {}
3169
3170 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3171 bool found;
3172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3174 PyObject* s = wx2PyString(szString);
3175 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3176 Py_DECREF(s);
3177 }
3178 wxPyEndBlockThreads(blocked);
3179 if (! found)
3180 wxLog::DoLog(level, szString, t);
3181 }
3182
3183 virtual void DoLogString(const wxChar *szString, time_t t) {
3184 bool found;
3185 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3186 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3187 PyObject* s = wx2PyString(szString);
3188 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3189 Py_DECREF(s);
3190 }
3191 wxPyEndBlockThreads(blocked);
3192 if (! found)
3193 wxLog::DoLogString(szString, t);
3194 }
3195
3196 DEC_PYCALLBACK_VOID_(Flush);
3197 PYPRIVATE;
3198 };
3199 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3200
3201
3202
3203
3204 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3205
3206
3207 #include <wx/joystick.h>
3208
3209
3210 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3211 // A C++ stub class for wxJoystick for platforms that don't have it.
3212 class wxJoystick : public wxObject {
3213 public:
3214 wxJoystick(int joystick = wxJOYSTICK1) {
3215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3216 PyErr_SetString(PyExc_NotImplementedError,
3217 "wxJoystick is not available on this platform.");
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 wxPoint GetPosition() { return wxPoint(-1,-1); }
3221 int GetZPosition() { return -1; }
3222 int GetButtonState() { return -1; }
3223 int GetPOVPosition() { return -1; }
3224 int GetPOVCTSPosition() { return -1; }
3225 int GetRudderPosition() { return -1; }
3226 int GetUPosition() { return -1; }
3227 int GetVPosition() { return -1; }
3228 int GetMovementThreshold() { return -1; }
3229 void SetMovementThreshold(int threshold) {}
3230
3231 bool IsOk(void) { return false; }
3232 int GetNumberJoysticks() { return -1; }
3233 int GetManufacturerId() { return -1; }
3234 int GetProductId() { return -1; }
3235 wxString GetProductName() { return wxEmptyString; }
3236 int GetXMin() { return -1; }
3237 int GetYMin() { return -1; }
3238 int GetZMin() { return -1; }
3239 int GetXMax() { return -1; }
3240 int GetYMax() { return -1; }
3241 int GetZMax() { return -1; }
3242 int GetNumberButtons() { return -1; }
3243 int GetNumberAxes() { return -1; }
3244 int GetMaxButtons() { return -1; }
3245 int GetMaxAxes() { return -1; }
3246 int GetPollingMin() { return -1; }
3247 int GetPollingMax() { return -1; }
3248 int GetRudderMin() { return -1; }
3249 int GetRudderMax() { return -1; }
3250 int GetUMin() { return -1; }
3251 int GetUMax() { return -1; }
3252 int GetVMin() { return -1; }
3253 int GetVMax() { return -1; }
3254
3255 bool HasRudder() { return false; }
3256 bool HasZ() { return false; }
3257 bool HasU() { return false; }
3258 bool HasV() { return false; }
3259 bool HasPOV() { return false; }
3260 bool HasPOV4Dir() { return false; }
3261 bool HasPOVCTS() { return false; }
3262
3263 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3264 bool ReleaseCapture() { return false; }
3265 };
3266 #endif
3267
3268
3269 #include <wx/sound.h>
3270
3271
3272 #if !wxUSE_SOUND
3273 // A C++ stub class for wxWave for platforms that don't have it.
3274 class wxSound : public wxObject
3275 {
3276 public:
3277 wxSound() {
3278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3279 PyErr_SetString(PyExc_NotImplementedError,
3280 "wxSound is not available on this platform.");
3281 wxPyEndBlockThreads(blocked);
3282 }
3283 wxSound(const wxString&/*, bool*/) {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289 wxSound(int, const wxByte*) {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295
3296 ~wxSound() {};
3297
3298 bool Create(const wxString&/*, bool*/) { return false; }
3299 bool Create(int, const wxByte*) { return false; };
3300 bool IsOk() { return false; };
3301 bool Play(unsigned) const { return false; }
3302 static bool Play(const wxString&, unsigned) { return false; }
3303 static void Stop() {}
3304 };
3305
3306 #endif
3307
3308 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3309 if (fileName.Length() == 0)
3310 return new wxSound;
3311 else
3312 return new wxSound(fileName);
3313 }
3314 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3315 unsigned char* buffer; int size;
3316 wxSound *sound = NULL;
3317
3318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3319 if (!PyArg_Parse(data, "t#", &buffer, &size))
3320 goto done;
3321 sound = new wxSound(size, buffer);
3322 done:
3323 wxPyEndBlockThreads(blocked);
3324 return sound;
3325 }
3326 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3327 #ifndef __WXMAC__
3328 unsigned char* buffer;
3329 int size;
3330 bool rv = false;
3331
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (!PyArg_Parse(data, "t#", &buffer, &size))
3334 goto done;
3335 rv = self->Create(size, buffer);
3336 done:
3337 wxPyEndBlockThreads(blocked);
3338 return rv;
3339 #else
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 PyErr_SetString(PyExc_NotImplementedError,
3342 "Create from data is not available on this platform.");
3343 wxPyEndBlockThreads(blocked);
3344 return false;
3345 #endif
3346 }
3347
3348 #include <wx/mimetype.h>
3349
3350 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3351 wxString str;
3352 if (self->GetMimeType(&str))
3353 return wx2PyString(str);
3354 else
3355 RETURN_NONE();
3356 }
3357 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3358 wxArrayString arr;
3359 if (self->GetMimeTypes(arr))
3360 return wxArrayString2PyList_helper(arr);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3365 wxArrayString arr;
3366 if (self->GetExtensions(arr))
3367 return wxArrayString2PyList_helper(arr);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3372 wxIconLocation loc;
3373 if (self->GetIcon(&loc))
3374 return new wxIcon(loc);
3375 else
3376 return NULL;
3377 }
3378 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3379 wxIconLocation loc;
3380 if (self->GetIcon(&loc)) {
3381 wxString iconFile = loc.GetFileName();
3382 int iconIndex = -1;
3383
3384
3385
3386 // Make a tuple and put the values in it
3387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3388 PyObject* tuple = PyTuple_New(3);
3389 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3390 wxT("wxIcon"), true));
3391 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3392 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3393 wxPyEndBlockThreads(blocked);
3394 return tuple;
3395 }
3396 else
3397 RETURN_NONE();
3398 }
3399 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3400 wxString str;
3401 if (self->GetDescription(&str))
3402 return wx2PyString(str);
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3407 wxString str;
3408 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxString str;
3415 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxArrayString verbs;
3422 wxArrayString commands;
3423 if (self->GetAllCommands(&verbs, &commands,
3424 wxFileType::MessageParameters(filename, mimetype))) {
3425 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3426 PyObject* tuple = PyTuple_New(2);
3427 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3428 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3429 wxPyEndBlockThreads(blocked);
3430 return tuple;
3431 }
3432 else
3433 RETURN_NONE();
3434 }
3435 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3436 return wxFileType::ExpandCommand(command,
3437 wxFileType::MessageParameters(filename, mimetype));
3438 }
3439 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3440 wxArrayString arr;
3441 self->EnumAllFileTypes(arr);
3442 return wxArrayString2PyList_helper(arr);
3443 }
3444
3445 #include <wx/artprov.h>
3446
3447 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3448 static const wxString wxPyART_MENU(wxART_MENU);
3449 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3450 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3451 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3452 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3453 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3454 static const wxString wxPyART_OTHER(wxART_OTHER);
3455 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3456 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3457 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3458 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3459 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3460 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3461 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3462 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3463 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3464 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3465 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3466 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3467 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3468 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3469 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3470 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3471 static const wxString wxPyART_PRINT(wxART_PRINT);
3472 static const wxString wxPyART_HELP(wxART_HELP);
3473 static const wxString wxPyART_TIP(wxART_TIP);
3474 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3475 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3476 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3477 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3478 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3479 static const wxString wxPyART_CDROM(wxART_CDROM);
3480 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3481 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3482 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3483 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3484 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3485 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3486 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3487 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3488 static const wxString wxPyART_ERROR(wxART_ERROR);
3489 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3490 static const wxString wxPyART_WARNING(wxART_WARNING);
3491 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3492 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3493 static const wxString wxPyART_COPY(wxART_COPY);
3494 static const wxString wxPyART_CUT(wxART_CUT);
3495 static const wxString wxPyART_PASTE(wxART_PASTE);
3496 static const wxString wxPyART_DELETE(wxART_DELETE);
3497 static const wxString wxPyART_NEW(wxART_NEW);
3498 static const wxString wxPyART_UNDO(wxART_UNDO);
3499 static const wxString wxPyART_REDO(wxART_REDO);
3500 static const wxString wxPyART_QUIT(wxART_QUIT);
3501 static const wxString wxPyART_FIND(wxART_FIND);
3502 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3503 // Python aware wxArtProvider
3504 class wxPyArtProvider : public wxArtProvider {
3505 public:
3506
3507 virtual wxBitmap CreateBitmap(const wxArtID& id,
3508 const wxArtClient& client,
3509 const wxSize& size) {
3510 wxBitmap rval = wxNullBitmap;
3511 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3512 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3513 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3514 PyObject* ro;
3515 wxBitmap* ptr;
3516 PyObject* s1, *s2;
3517 s1 = wx2PyString(id);
3518 s2 = wx2PyString(client);
3519 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3520 Py_DECREF(so);
3521 Py_DECREF(s1);
3522 Py_DECREF(s2);
3523 if (ro) {
3524 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3525 rval = *ptr;
3526 Py_DECREF(ro);
3527 }
3528 }
3529 wxPyEndBlockThreads(blocked);
3530 return rval;
3531 }
3532
3533 PYPRIVATE;
3534 };
3535
3536 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3537
3538
3539
3540 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3541 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3542 PyObject* ret = PyTuple_New(3);
3543 if (ret) {
3544 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3545 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3546 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3547 }
3548 wxPyEndBlockThreads(blocked);
3549 return ret;
3550 }
3551
3552 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3553 bool cont;
3554 long index = 0;
3555 wxString value;
3556
3557 cont = self->GetFirstGroup(value, index);
3558 return __EnumerationHelper(cont, value, index);
3559 }
3560 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3561 bool cont;
3562 wxString value;
3563
3564 cont = self->GetNextGroup(value, index);
3565 return __EnumerationHelper(cont, value, index);
3566 }
3567 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3568 bool cont;
3569 long index = 0;
3570 wxString value;
3571
3572 cont = self->GetFirstEntry(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3576 bool cont;
3577 wxString value;
3578
3579 cont = self->GetNextEntry(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3583 long rv;
3584 self->Read(key, &rv, defaultVal);
3585 return rv;
3586 }
3587
3588 SWIGINTERN int
3589 SWIG_AsVal_double (PyObject *obj, double* val)
3590 {
3591 if (PyNumber_Check(obj)) {
3592 if (val) *val = PyFloat_AsDouble(obj);
3593 return SWIG_OK;
3594 }
3595 return SWIG_TypeError;
3596 }
3597
3598 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3599 double rv;
3600 self->Read(key, &rv, defaultVal);
3601 return rv;
3602 }
3603
3604 #define SWIG_From_double PyFloat_FromDouble
3605
3606 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3607 bool rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #include <wx/datetime.h>
3613
3614 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3615 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3616
3617 #define LOCAL_TZ wxDateTime::Local
3618
3619 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3620 wxString am;
3621 wxString pm;
3622 wxDateTime::GetAmPmStrings(&am, &pm);
3623 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3624 PyObject* tup = PyTuple_New(2);
3625 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3626 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3627 wxPyEndBlockThreads(blocked);
3628 return tup;
3629 }
3630
3631 SWIGINTERNINLINE PyObject *
3632 SWIG_From_unsigned_SS_int (unsigned int value)
3633 {
3634 return SWIG_From_unsigned_SS_long (value);
3635 }
3636
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3639 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3642 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3643 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3644 return (*self < *other);
3645 }
3646 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3647 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3648 return (*self <= *other);
3649 }
3650 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3652 return (*self > *other);
3653 }
3654 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3656 return (*self >= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3660 return (*self == *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3664 return (*self != *other);
3665 }
3666 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3667 const wxChar* rv;
3668 const wxChar* _date = date;
3669 rv = self->ParseRfc822Date(_date);
3670 if (rv == NULL) return -1;
3671 return rv - _date;
3672 }
3673 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3674 const wxChar* rv;
3675 const wxChar* _date = date;
3676 rv = self->ParseFormat(_date, format, dateDef);
3677 if (rv == NULL) return -1;
3678 return rv - _date;
3679 }
3680 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3681 const wxChar* rv;
3682 const wxChar* _datetime = datetime;
3683 rv = self->ParseDateTime(_datetime);
3684 if (rv == NULL) return -1;
3685 return rv - _datetime;
3686 }
3687 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3688 const wxChar* rv;
3689 const wxChar* _date = date;
3690 rv = self->ParseDate(_date);
3691 if (rv == NULL) return -1;
3692 return rv - _date;
3693 }
3694 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3695 const wxChar* rv;
3696 const wxChar* _time = time;
3697 rv = self->ParseTime(_time);
3698 if (rv == NULL) return -1;
3699 return rv - _time;
3700 }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3705 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3710 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3711 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3714 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3715 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3716 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3717
3718 #include <wx/dataobj.h>
3719
3720 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3721 size_t count = self->GetFormatCount(dir);
3722 wxDataFormat* formats = new wxDataFormat[count];
3723 self->GetAllFormats(formats, dir);
3724
3725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3726 PyObject* list = PyList_New(count);
3727 for (size_t i=0; i<count; i++) {
3728 wxDataFormat* format = new wxDataFormat(formats[i]);
3729 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3730 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 delete [] formats;
3734 return list;
3735 }
3736 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3737 PyObject* rval = NULL;
3738 size_t size = self->GetDataSize(format);
3739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3740 if (size) {
3741 char* buf = new char[size];
3742 if (self->GetDataHere(format, buf))
3743 rval = PyString_FromStringAndSize(buf, size);
3744 delete [] buf;
3745 }
3746 if (! rval) {
3747 rval = Py_None;
3748 Py_INCREF(rval);
3749 }
3750 wxPyEndBlockThreads(blocked);
3751 return rval;
3752 }
3753 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3754 bool rval;
3755 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3756 if (PyString_Check(data)) {
3757 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3758 }
3759 else {
3760 // raise a TypeError if not a string
3761 PyErr_SetString(PyExc_TypeError, "String expected.");
3762 rval = false;
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return rval;
3766 }
3767 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3768 PyObject* rval = NULL;
3769 size_t size = self->GetDataSize();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 if (size) {
3772 char* buf = new char[size];
3773 if (self->GetDataHere(buf))
3774 rval = PyString_FromStringAndSize(buf, size);
3775 delete [] buf;
3776 }
3777 if (! rval) {
3778 rval = Py_None;
3779 Py_INCREF(rval);
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return rval;
3783 }
3784 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3785 bool rval;
3786 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3787 if (PyString_Check(data)) {
3788 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3789 }
3790 else {
3791 // raise a TypeError if not a string
3792 PyErr_SetString(PyExc_TypeError, "String expected.");
3793 rval = false;
3794 }
3795 wxPyEndBlockThreads(blocked);
3796 return rval;
3797 }
3798 // Create a new class for wxPython to use
3799 class wxPyDataObjectSimple : public wxDataObjectSimple {
3800 public:
3801 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3802 : wxDataObjectSimple(format) {}
3803
3804 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3805 bool GetDataHere(void *buf) const;
3806 bool SetData(size_t len, const void *buf) const;
3807 PYPRIVATE;
3808 };
3809
3810 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3811
3812 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3813 // We need to get the data for this object and write it to buf. I think
3814 // the best way to do this for wxPython is to have the Python method
3815 // return either a string or None and then act appropriately with the
3816 // C++ version.
3817
3818 bool rval = false;
3819 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3820 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3821 PyObject* ro;
3822 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3823 if (ro) {
3824 rval = (ro != Py_None && PyString_Check(ro));
3825 if (rval)
3826 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3827 Py_DECREF(ro);
3828 }
3829 }
3830 wxPyEndBlockThreads(blocked);
3831 return rval;
3832 }
3833
3834 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3835 // For this one we simply need to make a string from buf and len
3836 // and send it to the Python method.
3837 bool rval = false;
3838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3839 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3840 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3841 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3842 Py_DECREF(data);
3843 }
3844 wxPyEndBlockThreads(blocked);
3845 return rval;
3846 }
3847
3848 // Create a new class for wxPython to use
3849 class wxPyTextDataObject : public wxTextDataObject {
3850 public:
3851 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3852 : wxTextDataObject(text) {}
3853
3854 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3855 DEC_PYCALLBACK_STRING__const(GetText);
3856 DEC_PYCALLBACK__STRING(SetText);
3857 PYPRIVATE;
3858 };
3859
3860 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3861 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3862 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3863
3864
3865 // Create a new class for wxPython to use
3866 class wxPyBitmapDataObject : public wxBitmapDataObject {
3867 public:
3868 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3869 : wxBitmapDataObject(bitmap) {}
3870
3871 wxBitmap GetBitmap() const;
3872 void SetBitmap(const wxBitmap& bitmap);
3873 PYPRIVATE;
3874 };
3875
3876 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3877 wxBitmap* rval = &wxNullBitmap;
3878 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3879 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3880 PyObject* ro;
3881 wxBitmap* ptr;
3882 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3883 if (ro) {
3884 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3885 rval = ptr;
3886 Py_DECREF(ro);
3887 }
3888 }
3889 wxPyEndBlockThreads(blocked);
3890 return *rval;
3891 }
3892
3893 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3894 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3895 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3896 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3897 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3898 Py_DECREF(bo);
3899 }
3900 wxPyEndBlockThreads(blocked);
3901 }
3902
3903 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3904 return new wxCustomDataObject(wxDataFormat(formatName));
3905 }
3906 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3907 bool rval;
3908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3909 if (PyString_Check(data)) {
3910 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3911 }
3912 else {
3913 // raise a TypeError if not a string
3914 PyErr_SetString(PyExc_TypeError, "String expected.");
3915 rval = false;
3916 }
3917 wxPyEndBlockThreads(blocked);
3918 return rval;
3919 }
3920 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3921 PyObject* obj;
3922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3923 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3924 wxPyEndBlockThreads(blocked);
3925 return obj;
3926 }
3927
3928 class wxMetafileDataObject : public wxDataObjectSimple
3929 {
3930 public:
3931 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3932 };
3933
3934
3935 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3936
3937
3938 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3939 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3940 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3941 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3942 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3943
3944
3945 class wxPyTextDropTarget : public wxTextDropTarget {
3946 public:
3947 wxPyTextDropTarget() {}
3948
3949 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3950
3951 DEC_PYCALLBACK__(OnLeave);
3952 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3953 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3954 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3955 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3956
3957 PYPRIVATE;
3958 };
3959
3960 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3961 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3962 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3963 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3964 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3965 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3966
3967
3968
3969 class wxPyFileDropTarget : public wxFileDropTarget {
3970 public:
3971 wxPyFileDropTarget() {}
3972
3973 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3974
3975 DEC_PYCALLBACK__(OnLeave);
3976 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3977 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3978 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3979 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3980
3981 PYPRIVATE;
3982 };
3983
3984 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3985 const wxArrayString& filenames) {
3986 bool rval = false;
3987 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3988 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3989 PyObject* list = wxArrayString2PyList_helper(filenames);
3990 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3991 Py_DECREF(list);
3992 }
3993 wxPyEndBlockThreads(blocked);
3994 return rval;
3995 }
3996
3997
3998
3999 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4000 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4001 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4002 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4003 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4004
4005
4006
4007
4008 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4009
4010 #include <wx/display.h>
4011
4012 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4013 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4014
4015 #if !wxUSE_DISPLAY
4016 const wxVideoMode wxDefaultVideoMode;
4017 #endif
4018
4019 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4020 #if wxUSE_DISPLAY
4021 PyObject* pyList = NULL;
4022 wxArrayVideoModes arr = self->GetModes(mode);
4023 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4024 pyList = PyList_New(0);
4025 for (size_t i=0; i < arr.GetCount(); i++)
4026 {
4027 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4028 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4029 PyList_Append(pyList, pyObj);
4030 Py_DECREF(pyObj);
4031 }
4032 wxPyEndBlockThreads(blocked);
4033 return pyList;
4034 #else
4035 wxPyRaiseNotImplemented();
4036 return NULL;
4037 #endif
4038 }
4039 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4040 #if wxUSE_DISPLAY
4041 return self->GetCurrentMode();
4042 #else
4043 wxPyRaiseNotImplemented();
4044 return wxDefaultVideoMode;
4045 #endif
4046 }
4047 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4048 #if wxUSE_DISPLAY
4049 return self->ChangeMode(mode);
4050 #else
4051 wxPyRaiseNotImplemented();
4052 return false;
4053 #endif
4054 }
4055 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4056 #if wxUSE_DISPLAY
4057 self->ResetMode();
4058 #else
4059 wxPyRaiseNotImplemented();
4060 #endif
4061 }
4062
4063 #include <wx/stdpaths.h>
4064
4065 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4066 return (wxStandardPaths*) &wxStandardPaths::Get();
4067 }
4068 #ifdef __cplusplus
4069 extern "C" {
4070 #endif
4071 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4072 PyObject *resultobj = 0;
4073 wxSystemColour arg1 ;
4074 wxColour result;
4075 int val1 ;
4076 int ecode1 = 0 ;
4077 PyObject * obj0 = 0 ;
4078 char * kwnames[] = {
4079 (char *) "index", NULL
4080 };
4081
4082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4083 ecode1 = SWIG_AsVal_int(obj0, &val1);
4084 if (!SWIG_IsOK(ecode1)) {
4085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4086 }
4087 arg1 = static_cast< wxSystemColour >(val1);
4088 {
4089 if (!wxPyCheckForApp()) SWIG_fail;
4090 PyThreadState* __tstate = wxPyBeginAllowThreads();
4091 result = wxSystemSettings::GetColour(arg1);
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj = 0;
4104 wxSystemFont arg1 ;
4105 wxFont result;
4106 int val1 ;
4107 int ecode1 = 0 ;
4108 PyObject * obj0 = 0 ;
4109 char * kwnames[] = {
4110 (char *) "index", NULL
4111 };
4112
4113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4114 ecode1 = SWIG_AsVal_int(obj0, &val1);
4115 if (!SWIG_IsOK(ecode1)) {
4116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4117 }
4118 arg1 = static_cast< wxSystemFont >(val1);
4119 {
4120 if (!wxPyCheckForApp()) SWIG_fail;
4121 PyThreadState* __tstate = wxPyBeginAllowThreads();
4122 result = wxSystemSettings::GetFont(arg1);
4123 wxPyEndAllowThreads(__tstate);
4124 if (PyErr_Occurred()) SWIG_fail;
4125 }
4126 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4127 return resultobj;
4128 fail:
4129 return NULL;
4130 }
4131
4132
4133 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4134 PyObject *resultobj = 0;
4135 wxSystemMetric arg1 ;
4136 wxWindow *arg2 = (wxWindow *) NULL ;
4137 int result;
4138 int val1 ;
4139 int ecode1 = 0 ;
4140 void *argp2 = 0 ;
4141 int res2 = 0 ;
4142 PyObject * obj0 = 0 ;
4143 PyObject * obj1 = 0 ;
4144 char * kwnames[] = {
4145 (char *) "index",(char *) "win", NULL
4146 };
4147
4148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4149 ecode1 = SWIG_AsVal_int(obj0, &val1);
4150 if (!SWIG_IsOK(ecode1)) {
4151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4152 }
4153 arg1 = static_cast< wxSystemMetric >(val1);
4154 if (obj1) {
4155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4156 if (!SWIG_IsOK(res2)) {
4157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4158 }
4159 arg2 = reinterpret_cast< wxWindow * >(argp2);
4160 }
4161 {
4162 if (!wxPyCheckForApp()) SWIG_fail;
4163 PyThreadState* __tstate = wxPyBeginAllowThreads();
4164 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4165 wxPyEndAllowThreads(__tstate);
4166 if (PyErr_Occurred()) SWIG_fail;
4167 }
4168 resultobj = SWIG_From_int(static_cast< int >(result));
4169 return resultobj;
4170 fail:
4171 return NULL;
4172 }
4173
4174
4175 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4176 PyObject *resultobj = 0;
4177 wxSystemFeature arg1 ;
4178 bool result;
4179 int val1 ;
4180 int ecode1 = 0 ;
4181 PyObject * obj0 = 0 ;
4182 char * kwnames[] = {
4183 (char *) "index", NULL
4184 };
4185
4186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4187 ecode1 = SWIG_AsVal_int(obj0, &val1);
4188 if (!SWIG_IsOK(ecode1)) {
4189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4190 }
4191 arg1 = static_cast< wxSystemFeature >(val1);
4192 {
4193 if (!wxPyCheckForApp()) SWIG_fail;
4194 PyThreadState* __tstate = wxPyBeginAllowThreads();
4195 result = (bool)wxSystemSettings::HasFeature(arg1);
4196 wxPyEndAllowThreads(__tstate);
4197 if (PyErr_Occurred()) SWIG_fail;
4198 }
4199 {
4200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4201 }
4202 return resultobj;
4203 fail:
4204 return NULL;
4205 }
4206
4207
4208 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4209 PyObject *resultobj = 0;
4210 wxSystemScreenType result;
4211
4212 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4213 {
4214 if (!wxPyCheckForApp()) SWIG_fail;
4215 PyThreadState* __tstate = wxPyBeginAllowThreads();
4216 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4217 wxPyEndAllowThreads(__tstate);
4218 if (PyErr_Occurred()) SWIG_fail;
4219 }
4220 resultobj = SWIG_From_int(static_cast< int >(result));
4221 return resultobj;
4222 fail:
4223 return NULL;
4224 }
4225
4226
4227 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4228 PyObject *resultobj = 0;
4229 wxSystemScreenType arg1 ;
4230 int val1 ;
4231 int ecode1 = 0 ;
4232 PyObject * obj0 = 0 ;
4233 char * kwnames[] = {
4234 (char *) "screen", NULL
4235 };
4236
4237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4238 ecode1 = SWIG_AsVal_int(obj0, &val1);
4239 if (!SWIG_IsOK(ecode1)) {
4240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4241 }
4242 arg1 = static_cast< wxSystemScreenType >(val1);
4243 {
4244 if (!wxPyCheckForApp()) SWIG_fail;
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 wxSystemSettings::SetScreenType(arg1);
4247 wxPyEndAllowThreads(__tstate);
4248 if (PyErr_Occurred()) SWIG_fail;
4249 }
4250 resultobj = SWIG_Py_Void();
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4258 PyObject *obj;
4259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4260 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4261 return SWIG_Py_Void();
4262 }
4263
4264 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4265 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4266 return 1;
4267 }
4268
4269
4270 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4271 PyObject *pyobj = 0;
4272
4273 {
4274 #if wxUSE_UNICODE
4275 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4276 #else
4277 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4278 #endif
4279 }
4280 return pyobj;
4281 }
4282
4283
4284 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4285 PyObject *resultobj = 0;
4286 wxSystemOptions *result = 0 ;
4287
4288 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4289 {
4290 PyThreadState* __tstate = wxPyBeginAllowThreads();
4291 result = (wxSystemOptions *)new wxSystemOptions();
4292 wxPyEndAllowThreads(__tstate);
4293 if (PyErr_Occurred()) SWIG_fail;
4294 }
4295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4296 return resultobj;
4297 fail:
4298 return NULL;
4299 }
4300
4301
4302 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4303 PyObject *resultobj = 0;
4304 wxString *arg1 = 0 ;
4305 wxString *arg2 = 0 ;
4306 bool temp1 = false ;
4307 bool temp2 = false ;
4308 PyObject * obj0 = 0 ;
4309 PyObject * obj1 = 0 ;
4310 char * kwnames[] = {
4311 (char *) "name",(char *) "value", NULL
4312 };
4313
4314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4315 {
4316 arg1 = wxString_in_helper(obj0);
4317 if (arg1 == NULL) SWIG_fail;
4318 temp1 = true;
4319 }
4320 {
4321 arg2 = wxString_in_helper(obj1);
4322 if (arg2 == NULL) SWIG_fail;
4323 temp2 = true;
4324 }
4325 {
4326 PyThreadState* __tstate = wxPyBeginAllowThreads();
4327 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4328 wxPyEndAllowThreads(__tstate);
4329 if (PyErr_Occurred()) SWIG_fail;
4330 }
4331 resultobj = SWIG_Py_Void();
4332 {
4333 if (temp1)
4334 delete arg1;
4335 }
4336 {
4337 if (temp2)
4338 delete arg2;
4339 }
4340 return resultobj;
4341 fail:
4342 {
4343 if (temp1)
4344 delete arg1;
4345 }
4346 {
4347 if (temp2)
4348 delete arg2;
4349 }
4350 return NULL;
4351 }
4352
4353
4354 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4355 PyObject *resultobj = 0;
4356 wxString *arg1 = 0 ;
4357 int arg2 ;
4358 bool temp1 = false ;
4359 int val2 ;
4360 int ecode2 = 0 ;
4361 PyObject * obj0 = 0 ;
4362 PyObject * obj1 = 0 ;
4363 char * kwnames[] = {
4364 (char *) "name",(char *) "value", NULL
4365 };
4366
4367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4368 {
4369 arg1 = wxString_in_helper(obj0);
4370 if (arg1 == NULL) SWIG_fail;
4371 temp1 = true;
4372 }
4373 ecode2 = SWIG_AsVal_int(obj1, &val2);
4374 if (!SWIG_IsOK(ecode2)) {
4375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4376 }
4377 arg2 = static_cast< int >(val2);
4378 {
4379 PyThreadState* __tstate = wxPyBeginAllowThreads();
4380 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4381 wxPyEndAllowThreads(__tstate);
4382 if (PyErr_Occurred()) SWIG_fail;
4383 }
4384 resultobj = SWIG_Py_Void();
4385 {
4386 if (temp1)
4387 delete arg1;
4388 }
4389 return resultobj;
4390 fail:
4391 {
4392 if (temp1)
4393 delete arg1;
4394 }
4395 return NULL;
4396 }
4397
4398
4399 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4400 PyObject *resultobj = 0;
4401 wxString *arg1 = 0 ;
4402 wxString result;
4403 bool temp1 = false ;
4404 PyObject * obj0 = 0 ;
4405 char * kwnames[] = {
4406 (char *) "name", NULL
4407 };
4408
4409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4410 {
4411 arg1 = wxString_in_helper(obj0);
4412 if (arg1 == NULL) SWIG_fail;
4413 temp1 = true;
4414 }
4415 {
4416 PyThreadState* __tstate = wxPyBeginAllowThreads();
4417 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 {
4422 #if wxUSE_UNICODE
4423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4424 #else
4425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4426 #endif
4427 }
4428 {
4429 if (temp1)
4430 delete arg1;
4431 }
4432 return resultobj;
4433 fail:
4434 {
4435 if (temp1)
4436 delete arg1;
4437 }
4438 return NULL;
4439 }
4440
4441
4442 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4443 PyObject *resultobj = 0;
4444 wxString *arg1 = 0 ;
4445 int result;
4446 bool temp1 = false ;
4447 PyObject * obj0 = 0 ;
4448 char * kwnames[] = {
4449 (char *) "name", NULL
4450 };
4451
4452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4453 {
4454 arg1 = wxString_in_helper(obj0);
4455 if (arg1 == NULL) SWIG_fail;
4456 temp1 = true;
4457 }
4458 {
4459 PyThreadState* __tstate = wxPyBeginAllowThreads();
4460 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4461 wxPyEndAllowThreads(__tstate);
4462 if (PyErr_Occurred()) SWIG_fail;
4463 }
4464 resultobj = SWIG_From_int(static_cast< int >(result));
4465 {
4466 if (temp1)
4467 delete arg1;
4468 }
4469 return resultobj;
4470 fail:
4471 {
4472 if (temp1)
4473 delete arg1;
4474 }
4475 return NULL;
4476 }
4477
4478
4479 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4480 PyObject *resultobj = 0;
4481 wxString *arg1 = 0 ;
4482 bool result;
4483 bool temp1 = false ;
4484 PyObject * obj0 = 0 ;
4485 char * kwnames[] = {
4486 (char *) "name", NULL
4487 };
4488
4489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4490 {
4491 arg1 = wxString_in_helper(obj0);
4492 if (arg1 == NULL) SWIG_fail;
4493 temp1 = true;
4494 }
4495 {
4496 PyThreadState* __tstate = wxPyBeginAllowThreads();
4497 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4498 wxPyEndAllowThreads(__tstate);
4499 if (PyErr_Occurred()) SWIG_fail;
4500 }
4501 {
4502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4503 }
4504 {
4505 if (temp1)
4506 delete arg1;
4507 }
4508 return resultobj;
4509 fail:
4510 {
4511 if (temp1)
4512 delete arg1;
4513 }
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4519 PyObject *resultobj = 0;
4520 wxString *arg1 = 0 ;
4521 bool result;
4522 bool temp1 = false ;
4523 PyObject * obj0 = 0 ;
4524 char * kwnames[] = {
4525 (char *) "name", NULL
4526 };
4527
4528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4529 {
4530 arg1 = wxString_in_helper(obj0);
4531 if (arg1 == NULL) SWIG_fail;
4532 temp1 = true;
4533 }
4534 {
4535 PyThreadState* __tstate = wxPyBeginAllowThreads();
4536 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4537 wxPyEndAllowThreads(__tstate);
4538 if (PyErr_Occurred()) SWIG_fail;
4539 }
4540 {
4541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4542 }
4543 {
4544 if (temp1)
4545 delete arg1;
4546 }
4547 return resultobj;
4548 fail:
4549 {
4550 if (temp1)
4551 delete arg1;
4552 }
4553 return NULL;
4554 }
4555
4556
4557 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4558 PyObject *obj;
4559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4560 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4561 return SWIG_Py_Void();
4562 }
4563
4564 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 return SWIG_Python_InitShadowInstance(args);
4566 }
4567
4568 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4569 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4570 return 1;
4571 }
4572
4573
4574 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4575 PyObject *pyobj = 0;
4576
4577 {
4578 #if wxUSE_UNICODE
4579 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4580 #else
4581 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4582 #endif
4583 }
4584 return pyobj;
4585 }
4586
4587
4588 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4589 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4590 return 1;
4591 }
4592
4593
4594 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4595 PyObject *pyobj = 0;
4596
4597 {
4598 #if wxUSE_UNICODE
4599 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4600 #else
4601 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4602 #endif
4603 }
4604 return pyobj;
4605 }
4606
4607
4608 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4609 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4610 return 1;
4611 }
4612
4613
4614 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4615 PyObject *pyobj = 0;
4616
4617 {
4618 #if wxUSE_UNICODE
4619 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4620 #else
4621 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4622 #endif
4623 }
4624 return pyobj;
4625 }
4626
4627
4628 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4629 PyObject *resultobj = 0;
4630 long result;
4631
4632 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4633 {
4634 PyThreadState* __tstate = wxPyBeginAllowThreads();
4635 result = (long)wxNewId();
4636 wxPyEndAllowThreads(__tstate);
4637 if (PyErr_Occurred()) SWIG_fail;
4638 }
4639 resultobj = SWIG_From_long(static_cast< long >(result));
4640 return resultobj;
4641 fail:
4642 return NULL;
4643 }
4644
4645
4646 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4647 PyObject *resultobj = 0;
4648 long arg1 ;
4649 long val1 ;
4650 int ecode1 = 0 ;
4651 PyObject * obj0 = 0 ;
4652 char * kwnames[] = {
4653 (char *) "id", NULL
4654 };
4655
4656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4657 ecode1 = SWIG_AsVal_long(obj0, &val1);
4658 if (!SWIG_IsOK(ecode1)) {
4659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4660 }
4661 arg1 = static_cast< long >(val1);
4662 {
4663 PyThreadState* __tstate = wxPyBeginAllowThreads();
4664 wxRegisterId(arg1);
4665 wxPyEndAllowThreads(__tstate);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 resultobj = SWIG_Py_Void();
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4676 PyObject *resultobj = 0;
4677 long result;
4678
4679 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4680 {
4681 PyThreadState* __tstate = wxPyBeginAllowThreads();
4682 result = (long)wxGetCurrentId();
4683 wxPyEndAllowThreads(__tstate);
4684 if (PyErr_Occurred()) SWIG_fail;
4685 }
4686 resultobj = SWIG_From_long(static_cast< long >(result));
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj = 0;
4695 int arg1 ;
4696 bool result;
4697 int val1 ;
4698 int ecode1 = 0 ;
4699 PyObject * obj0 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "id", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4705 ecode1 = SWIG_AsVal_int(obj0, &val1);
4706 if (!SWIG_IsOK(ecode1)) {
4707 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4708 }
4709 arg1 = static_cast< int >(val1);
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 result = (bool)wxIsStockID(arg1);
4713 wxPyEndAllowThreads(__tstate);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 {
4717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4718 }
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj = 0;
4727 int arg1 ;
4728 wxString *arg2 = 0 ;
4729 bool result;
4730 int val1 ;
4731 int ecode1 = 0 ;
4732 bool temp2 = false ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "id",(char *) "label", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4740 ecode1 = SWIG_AsVal_int(obj0, &val1);
4741 if (!SWIG_IsOK(ecode1)) {
4742 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4743 }
4744 arg1 = static_cast< int >(val1);
4745 {
4746 arg2 = wxString_in_helper(obj1);
4747 if (arg2 == NULL) SWIG_fail;
4748 temp2 = true;
4749 }
4750 {
4751 PyThreadState* __tstate = wxPyBeginAllowThreads();
4752 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4753 wxPyEndAllowThreads(__tstate);
4754 if (PyErr_Occurred()) SWIG_fail;
4755 }
4756 {
4757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4758 }
4759 {
4760 if (temp2)
4761 delete arg2;
4762 }
4763 return resultobj;
4764 fail:
4765 {
4766 if (temp2)
4767 delete arg2;
4768 }
4769 return NULL;
4770 }
4771
4772
4773 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj = 0;
4775 int arg1 ;
4776 bool arg2 = (bool) true ;
4777 wxString arg3 = (wxString) wxPyEmptyString ;
4778 wxString result;
4779 int val1 ;
4780 int ecode1 = 0 ;
4781 bool val2 ;
4782 int ecode2 = 0 ;
4783 PyObject * obj0 = 0 ;
4784 PyObject * obj1 = 0 ;
4785 PyObject * obj2 = 0 ;
4786 char * kwnames[] = {
4787 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4788 };
4789
4790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4791 ecode1 = SWIG_AsVal_int(obj0, &val1);
4792 if (!SWIG_IsOK(ecode1)) {
4793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4794 }
4795 arg1 = static_cast< int >(val1);
4796 if (obj1) {
4797 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4798 if (!SWIG_IsOK(ecode2)) {
4799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4800 }
4801 arg2 = static_cast< bool >(val2);
4802 }
4803 if (obj2) {
4804 {
4805 wxString* sptr = wxString_in_helper(obj2);
4806 if (sptr == NULL) SWIG_fail;
4807 arg3 = *sptr;
4808 delete sptr;
4809 }
4810 }
4811 {
4812 PyThreadState* __tstate = wxPyBeginAllowThreads();
4813 result = wxGetStockLabel(arg1,arg2,arg3);
4814 wxPyEndAllowThreads(__tstate);
4815 if (PyErr_Occurred()) SWIG_fail;
4816 }
4817 {
4818 #if wxUSE_UNICODE
4819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4820 #else
4821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4822 #endif
4823 }
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4831 PyObject *resultobj = 0;
4832
4833 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4834 {
4835 if (!wxPyCheckForApp()) SWIG_fail;
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 wxBell();
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 resultobj = SWIG_Py_Void();
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4849 PyObject *resultobj = 0;
4850
4851 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4852 {
4853 if (!wxPyCheckForApp()) SWIG_fail;
4854 PyThreadState* __tstate = wxPyBeginAllowThreads();
4855 wxEndBusyCursor();
4856 wxPyEndAllowThreads(__tstate);
4857 if (PyErr_Occurred()) SWIG_fail;
4858 }
4859 resultobj = SWIG_Py_Void();
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj = 0;
4868 bool arg1 = (bool) true ;
4869 long result;
4870 bool val1 ;
4871 int ecode1 = 0 ;
4872 PyObject * obj0 = 0 ;
4873 char * kwnames[] = {
4874 (char *) "resetTimer", NULL
4875 };
4876
4877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4878 if (obj0) {
4879 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4880 if (!SWIG_IsOK(ecode1)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4882 }
4883 arg1 = static_cast< bool >(val1);
4884 }
4885 {
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 result = (long)wxGetElapsedTime(arg1);
4888 wxPyEndAllowThreads(__tstate);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 resultobj = SWIG_From_long(static_cast< long >(result));
4892 return resultobj;
4893 fail:
4894 return NULL;
4895 }
4896
4897
4898 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4899 PyObject *resultobj = 0;
4900 bool result;
4901
4902 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4903 {
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 result = (bool)wxIsBusy();
4906 wxPyEndAllowThreads(__tstate);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 {
4910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4911 }
4912 return resultobj;
4913 fail:
4914 return NULL;
4915 }
4916
4917
4918 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4919 PyObject *resultobj = 0;
4920 wxString result;
4921
4922 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4923 {
4924 PyThreadState* __tstate = wxPyBeginAllowThreads();
4925 result = wxNow();
4926 wxPyEndAllowThreads(__tstate);
4927 if (PyErr_Occurred()) SWIG_fail;
4928 }
4929 {
4930 #if wxUSE_UNICODE
4931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4932 #else
4933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4934 #endif
4935 }
4936 return resultobj;
4937 fail:
4938 return NULL;
4939 }
4940
4941
4942 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4943 PyObject *resultobj = 0;
4944 wxString const &arg1_defvalue = wxPyEmptyString ;
4945 wxString *arg1 = (wxString *) &arg1_defvalue ;
4946 bool result;
4947 bool temp1 = false ;
4948 PyObject * obj0 = 0 ;
4949 char * kwnames[] = {
4950 (char *) "command", NULL
4951 };
4952
4953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4954 if (obj0) {
4955 {
4956 arg1 = wxString_in_helper(obj0);
4957 if (arg1 == NULL) SWIG_fail;
4958 temp1 = true;
4959 }
4960 }
4961 {
4962 PyThreadState* __tstate = wxPyBeginAllowThreads();
4963 result = (bool)wxShell((wxString const &)*arg1);
4964 wxPyEndAllowThreads(__tstate);
4965 if (PyErr_Occurred()) SWIG_fail;
4966 }
4967 {
4968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4969 }
4970 {
4971 if (temp1)
4972 delete arg1;
4973 }
4974 return resultobj;
4975 fail:
4976 {
4977 if (temp1)
4978 delete arg1;
4979 }
4980 return NULL;
4981 }
4982
4983
4984 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4985 PyObject *resultobj = 0;
4986
4987 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 wxStartTimer();
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 resultobj = SWIG_Py_Void();
4995 return resultobj;
4996 fail:
4997 return NULL;
4998 }
4999
5000
5001 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5002 PyObject *resultobj = 0;
5003 int *arg1 = (int *) 0 ;
5004 int *arg2 = (int *) 0 ;
5005 int result;
5006 int temp1 ;
5007 int res1 = SWIG_TMPOBJ ;
5008 int temp2 ;
5009 int res2 = SWIG_TMPOBJ ;
5010
5011 arg1 = &temp1;
5012 arg2 = &temp2;
5013 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5014 {
5015 PyThreadState* __tstate = wxPyBeginAllowThreads();
5016 result = (int)wxGetOsVersion(arg1,arg2);
5017 wxPyEndAllowThreads(__tstate);
5018 if (PyErr_Occurred()) SWIG_fail;
5019 }
5020 resultobj = SWIG_From_int(static_cast< int >(result));
5021 if (SWIG_IsTmpObj(res1)) {
5022 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5023 } else {
5024 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5025 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5026 }
5027 if (SWIG_IsTmpObj(res2)) {
5028 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5029 } else {
5030 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5031 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5032 }
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5040 PyObject *resultobj = 0;
5041 wxString result;
5042
5043 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5044 {
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 result = wxGetOsDescription();
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 {
5051 #if wxUSE_UNICODE
5052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5053 #else
5054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5055 #endif
5056 }
5057 return resultobj;
5058 fail:
5059 return NULL;
5060 }
5061
5062
5063 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5064 PyObject *resultobj = 0;
5065 wxMemorySize result;
5066
5067 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = wxGetFreeMemory();
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj = 0;
5083 wxShutdownFlags arg1 ;
5084 bool result;
5085 int val1 ;
5086 int ecode1 = 0 ;
5087 PyObject * obj0 = 0 ;
5088 char * kwnames[] = {
5089 (char *) "wFlags", NULL
5090 };
5091
5092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5093 ecode1 = SWIG_AsVal_int(obj0, &val1);
5094 if (!SWIG_IsOK(ecode1)) {
5095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5096 }
5097 arg1 = static_cast< wxShutdownFlags >(val1);
5098 {
5099 if (!wxPyCheckForApp()) SWIG_fail;
5100 PyThreadState* __tstate = wxPyBeginAllowThreads();
5101 result = (bool)wxShutdown(arg1);
5102 wxPyEndAllowThreads(__tstate);
5103 if (PyErr_Occurred()) SWIG_fail;
5104 }
5105 {
5106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5107 }
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj = 0;
5116 int arg1 ;
5117 int val1 ;
5118 int ecode1 = 0 ;
5119 PyObject * obj0 = 0 ;
5120 char * kwnames[] = {
5121 (char *) "secs", NULL
5122 };
5123
5124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5125 ecode1 = SWIG_AsVal_int(obj0, &val1);
5126 if (!SWIG_IsOK(ecode1)) {
5127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5128 }
5129 arg1 = static_cast< int >(val1);
5130 {
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 wxSleep(arg1);
5133 wxPyEndAllowThreads(__tstate);
5134 if (PyErr_Occurred()) SWIG_fail;
5135 }
5136 resultobj = SWIG_Py_Void();
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj = 0;
5145 unsigned long arg1 ;
5146 unsigned long val1 ;
5147 int ecode1 = 0 ;
5148 PyObject * obj0 = 0 ;
5149 char * kwnames[] = {
5150 (char *) "milliseconds", NULL
5151 };
5152
5153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5154 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5155 if (!SWIG_IsOK(ecode1)) {
5156 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5157 }
5158 arg1 = static_cast< unsigned long >(val1);
5159 {
5160 PyThreadState* __tstate = wxPyBeginAllowThreads();
5161 wxMilliSleep(arg1);
5162 wxPyEndAllowThreads(__tstate);
5163 if (PyErr_Occurred()) SWIG_fail;
5164 }
5165 resultobj = SWIG_Py_Void();
5166 return resultobj;
5167 fail:
5168 return NULL;
5169 }
5170
5171
5172 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5173 PyObject *resultobj = 0;
5174 unsigned long arg1 ;
5175 unsigned long val1 ;
5176 int ecode1 = 0 ;
5177 PyObject * obj0 = 0 ;
5178 char * kwnames[] = {
5179 (char *) "microseconds", NULL
5180 };
5181
5182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5183 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5184 if (!SWIG_IsOK(ecode1)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5186 }
5187 arg1 = static_cast< unsigned long >(val1);
5188 {
5189 PyThreadState* __tstate = wxPyBeginAllowThreads();
5190 wxMicroSleep(arg1);
5191 wxPyEndAllowThreads(__tstate);
5192 if (PyErr_Occurred()) SWIG_fail;
5193 }
5194 resultobj = SWIG_Py_Void();
5195 return resultobj;
5196 fail:
5197 return NULL;
5198 }
5199
5200
5201 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5202 PyObject *resultobj = 0;
5203 bool arg1 ;
5204 bool val1 ;
5205 int ecode1 = 0 ;
5206 PyObject * obj0 = 0 ;
5207 char * kwnames[] = {
5208 (char *) "enable", NULL
5209 };
5210
5211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5212 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5213 if (!SWIG_IsOK(ecode1)) {
5214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5215 }
5216 arg1 = static_cast< bool >(val1);
5217 {
5218 PyThreadState* __tstate = wxPyBeginAllowThreads();
5219 wxEnableTopLevelWindows(arg1);
5220 wxPyEndAllowThreads(__tstate);
5221 if (PyErr_Occurred()) SWIG_fail;
5222 }
5223 resultobj = SWIG_Py_Void();
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj = 0;
5232 wxString *arg1 = 0 ;
5233 wxString result;
5234 bool temp1 = false ;
5235 PyObject * obj0 = 0 ;
5236 char * kwnames[] = {
5237 (char *) "in", NULL
5238 };
5239
5240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5241 {
5242 arg1 = wxString_in_helper(obj0);
5243 if (arg1 == NULL) SWIG_fail;
5244 temp1 = true;
5245 }
5246 {
5247 PyThreadState* __tstate = wxPyBeginAllowThreads();
5248 result = wxStripMenuCodes((wxString const &)*arg1);
5249 wxPyEndAllowThreads(__tstate);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 {
5253 #if wxUSE_UNICODE
5254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5255 #else
5256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5257 #endif
5258 }
5259 {
5260 if (temp1)
5261 delete arg1;
5262 }
5263 return resultobj;
5264 fail:
5265 {
5266 if (temp1)
5267 delete arg1;
5268 }
5269 return NULL;
5270 }
5271
5272
5273 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5274 PyObject *resultobj = 0;
5275 wxString result;
5276
5277 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5278 {
5279 PyThreadState* __tstate = wxPyBeginAllowThreads();
5280 result = wxGetEmailAddress();
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 {
5285 #if wxUSE_UNICODE
5286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5287 #else
5288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5289 #endif
5290 }
5291 return resultobj;
5292 fail:
5293 return NULL;
5294 }
5295
5296
5297 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 PyObject *resultobj = 0;
5299 wxString result;
5300
5301 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5302 {
5303 PyThreadState* __tstate = wxPyBeginAllowThreads();
5304 result = wxGetHostName();
5305 wxPyEndAllowThreads(__tstate);
5306 if (PyErr_Occurred()) SWIG_fail;
5307 }
5308 {
5309 #if wxUSE_UNICODE
5310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5311 #else
5312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5313 #endif
5314 }
5315 return resultobj;
5316 fail:
5317 return NULL;
5318 }
5319
5320
5321 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5322 PyObject *resultobj = 0;
5323 wxString result;
5324
5325 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5326 {
5327 PyThreadState* __tstate = wxPyBeginAllowThreads();
5328 result = wxGetFullHostName();
5329 wxPyEndAllowThreads(__tstate);
5330 if (PyErr_Occurred()) SWIG_fail;
5331 }
5332 {
5333 #if wxUSE_UNICODE
5334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5335 #else
5336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5337 #endif
5338 }
5339 return resultobj;
5340 fail:
5341 return NULL;
5342 }
5343
5344
5345 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5346 PyObject *resultobj = 0;
5347 wxString result;
5348
5349 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 result = wxGetUserId();
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 {
5357 #if wxUSE_UNICODE
5358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5359 #else
5360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5361 #endif
5362 }
5363 return resultobj;
5364 fail:
5365 return NULL;
5366 }
5367
5368
5369 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5370 PyObject *resultobj = 0;
5371 wxString result;
5372
5373 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5374 {
5375 PyThreadState* __tstate = wxPyBeginAllowThreads();
5376 result = wxGetUserName();
5377 wxPyEndAllowThreads(__tstate);
5378 if (PyErr_Occurred()) SWIG_fail;
5379 }
5380 {
5381 #if wxUSE_UNICODE
5382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5383 #else
5384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5385 #endif
5386 }
5387 return resultobj;
5388 fail:
5389 return NULL;
5390 }
5391
5392
5393 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5394 PyObject *resultobj = 0;
5395 wxString result;
5396
5397 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5398 {
5399 PyThreadState* __tstate = wxPyBeginAllowThreads();
5400 result = wxGetHomeDir();
5401 wxPyEndAllowThreads(__tstate);
5402 if (PyErr_Occurred()) SWIG_fail;
5403 }
5404 {
5405 #if wxUSE_UNICODE
5406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5407 #else
5408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5409 #endif
5410 }
5411 return resultobj;
5412 fail:
5413 return NULL;
5414 }
5415
5416
5417 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5418 PyObject *resultobj = 0;
5419 wxString const &arg1_defvalue = wxPyEmptyString ;
5420 wxString *arg1 = (wxString *) &arg1_defvalue ;
5421 wxString result;
5422 bool temp1 = false ;
5423 PyObject * obj0 = 0 ;
5424 char * kwnames[] = {
5425 (char *) "user", NULL
5426 };
5427
5428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5429 if (obj0) {
5430 {
5431 arg1 = wxString_in_helper(obj0);
5432 if (arg1 == NULL) SWIG_fail;
5433 temp1 = true;
5434 }
5435 }
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 result = wxGetUserHome((wxString const &)*arg1);
5439 wxPyEndAllowThreads(__tstate);
5440 if (PyErr_Occurred()) SWIG_fail;
5441 }
5442 {
5443 #if wxUSE_UNICODE
5444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5445 #else
5446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5447 #endif
5448 }
5449 {
5450 if (temp1)
5451 delete arg1;
5452 }
5453 return resultobj;
5454 fail:
5455 {
5456 if (temp1)
5457 delete arg1;
5458 }
5459 return NULL;
5460 }
5461
5462
5463 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5464 PyObject *resultobj = 0;
5465 unsigned long result;
5466
5467 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (unsigned long)wxGetProcessId();
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5482 PyObject *resultobj = 0;
5483
5484 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 wxTrap();
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 resultobj = SWIG_Py_Void();
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5499 PyObject *resultobj = 0;
5500 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5501 wxString *arg1 = (wxString *) &arg1_defvalue ;
5502 wxString const &arg2_defvalue = wxPyEmptyString ;
5503 wxString *arg2 = (wxString *) &arg2_defvalue ;
5504 wxString const &arg3_defvalue = wxPyEmptyString ;
5505 wxString *arg3 = (wxString *) &arg3_defvalue ;
5506 wxString const &arg4_defvalue = wxPyEmptyString ;
5507 wxString *arg4 = (wxString *) &arg4_defvalue ;
5508 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5509 wxString *arg5 = (wxString *) &arg5_defvalue ;
5510 int arg6 = (int) 0 ;
5511 wxWindow *arg7 = (wxWindow *) NULL ;
5512 int arg8 = (int) -1 ;
5513 int arg9 = (int) -1 ;
5514 wxString result;
5515 bool temp1 = false ;
5516 bool temp2 = false ;
5517 bool temp3 = false ;
5518 bool temp4 = false ;
5519 bool temp5 = false ;
5520 int val6 ;
5521 int ecode6 = 0 ;
5522 void *argp7 = 0 ;
5523 int res7 = 0 ;
5524 int val8 ;
5525 int ecode8 = 0 ;
5526 int val9 ;
5527 int ecode9 = 0 ;
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 PyObject * obj2 = 0 ;
5531 PyObject * obj3 = 0 ;
5532 PyObject * obj4 = 0 ;
5533 PyObject * obj5 = 0 ;
5534 PyObject * obj6 = 0 ;
5535 PyObject * obj7 = 0 ;
5536 PyObject * obj8 = 0 ;
5537 char * kwnames[] = {
5538 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5539 };
5540
5541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5542 if (obj0) {
5543 {
5544 arg1 = wxString_in_helper(obj0);
5545 if (arg1 == NULL) SWIG_fail;
5546 temp1 = true;
5547 }
5548 }
5549 if (obj1) {
5550 {
5551 arg2 = wxString_in_helper(obj1);
5552 if (arg2 == NULL) SWIG_fail;
5553 temp2 = true;
5554 }
5555 }
5556 if (obj2) {
5557 {
5558 arg3 = wxString_in_helper(obj2);
5559 if (arg3 == NULL) SWIG_fail;
5560 temp3 = true;
5561 }
5562 }
5563 if (obj3) {
5564 {
5565 arg4 = wxString_in_helper(obj3);
5566 if (arg4 == NULL) SWIG_fail;
5567 temp4 = true;
5568 }
5569 }
5570 if (obj4) {
5571 {
5572 arg5 = wxString_in_helper(obj4);
5573 if (arg5 == NULL) SWIG_fail;
5574 temp5 = true;
5575 }
5576 }
5577 if (obj5) {
5578 ecode6 = SWIG_AsVal_int(obj5, &val6);
5579 if (!SWIG_IsOK(ecode6)) {
5580 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5581 }
5582 arg6 = static_cast< int >(val6);
5583 }
5584 if (obj6) {
5585 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5586 if (!SWIG_IsOK(res7)) {
5587 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5588 }
5589 arg7 = reinterpret_cast< wxWindow * >(argp7);
5590 }
5591 if (obj7) {
5592 ecode8 = SWIG_AsVal_int(obj7, &val8);
5593 if (!SWIG_IsOK(ecode8)) {
5594 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5595 }
5596 arg8 = static_cast< int >(val8);
5597 }
5598 if (obj8) {
5599 ecode9 = SWIG_AsVal_int(obj8, &val9);
5600 if (!SWIG_IsOK(ecode9)) {
5601 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5602 }
5603 arg9 = static_cast< int >(val9);
5604 }
5605 {
5606 if (!wxPyCheckForApp()) SWIG_fail;
5607 PyThreadState* __tstate = wxPyBeginAllowThreads();
5608 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5609 wxPyEndAllowThreads(__tstate);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 {
5613 #if wxUSE_UNICODE
5614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5615 #else
5616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5617 #endif
5618 }
5619 {
5620 if (temp1)
5621 delete arg1;
5622 }
5623 {
5624 if (temp2)
5625 delete arg2;
5626 }
5627 {
5628 if (temp3)
5629 delete arg3;
5630 }
5631 {
5632 if (temp4)
5633 delete arg4;
5634 }
5635 {
5636 if (temp5)
5637 delete arg5;
5638 }
5639 return resultobj;
5640 fail:
5641 {
5642 if (temp1)
5643 delete arg1;
5644 }
5645 {
5646 if (temp2)
5647 delete arg2;
5648 }
5649 {
5650 if (temp3)
5651 delete arg3;
5652 }
5653 {
5654 if (temp4)
5655 delete arg4;
5656 }
5657 {
5658 if (temp5)
5659 delete arg5;
5660 }
5661 return NULL;
5662 }
5663
5664
5665 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5666 PyObject *resultobj = 0;
5667 wxString *arg1 = 0 ;
5668 wxString *arg2 = 0 ;
5669 wxString const &arg3_defvalue = wxPyEmptyString ;
5670 wxString *arg3 = (wxString *) &arg3_defvalue ;
5671 wxWindow *arg4 = (wxWindow *) NULL ;
5672 wxString result;
5673 bool temp1 = false ;
5674 bool temp2 = false ;
5675 bool temp3 = false ;
5676 void *argp4 = 0 ;
5677 int res4 = 0 ;
5678 PyObject * obj0 = 0 ;
5679 PyObject * obj1 = 0 ;
5680 PyObject * obj2 = 0 ;
5681 PyObject * obj3 = 0 ;
5682 char * kwnames[] = {
5683 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5684 };
5685
5686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5687 {
5688 arg1 = wxString_in_helper(obj0);
5689 if (arg1 == NULL) SWIG_fail;
5690 temp1 = true;
5691 }
5692 {
5693 arg2 = wxString_in_helper(obj1);
5694 if (arg2 == NULL) SWIG_fail;
5695 temp2 = true;
5696 }
5697 if (obj2) {
5698 {
5699 arg3 = wxString_in_helper(obj2);
5700 if (arg3 == NULL) SWIG_fail;
5701 temp3 = true;
5702 }
5703 }
5704 if (obj3) {
5705 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5706 if (!SWIG_IsOK(res4)) {
5707 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5708 }
5709 arg4 = reinterpret_cast< wxWindow * >(argp4);
5710 }
5711 {
5712 if (!wxPyCheckForApp()) SWIG_fail;
5713 PyThreadState* __tstate = wxPyBeginAllowThreads();
5714 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5715 wxPyEndAllowThreads(__tstate);
5716 if (PyErr_Occurred()) SWIG_fail;
5717 }
5718 {
5719 #if wxUSE_UNICODE
5720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5721 #else
5722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5723 #endif
5724 }
5725 {
5726 if (temp1)
5727 delete arg1;
5728 }
5729 {
5730 if (temp2)
5731 delete arg2;
5732 }
5733 {
5734 if (temp3)
5735 delete arg3;
5736 }
5737 return resultobj;
5738 fail:
5739 {
5740 if (temp1)
5741 delete arg1;
5742 }
5743 {
5744 if (temp2)
5745 delete arg2;
5746 }
5747 {
5748 if (temp3)
5749 delete arg3;
5750 }
5751 return NULL;
5752 }
5753
5754
5755 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5756 PyObject *resultobj = 0;
5757 wxString *arg1 = 0 ;
5758 wxString *arg2 = 0 ;
5759 wxString const &arg3_defvalue = wxPyEmptyString ;
5760 wxString *arg3 = (wxString *) &arg3_defvalue ;
5761 wxWindow *arg4 = (wxWindow *) NULL ;
5762 wxString result;
5763 bool temp1 = false ;
5764 bool temp2 = false ;
5765 bool temp3 = false ;
5766 void *argp4 = 0 ;
5767 int res4 = 0 ;
5768 PyObject * obj0 = 0 ;
5769 PyObject * obj1 = 0 ;
5770 PyObject * obj2 = 0 ;
5771 PyObject * obj3 = 0 ;
5772 char * kwnames[] = {
5773 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5774 };
5775
5776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5777 {
5778 arg1 = wxString_in_helper(obj0);
5779 if (arg1 == NULL) SWIG_fail;
5780 temp1 = true;
5781 }
5782 {
5783 arg2 = wxString_in_helper(obj1);
5784 if (arg2 == NULL) SWIG_fail;
5785 temp2 = true;
5786 }
5787 if (obj2) {
5788 {
5789 arg3 = wxString_in_helper(obj2);
5790 if (arg3 == NULL) SWIG_fail;
5791 temp3 = true;
5792 }
5793 }
5794 if (obj3) {
5795 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5796 if (!SWIG_IsOK(res4)) {
5797 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5798 }
5799 arg4 = reinterpret_cast< wxWindow * >(argp4);
5800 }
5801 {
5802 if (!wxPyCheckForApp()) SWIG_fail;
5803 PyThreadState* __tstate = wxPyBeginAllowThreads();
5804 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5805 wxPyEndAllowThreads(__tstate);
5806 if (PyErr_Occurred()) SWIG_fail;
5807 }
5808 {
5809 #if wxUSE_UNICODE
5810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5811 #else
5812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5813 #endif
5814 }
5815 {
5816 if (temp1)
5817 delete arg1;
5818 }
5819 {
5820 if (temp2)
5821 delete arg2;
5822 }
5823 {
5824 if (temp3)
5825 delete arg3;
5826 }
5827 return resultobj;
5828 fail:
5829 {
5830 if (temp1)
5831 delete arg1;
5832 }
5833 {
5834 if (temp2)
5835 delete arg2;
5836 }
5837 {
5838 if (temp3)
5839 delete arg3;
5840 }
5841 return NULL;
5842 }
5843
5844
5845 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj = 0;
5847 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5848 wxString *arg1 = (wxString *) &arg1_defvalue ;
5849 wxString const &arg2_defvalue = wxPyEmptyString ;
5850 wxString *arg2 = (wxString *) &arg2_defvalue ;
5851 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5852 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5853 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5854 wxWindow *arg5 = (wxWindow *) NULL ;
5855 wxString result;
5856 bool temp1 = false ;
5857 bool temp2 = false ;
5858 long val3 ;
5859 int ecode3 = 0 ;
5860 wxPoint temp4 ;
5861 void *argp5 = 0 ;
5862 int res5 = 0 ;
5863 PyObject * obj0 = 0 ;
5864 PyObject * obj1 = 0 ;
5865 PyObject * obj2 = 0 ;
5866 PyObject * obj3 = 0 ;
5867 PyObject * obj4 = 0 ;
5868 char * kwnames[] = {
5869 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5870 };
5871
5872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5873 if (obj0) {
5874 {
5875 arg1 = wxString_in_helper(obj0);
5876 if (arg1 == NULL) SWIG_fail;
5877 temp1 = true;
5878 }
5879 }
5880 if (obj1) {
5881 {
5882 arg2 = wxString_in_helper(obj1);
5883 if (arg2 == NULL) SWIG_fail;
5884 temp2 = true;
5885 }
5886 }
5887 if (obj2) {
5888 ecode3 = SWIG_AsVal_long(obj2, &val3);
5889 if (!SWIG_IsOK(ecode3)) {
5890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5891 }
5892 arg3 = static_cast< long >(val3);
5893 }
5894 if (obj3) {
5895 {
5896 arg4 = &temp4;
5897 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5898 }
5899 }
5900 if (obj4) {
5901 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5902 if (!SWIG_IsOK(res5)) {
5903 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5904 }
5905 arg5 = reinterpret_cast< wxWindow * >(argp5);
5906 }
5907 {
5908 if (!wxPyCheckForApp()) SWIG_fail;
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 {
5915 #if wxUSE_UNICODE
5916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5917 #else
5918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5919 #endif
5920 }
5921 {
5922 if (temp1)
5923 delete arg1;
5924 }
5925 {
5926 if (temp2)
5927 delete arg2;
5928 }
5929 return resultobj;
5930 fail:
5931 {
5932 if (temp1)
5933 delete arg1;
5934 }
5935 {
5936 if (temp2)
5937 delete arg2;
5938 }
5939 return NULL;
5940 }
5941
5942
5943 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj = 0;
5945 wxString *arg1 = 0 ;
5946 wxString const &arg2_defvalue = wxPyEmptyString ;
5947 wxString *arg2 = (wxString *) &arg2_defvalue ;
5948 wxString const &arg3_defvalue = wxPyEmptyString ;
5949 wxString *arg3 = (wxString *) &arg3_defvalue ;
5950 wxWindow *arg4 = (wxWindow *) NULL ;
5951 int arg5 = (int) -1 ;
5952 int arg6 = (int) -1 ;
5953 bool arg7 = (bool) true ;
5954 wxString result;
5955 bool temp1 = false ;
5956 bool temp2 = false ;
5957 bool temp3 = false ;
5958 void *argp4 = 0 ;
5959 int res4 = 0 ;
5960 int val5 ;
5961 int ecode5 = 0 ;
5962 int val6 ;
5963 int ecode6 = 0 ;
5964 bool val7 ;
5965 int ecode7 = 0 ;
5966 PyObject * obj0 = 0 ;
5967 PyObject * obj1 = 0 ;
5968 PyObject * obj2 = 0 ;
5969 PyObject * obj3 = 0 ;
5970 PyObject * obj4 = 0 ;
5971 PyObject * obj5 = 0 ;
5972 PyObject * obj6 = 0 ;
5973 char * kwnames[] = {
5974 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5975 };
5976
5977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5978 {
5979 arg1 = wxString_in_helper(obj0);
5980 if (arg1 == NULL) SWIG_fail;
5981 temp1 = true;
5982 }
5983 if (obj1) {
5984 {
5985 arg2 = wxString_in_helper(obj1);
5986 if (arg2 == NULL) SWIG_fail;
5987 temp2 = true;
5988 }
5989 }
5990 if (obj2) {
5991 {
5992 arg3 = wxString_in_helper(obj2);
5993 if (arg3 == NULL) SWIG_fail;
5994 temp3 = true;
5995 }
5996 }
5997 if (obj3) {
5998 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5999 if (!SWIG_IsOK(res4)) {
6000 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6001 }
6002 arg4 = reinterpret_cast< wxWindow * >(argp4);
6003 }
6004 if (obj4) {
6005 ecode5 = SWIG_AsVal_int(obj4, &val5);
6006 if (!SWIG_IsOK(ecode5)) {
6007 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6008 }
6009 arg5 = static_cast< int >(val5);
6010 }
6011 if (obj5) {
6012 ecode6 = SWIG_AsVal_int(obj5, &val6);
6013 if (!SWIG_IsOK(ecode6)) {
6014 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6015 }
6016 arg6 = static_cast< int >(val6);
6017 }
6018 if (obj6) {
6019 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6020 if (!SWIG_IsOK(ecode7)) {
6021 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6022 }
6023 arg7 = static_cast< bool >(val7);
6024 }
6025 {
6026 if (!wxPyCheckForApp()) SWIG_fail;
6027 PyThreadState* __tstate = wxPyBeginAllowThreads();
6028 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 {
6033 #if wxUSE_UNICODE
6034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6035 #else
6036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6037 #endif
6038 }
6039 {
6040 if (temp1)
6041 delete arg1;
6042 }
6043 {
6044 if (temp2)
6045 delete arg2;
6046 }
6047 {
6048 if (temp3)
6049 delete arg3;
6050 }
6051 return resultobj;
6052 fail:
6053 {
6054 if (temp1)
6055 delete arg1;
6056 }
6057 {
6058 if (temp2)
6059 delete arg2;
6060 }
6061 {
6062 if (temp3)
6063 delete arg3;
6064 }
6065 return NULL;
6066 }
6067
6068
6069 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj = 0;
6071 wxString *arg1 = 0 ;
6072 wxString const &arg2_defvalue = wxPyEmptyString ;
6073 wxString *arg2 = (wxString *) &arg2_defvalue ;
6074 wxString const &arg3_defvalue = wxPyEmptyString ;
6075 wxString *arg3 = (wxString *) &arg3_defvalue ;
6076 wxWindow *arg4 = (wxWindow *) NULL ;
6077 wxString result;
6078 bool temp1 = false ;
6079 bool temp2 = false ;
6080 bool temp3 = false ;
6081 void *argp4 = 0 ;
6082 int res4 = 0 ;
6083 PyObject * obj0 = 0 ;
6084 PyObject * obj1 = 0 ;
6085 PyObject * obj2 = 0 ;
6086 PyObject * obj3 = 0 ;
6087 char * kwnames[] = {
6088 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6089 };
6090
6091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6092 {
6093 arg1 = wxString_in_helper(obj0);
6094 if (arg1 == NULL) SWIG_fail;
6095 temp1 = true;
6096 }
6097 if (obj1) {
6098 {
6099 arg2 = wxString_in_helper(obj1);
6100 if (arg2 == NULL) SWIG_fail;
6101 temp2 = true;
6102 }
6103 }
6104 if (obj2) {
6105 {
6106 arg3 = wxString_in_helper(obj2);
6107 if (arg3 == NULL) SWIG_fail;
6108 temp3 = true;
6109 }
6110 }
6111 if (obj3) {
6112 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6113 if (!SWIG_IsOK(res4)) {
6114 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6115 }
6116 arg4 = reinterpret_cast< wxWindow * >(argp4);
6117 }
6118 {
6119 if (!wxPyCheckForApp()) SWIG_fail;
6120 PyThreadState* __tstate = wxPyBeginAllowThreads();
6121 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6122 wxPyEndAllowThreads(__tstate);
6123 if (PyErr_Occurred()) SWIG_fail;
6124 }
6125 {
6126 #if wxUSE_UNICODE
6127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6128 #else
6129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6130 #endif
6131 }
6132 {
6133 if (temp1)
6134 delete arg1;
6135 }
6136 {
6137 if (temp2)
6138 delete arg2;
6139 }
6140 {
6141 if (temp3)
6142 delete arg3;
6143 }
6144 return resultobj;
6145 fail:
6146 {
6147 if (temp1)
6148 delete arg1;
6149 }
6150 {
6151 if (temp2)
6152 delete arg2;
6153 }
6154 {
6155 if (temp3)
6156 delete arg3;
6157 }
6158 return NULL;
6159 }
6160
6161
6162 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6163 PyObject *resultobj = 0;
6164 wxString *arg1 = 0 ;
6165 wxString *arg2 = 0 ;
6166 int arg3 ;
6167 wxString *arg4 = (wxString *) 0 ;
6168 wxWindow *arg5 = (wxWindow *) NULL ;
6169 int arg6 = (int) -1 ;
6170 int arg7 = (int) -1 ;
6171 bool arg8 = (bool) true ;
6172 int arg9 = (int) 150 ;
6173 int arg10 = (int) 200 ;
6174 wxString result;
6175 bool temp1 = false ;
6176 bool temp2 = false ;
6177 void *argp5 = 0 ;
6178 int res5 = 0 ;
6179 int val6 ;
6180 int ecode6 = 0 ;
6181 int val7 ;
6182 int ecode7 = 0 ;
6183 bool val8 ;
6184 int ecode8 = 0 ;
6185 int val9 ;
6186 int ecode9 = 0 ;
6187 int val10 ;
6188 int ecode10 = 0 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 PyObject * obj2 = 0 ;
6192 PyObject * obj3 = 0 ;
6193 PyObject * obj4 = 0 ;
6194 PyObject * obj5 = 0 ;
6195 PyObject * obj6 = 0 ;
6196 PyObject * obj7 = 0 ;
6197 PyObject * obj8 = 0 ;
6198 char * kwnames[] = {
6199 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6200 };
6201
6202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6203 {
6204 arg1 = wxString_in_helper(obj0);
6205 if (arg1 == NULL) SWIG_fail;
6206 temp1 = true;
6207 }
6208 {
6209 arg2 = wxString_in_helper(obj1);
6210 if (arg2 == NULL) SWIG_fail;
6211 temp2 = true;
6212 }
6213 {
6214 arg3 = PyList_Size(obj2);
6215 arg4 = wxString_LIST_helper(obj2);
6216 if (arg4 == NULL) SWIG_fail;
6217 }
6218 if (obj3) {
6219 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6220 if (!SWIG_IsOK(res5)) {
6221 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6222 }
6223 arg5 = reinterpret_cast< wxWindow * >(argp5);
6224 }
6225 if (obj4) {
6226 ecode6 = SWIG_AsVal_int(obj4, &val6);
6227 if (!SWIG_IsOK(ecode6)) {
6228 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6229 }
6230 arg6 = static_cast< int >(val6);
6231 }
6232 if (obj5) {
6233 ecode7 = SWIG_AsVal_int(obj5, &val7);
6234 if (!SWIG_IsOK(ecode7)) {
6235 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6236 }
6237 arg7 = static_cast< int >(val7);
6238 }
6239 if (obj6) {
6240 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6241 if (!SWIG_IsOK(ecode8)) {
6242 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6243 }
6244 arg8 = static_cast< bool >(val8);
6245 }
6246 if (obj7) {
6247 ecode9 = SWIG_AsVal_int(obj7, &val9);
6248 if (!SWIG_IsOK(ecode9)) {
6249 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6250 }
6251 arg9 = static_cast< int >(val9);
6252 }
6253 if (obj8) {
6254 ecode10 = SWIG_AsVal_int(obj8, &val10);
6255 if (!SWIG_IsOK(ecode10)) {
6256 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6257 }
6258 arg10 = static_cast< int >(val10);
6259 }
6260 {
6261 if (!wxPyCheckForApp()) SWIG_fail;
6262 PyThreadState* __tstate = wxPyBeginAllowThreads();
6263 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6264 wxPyEndAllowThreads(__tstate);
6265 if (PyErr_Occurred()) SWIG_fail;
6266 }
6267 {
6268 #if wxUSE_UNICODE
6269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6270 #else
6271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6272 #endif
6273 }
6274 {
6275 if (temp1)
6276 delete arg1;
6277 }
6278 {
6279 if (temp2)
6280 delete arg2;
6281 }
6282 {
6283 if (arg4) delete [] arg4;
6284 }
6285 return resultobj;
6286 fail:
6287 {
6288 if (temp1)
6289 delete arg1;
6290 }
6291 {
6292 if (temp2)
6293 delete arg2;
6294 }
6295 {
6296 if (arg4) delete [] arg4;
6297 }
6298 return NULL;
6299 }
6300
6301
6302 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxString *arg1 = 0 ;
6305 wxString *arg2 = 0 ;
6306 int arg3 ;
6307 wxString *arg4 = (wxString *) 0 ;
6308 wxWindow *arg5 = (wxWindow *) NULL ;
6309 int arg6 = (int) -1 ;
6310 int arg7 = (int) -1 ;
6311 bool arg8 = (bool) true ;
6312 int arg9 = (int) 150 ;
6313 int arg10 = (int) 200 ;
6314 int result;
6315 bool temp1 = false ;
6316 bool temp2 = false ;
6317 void *argp5 = 0 ;
6318 int res5 = 0 ;
6319 int val6 ;
6320 int ecode6 = 0 ;
6321 int val7 ;
6322 int ecode7 = 0 ;
6323 bool val8 ;
6324 int ecode8 = 0 ;
6325 int val9 ;
6326 int ecode9 = 0 ;
6327 int val10 ;
6328 int ecode10 = 0 ;
6329 PyObject * obj0 = 0 ;
6330 PyObject * obj1 = 0 ;
6331 PyObject * obj2 = 0 ;
6332 PyObject * obj3 = 0 ;
6333 PyObject * obj4 = 0 ;
6334 PyObject * obj5 = 0 ;
6335 PyObject * obj6 = 0 ;
6336 PyObject * obj7 = 0 ;
6337 PyObject * obj8 = 0 ;
6338 char * kwnames[] = {
6339 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6340 };
6341
6342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6343 {
6344 arg1 = wxString_in_helper(obj0);
6345 if (arg1 == NULL) SWIG_fail;
6346 temp1 = true;
6347 }
6348 {
6349 arg2 = wxString_in_helper(obj1);
6350 if (arg2 == NULL) SWIG_fail;
6351 temp2 = true;
6352 }
6353 {
6354 arg3 = PyList_Size(obj2);
6355 arg4 = wxString_LIST_helper(obj2);
6356 if (arg4 == NULL) SWIG_fail;
6357 }
6358 if (obj3) {
6359 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6360 if (!SWIG_IsOK(res5)) {
6361 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6362 }
6363 arg5 = reinterpret_cast< wxWindow * >(argp5);
6364 }
6365 if (obj4) {
6366 ecode6 = SWIG_AsVal_int(obj4, &val6);
6367 if (!SWIG_IsOK(ecode6)) {
6368 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6369 }
6370 arg6 = static_cast< int >(val6);
6371 }
6372 if (obj5) {
6373 ecode7 = SWIG_AsVal_int(obj5, &val7);
6374 if (!SWIG_IsOK(ecode7)) {
6375 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6376 }
6377 arg7 = static_cast< int >(val7);
6378 }
6379 if (obj6) {
6380 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6381 if (!SWIG_IsOK(ecode8)) {
6382 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6383 }
6384 arg8 = static_cast< bool >(val8);
6385 }
6386 if (obj7) {
6387 ecode9 = SWIG_AsVal_int(obj7, &val9);
6388 if (!SWIG_IsOK(ecode9)) {
6389 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6390 }
6391 arg9 = static_cast< int >(val9);
6392 }
6393 if (obj8) {
6394 ecode10 = SWIG_AsVal_int(obj8, &val10);
6395 if (!SWIG_IsOK(ecode10)) {
6396 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6397 }
6398 arg10 = static_cast< int >(val10);
6399 }
6400 {
6401 if (!wxPyCheckForApp()) SWIG_fail;
6402 PyThreadState* __tstate = wxPyBeginAllowThreads();
6403 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6404 wxPyEndAllowThreads(__tstate);
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 resultobj = SWIG_From_int(static_cast< int >(result));
6408 {
6409 if (temp1)
6410 delete arg1;
6411 }
6412 {
6413 if (temp2)
6414 delete arg2;
6415 }
6416 {
6417 if (arg4) delete [] arg4;
6418 }
6419 return resultobj;
6420 fail:
6421 {
6422 if (temp1)
6423 delete arg1;
6424 }
6425 {
6426 if (temp2)
6427 delete arg2;
6428 }
6429 {
6430 if (arg4) delete [] arg4;
6431 }
6432 return NULL;
6433 }
6434
6435
6436 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6437 PyObject *resultobj = 0;
6438 wxString *arg1 = 0 ;
6439 wxString const &arg2_defvalue = wxPyEmptyString ;
6440 wxString *arg2 = (wxString *) &arg2_defvalue ;
6441 int arg3 = (int) wxOK|wxCENTRE ;
6442 wxWindow *arg4 = (wxWindow *) NULL ;
6443 int arg5 = (int) -1 ;
6444 int arg6 = (int) -1 ;
6445 int result;
6446 bool temp1 = false ;
6447 bool temp2 = false ;
6448 int val3 ;
6449 int ecode3 = 0 ;
6450 void *argp4 = 0 ;
6451 int res4 = 0 ;
6452 int val5 ;
6453 int ecode5 = 0 ;
6454 int val6 ;
6455 int ecode6 = 0 ;
6456 PyObject * obj0 = 0 ;
6457 PyObject * obj1 = 0 ;
6458 PyObject * obj2 = 0 ;
6459 PyObject * obj3 = 0 ;
6460 PyObject * obj4 = 0 ;
6461 PyObject * obj5 = 0 ;
6462 char * kwnames[] = {
6463 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6464 };
6465
6466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6467 {
6468 arg1 = wxString_in_helper(obj0);
6469 if (arg1 == NULL) SWIG_fail;
6470 temp1 = true;
6471 }
6472 if (obj1) {
6473 {
6474 arg2 = wxString_in_helper(obj1);
6475 if (arg2 == NULL) SWIG_fail;
6476 temp2 = true;
6477 }
6478 }
6479 if (obj2) {
6480 ecode3 = SWIG_AsVal_int(obj2, &val3);
6481 if (!SWIG_IsOK(ecode3)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6483 }
6484 arg3 = static_cast< int >(val3);
6485 }
6486 if (obj3) {
6487 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6488 if (!SWIG_IsOK(res4)) {
6489 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6490 }
6491 arg4 = reinterpret_cast< wxWindow * >(argp4);
6492 }
6493 if (obj4) {
6494 ecode5 = SWIG_AsVal_int(obj4, &val5);
6495 if (!SWIG_IsOK(ecode5)) {
6496 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6497 }
6498 arg5 = static_cast< int >(val5);
6499 }
6500 if (obj5) {
6501 ecode6 = SWIG_AsVal_int(obj5, &val6);
6502 if (!SWIG_IsOK(ecode6)) {
6503 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6504 }
6505 arg6 = static_cast< int >(val6);
6506 }
6507 {
6508 if (!wxPyCheckForApp()) SWIG_fail;
6509 PyThreadState* __tstate = wxPyBeginAllowThreads();
6510 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 resultobj = SWIG_From_int(static_cast< int >(result));
6515 {
6516 if (temp1)
6517 delete arg1;
6518 }
6519 {
6520 if (temp2)
6521 delete arg2;
6522 }
6523 return resultobj;
6524 fail:
6525 {
6526 if (temp1)
6527 delete arg1;
6528 }
6529 {
6530 if (temp2)
6531 delete arg2;
6532 }
6533 return NULL;
6534 }
6535
6536
6537 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6538 PyObject *resultobj = 0;
6539 bool result;
6540
6541 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6542 {
6543 if (!wxPyCheckForApp()) SWIG_fail;
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 result = (bool)wxColourDisplay();
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 {
6550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6551 }
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6559 PyObject *resultobj = 0;
6560 int result;
6561
6562 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6563 {
6564 if (!wxPyCheckForApp()) SWIG_fail;
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 result = (int)wxDisplayDepth();
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 resultobj = SWIG_From_int(static_cast< int >(result));
6571 return resultobj;
6572 fail:
6573 return NULL;
6574 }
6575
6576
6577 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6578 PyObject *resultobj = 0;
6579 int result;
6580
6581 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6582 {
6583 if (!wxPyCheckForApp()) SWIG_fail;
6584 PyThreadState* __tstate = wxPyBeginAllowThreads();
6585 result = (int)wxGetDisplayDepth();
6586 wxPyEndAllowThreads(__tstate);
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 resultobj = SWIG_From_int(static_cast< int >(result));
6590 return resultobj;
6591 fail:
6592 return NULL;
6593 }
6594
6595
6596 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6597 PyObject *resultobj = 0;
6598 int *arg1 = (int *) 0 ;
6599 int *arg2 = (int *) 0 ;
6600 int temp1 ;
6601 int res1 = SWIG_TMPOBJ ;
6602 int temp2 ;
6603 int res2 = SWIG_TMPOBJ ;
6604
6605 arg1 = &temp1;
6606 arg2 = &temp2;
6607 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6608 {
6609 if (!wxPyCheckForApp()) SWIG_fail;
6610 PyThreadState* __tstate = wxPyBeginAllowThreads();
6611 wxDisplaySize(arg1,arg2);
6612 wxPyEndAllowThreads(__tstate);
6613 if (PyErr_Occurred()) SWIG_fail;
6614 }
6615 resultobj = SWIG_Py_Void();
6616 if (SWIG_IsTmpObj(res1)) {
6617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6618 } else {
6619 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6621 }
6622 if (SWIG_IsTmpObj(res2)) {
6623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6624 } else {
6625 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6627 }
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6635 PyObject *resultobj = 0;
6636 wxSize result;
6637
6638 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6639 {
6640 if (!wxPyCheckForApp()) SWIG_fail;
6641 PyThreadState* __tstate = wxPyBeginAllowThreads();
6642 result = wxGetDisplaySize();
6643 wxPyEndAllowThreads(__tstate);
6644 if (PyErr_Occurred()) SWIG_fail;
6645 }
6646 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6647 return resultobj;
6648 fail:
6649 return NULL;
6650 }
6651
6652
6653 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6654 PyObject *resultobj = 0;
6655 int *arg1 = (int *) 0 ;
6656 int *arg2 = (int *) 0 ;
6657 int temp1 ;
6658 int res1 = SWIG_TMPOBJ ;
6659 int temp2 ;
6660 int res2 = SWIG_TMPOBJ ;
6661
6662 arg1 = &temp1;
6663 arg2 = &temp2;
6664 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6665 {
6666 if (!wxPyCheckForApp()) SWIG_fail;
6667 PyThreadState* __tstate = wxPyBeginAllowThreads();
6668 wxDisplaySizeMM(arg1,arg2);
6669 wxPyEndAllowThreads(__tstate);
6670 if (PyErr_Occurred()) SWIG_fail;
6671 }
6672 resultobj = SWIG_Py_Void();
6673 if (SWIG_IsTmpObj(res1)) {
6674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6675 } else {
6676 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6678 }
6679 if (SWIG_IsTmpObj(res2)) {
6680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6681 } else {
6682 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6684 }
6685 return resultobj;
6686 fail:
6687 return NULL;
6688 }
6689
6690
6691 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6692 PyObject *resultobj = 0;
6693 wxSize result;
6694
6695 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6696 {
6697 if (!wxPyCheckForApp()) SWIG_fail;
6698 PyThreadState* __tstate = wxPyBeginAllowThreads();
6699 result = wxGetDisplaySizeMM();
6700 wxPyEndAllowThreads(__tstate);
6701 if (PyErr_Occurred()) SWIG_fail;
6702 }
6703 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6704 return resultobj;
6705 fail:
6706 return NULL;
6707 }
6708
6709
6710 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6711 PyObject *resultobj = 0;
6712 int *arg1 = (int *) 0 ;
6713 int *arg2 = (int *) 0 ;
6714 int *arg3 = (int *) 0 ;
6715 int *arg4 = (int *) 0 ;
6716 int temp1 ;
6717 int res1 = SWIG_TMPOBJ ;
6718 int temp2 ;
6719 int res2 = SWIG_TMPOBJ ;
6720 int temp3 ;
6721 int res3 = SWIG_TMPOBJ ;
6722 int temp4 ;
6723 int res4 = SWIG_TMPOBJ ;
6724
6725 arg1 = &temp1;
6726 arg2 = &temp2;
6727 arg3 = &temp3;
6728 arg4 = &temp4;
6729 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6730 {
6731 if (!wxPyCheckForApp()) SWIG_fail;
6732 PyThreadState* __tstate = wxPyBeginAllowThreads();
6733 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 resultobj = SWIG_Py_Void();
6738 if (SWIG_IsTmpObj(res1)) {
6739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6740 } else {
6741 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6743 }
6744 if (SWIG_IsTmpObj(res2)) {
6745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6746 } else {
6747 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6749 }
6750 if (SWIG_IsTmpObj(res3)) {
6751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6752 } else {
6753 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6755 }
6756 if (SWIG_IsTmpObj(res4)) {
6757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6758 } else {
6759 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6761 }
6762 return resultobj;
6763 fail:
6764 return NULL;
6765 }
6766
6767
6768 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6769 PyObject *resultobj = 0;
6770 wxRect result;
6771
6772 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6773 {
6774 if (!wxPyCheckForApp()) SWIG_fail;
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 result = wxGetClientDisplayRect();
6777 wxPyEndAllowThreads(__tstate);
6778 if (PyErr_Occurred()) SWIG_fail;
6779 }
6780 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6788 PyObject *resultobj = 0;
6789 wxCursor *arg1 = 0 ;
6790 void *argp1 = 0 ;
6791 int res1 = 0 ;
6792 PyObject * obj0 = 0 ;
6793 char * kwnames[] = {
6794 (char *) "cursor", NULL
6795 };
6796
6797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6798 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6799 if (!SWIG_IsOK(res1)) {
6800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6801 }
6802 if (!argp1) {
6803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6804 }
6805 arg1 = reinterpret_cast< wxCursor * >(argp1);
6806 {
6807 if (!wxPyCheckForApp()) SWIG_fail;
6808 PyThreadState* __tstate = wxPyBeginAllowThreads();
6809 wxSetCursor(*arg1);
6810 wxPyEndAllowThreads(__tstate);
6811 if (PyErr_Occurred()) SWIG_fail;
6812 }
6813 resultobj = SWIG_Py_Void();
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6821 PyObject *resultobj = 0;
6822 void *result = 0 ;
6823
6824 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6825 {
6826 if (!wxPyCheckForApp()) SWIG_fail;
6827 PyThreadState* __tstate = wxPyBeginAllowThreads();
6828 result = (void *)wxGetXDisplay();
6829 wxPyEndAllowThreads(__tstate);
6830 if (PyErr_Occurred()) SWIG_fail;
6831 }
6832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6840 PyObject *resultobj = 0;
6841 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6842 void *argp1 = 0 ;
6843 int res1 = 0 ;
6844 PyObject * obj0 = 0 ;
6845 char * kwnames[] = {
6846 (char *) "cursor", NULL
6847 };
6848
6849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6850 if (obj0) {
6851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6852 if (!SWIG_IsOK(res1)) {
6853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6854 }
6855 arg1 = reinterpret_cast< wxCursor * >(argp1);
6856 }
6857 {
6858 if (!wxPyCheckForApp()) SWIG_fail;
6859 PyThreadState* __tstate = wxPyBeginAllowThreads();
6860 wxBeginBusyCursor(arg1);
6861 wxPyEndAllowThreads(__tstate);
6862 if (PyErr_Occurred()) SWIG_fail;
6863 }
6864 resultobj = SWIG_Py_Void();
6865 return resultobj;
6866 fail:
6867 return NULL;
6868 }
6869
6870
6871 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6872 PyObject *resultobj = 0;
6873 wxPoint result;
6874
6875 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6876 {
6877 if (!wxPyCheckForApp()) SWIG_fail;
6878 PyThreadState* __tstate = wxPyBeginAllowThreads();
6879 result = wxGetMousePosition();
6880 wxPyEndAllowThreads(__tstate);
6881 if (PyErr_Occurred()) SWIG_fail;
6882 }
6883 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6884 return resultobj;
6885 fail:
6886 return NULL;
6887 }
6888
6889
6890 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6891 PyObject *resultobj = 0;
6892 wxWindow *result = 0 ;
6893
6894 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6895 {
6896 if (!wxPyCheckForApp()) SWIG_fail;
6897 PyThreadState* __tstate = wxPyBeginAllowThreads();
6898 result = (wxWindow *)FindWindowAtPointer();
6899 wxPyEndAllowThreads(__tstate);
6900 if (PyErr_Occurred()) SWIG_fail;
6901 }
6902 {
6903 resultobj = wxPyMake_wxObject(result, 0);
6904 }
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6912 PyObject *resultobj = 0;
6913 wxWindow *result = 0 ;
6914
6915 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6916 {
6917 if (!wxPyCheckForApp()) SWIG_fail;
6918 PyThreadState* __tstate = wxPyBeginAllowThreads();
6919 result = (wxWindow *)wxGetActiveWindow();
6920 wxPyEndAllowThreads(__tstate);
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 {
6924 resultobj = wxPyMake_wxObject(result, 0);
6925 }
6926 return resultobj;
6927 fail:
6928 return NULL;
6929 }
6930
6931
6932 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6933 PyObject *resultobj = 0;
6934 wxPoint *arg1 = 0 ;
6935 wxWindow *result = 0 ;
6936 wxPoint temp1 ;
6937 PyObject * obj0 = 0 ;
6938 char * kwnames[] = {
6939 (char *) "pt", NULL
6940 };
6941
6942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6943 {
6944 arg1 = &temp1;
6945 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6946 }
6947 {
6948 if (!wxPyCheckForApp()) SWIG_fail;
6949 PyThreadState* __tstate = wxPyBeginAllowThreads();
6950 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 {
6955 resultobj = wxPyMake_wxObject(result, 0);
6956 }
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj = 0;
6965 wxPoint *arg1 = 0 ;
6966 wxWindow *result = 0 ;
6967 wxPoint temp1 ;
6968 PyObject * obj0 = 0 ;
6969 char * kwnames[] = {
6970 (char *) "pt", NULL
6971 };
6972
6973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6974 {
6975 arg1 = &temp1;
6976 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6977 }
6978 {
6979 if (!wxPyCheckForApp()) SWIG_fail;
6980 PyThreadState* __tstate = wxPyBeginAllowThreads();
6981 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6982 wxPyEndAllowThreads(__tstate);
6983 if (PyErr_Occurred()) SWIG_fail;
6984 }
6985 {
6986 resultobj = wxPyMake_wxObject(result, 0);
6987 }
6988 return resultobj;
6989 fail:
6990 return NULL;
6991 }
6992
6993
6994 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6995 PyObject *resultobj = 0;
6996 wxWindow *arg1 = (wxWindow *) 0 ;
6997 wxWindow *result = 0 ;
6998 void *argp1 = 0 ;
6999 int res1 = 0 ;
7000 PyObject * obj0 = 0 ;
7001 char * kwnames[] = {
7002 (char *) "win", NULL
7003 };
7004
7005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7007 if (!SWIG_IsOK(res1)) {
7008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7009 }
7010 arg1 = reinterpret_cast< wxWindow * >(argp1);
7011 {
7012 if (!wxPyCheckForApp()) SWIG_fail;
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 result = (wxWindow *)wxGetTopLevelParent(arg1);
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 {
7019 resultobj = wxPyMake_wxObject(result, 0);
7020 }
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj = 0;
7029 wxString *arg1 = 0 ;
7030 bool result;
7031 bool temp1 = false ;
7032 PyObject * obj0 = 0 ;
7033 char * kwnames[] = {
7034 (char *) "url", NULL
7035 };
7036
7037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7038 {
7039 arg1 = wxString_in_helper(obj0);
7040 if (arg1 == NULL) SWIG_fail;
7041 temp1 = true;
7042 }
7043 {
7044 PyThreadState* __tstate = wxPyBeginAllowThreads();
7045 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 {
7050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7051 }
7052 {
7053 if (temp1)
7054 delete arg1;
7055 }
7056 return resultobj;
7057 fail:
7058 {
7059 if (temp1)
7060 delete arg1;
7061 }
7062 return NULL;
7063 }
7064
7065
7066 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj = 0;
7068 wxKeyCode arg1 ;
7069 bool result;
7070 int val1 ;
7071 int ecode1 = 0 ;
7072 PyObject * obj0 = 0 ;
7073 char * kwnames[] = {
7074 (char *) "key", NULL
7075 };
7076
7077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7078 ecode1 = SWIG_AsVal_int(obj0, &val1);
7079 if (!SWIG_IsOK(ecode1)) {
7080 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7081 }
7082 arg1 = static_cast< wxKeyCode >(val1);
7083 {
7084 if (!wxPyCheckForApp()) SWIG_fail;
7085 PyThreadState* __tstate = wxPyBeginAllowThreads();
7086 result = (bool)wxGetKeyState(arg1);
7087 wxPyEndAllowThreads(__tstate);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 {
7091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7092 }
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7100 PyObject *resultobj = 0;
7101 wxMouseState *result = 0 ;
7102
7103 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7104 {
7105 PyThreadState* __tstate = wxPyBeginAllowThreads();
7106 result = (wxMouseState *)new wxMouseState();
7107 wxPyEndAllowThreads(__tstate);
7108 if (PyErr_Occurred()) SWIG_fail;
7109 }
7110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7111 return resultobj;
7112 fail:
7113 return NULL;
7114 }
7115
7116
7117 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7118 PyObject *resultobj = 0;
7119 wxMouseState *arg1 = (wxMouseState *) 0 ;
7120 void *argp1 = 0 ;
7121 int res1 = 0 ;
7122 PyObject *swig_obj[1] ;
7123
7124 if (!args) SWIG_fail;
7125 swig_obj[0] = args;
7126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7127 if (!SWIG_IsOK(res1)) {
7128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7129 }
7130 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7131 {
7132 PyThreadState* __tstate = wxPyBeginAllowThreads();
7133 delete arg1;
7134
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 resultobj = SWIG_Py_Void();
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7146 PyObject *resultobj = 0;
7147 wxMouseState *arg1 = (wxMouseState *) 0 ;
7148 int result;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 PyObject *swig_obj[1] ;
7152
7153 if (!args) SWIG_fail;
7154 swig_obj[0] = args;
7155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7156 if (!SWIG_IsOK(res1)) {
7157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7158 }
7159 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7160 {
7161 PyThreadState* __tstate = wxPyBeginAllowThreads();
7162 result = (int)(arg1)->GetX();
7163 wxPyEndAllowThreads(__tstate);
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 resultobj = SWIG_From_int(static_cast< int >(result));
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7174 PyObject *resultobj = 0;
7175 wxMouseState *arg1 = (wxMouseState *) 0 ;
7176 int result;
7177 void *argp1 = 0 ;
7178 int res1 = 0 ;
7179 PyObject *swig_obj[1] ;
7180
7181 if (!args) SWIG_fail;
7182 swig_obj[0] = args;
7183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7184 if (!SWIG_IsOK(res1)) {
7185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7186 }
7187 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7188 {
7189 PyThreadState* __tstate = wxPyBeginAllowThreads();
7190 result = (int)(arg1)->GetY();
7191 wxPyEndAllowThreads(__tstate);
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 resultobj = SWIG_From_int(static_cast< int >(result));
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7202 PyObject *resultobj = 0;
7203 wxMouseState *arg1 = (wxMouseState *) 0 ;
7204 bool result;
7205 void *argp1 = 0 ;
7206 int res1 = 0 ;
7207 PyObject *swig_obj[1] ;
7208
7209 if (!args) SWIG_fail;
7210 swig_obj[0] = args;
7211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7212 if (!SWIG_IsOK(res1)) {
7213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7214 }
7215 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7216 {
7217 PyThreadState* __tstate = wxPyBeginAllowThreads();
7218 result = (bool)(arg1)->LeftDown();
7219 wxPyEndAllowThreads(__tstate);
7220 if (PyErr_Occurred()) SWIG_fail;
7221 }
7222 {
7223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7224 }
7225 return resultobj;
7226 fail:
7227 return NULL;
7228 }
7229
7230
7231 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7232 PyObject *resultobj = 0;
7233 wxMouseState *arg1 = (wxMouseState *) 0 ;
7234 bool result;
7235 void *argp1 = 0 ;
7236 int res1 = 0 ;
7237 PyObject *swig_obj[1] ;
7238
7239 if (!args) SWIG_fail;
7240 swig_obj[0] = args;
7241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7242 if (!SWIG_IsOK(res1)) {
7243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7244 }
7245 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (bool)(arg1)->MiddleDown();
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 {
7253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7254 }
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7262 PyObject *resultobj = 0;
7263 wxMouseState *arg1 = (wxMouseState *) 0 ;
7264 bool result;
7265 void *argp1 = 0 ;
7266 int res1 = 0 ;
7267 PyObject *swig_obj[1] ;
7268
7269 if (!args) SWIG_fail;
7270 swig_obj[0] = args;
7271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7272 if (!SWIG_IsOK(res1)) {
7273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7274 }
7275 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (bool)(arg1)->RightDown();
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 {
7283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7284 }
7285 return resultobj;
7286 fail:
7287 return NULL;
7288 }
7289
7290
7291 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7292 PyObject *resultobj = 0;
7293 wxMouseState *arg1 = (wxMouseState *) 0 ;
7294 bool result;
7295 void *argp1 = 0 ;
7296 int res1 = 0 ;
7297 PyObject *swig_obj[1] ;
7298
7299 if (!args) SWIG_fail;
7300 swig_obj[0] = args;
7301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7302 if (!SWIG_IsOK(res1)) {
7303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7304 }
7305 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (bool)(arg1)->ControlDown();
7309 wxPyEndAllowThreads(__tstate);
7310 if (PyErr_Occurred()) SWIG_fail;
7311 }
7312 {
7313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7314 }
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7322 PyObject *resultobj = 0;
7323 wxMouseState *arg1 = (wxMouseState *) 0 ;
7324 bool result;
7325 void *argp1 = 0 ;
7326 int res1 = 0 ;
7327 PyObject *swig_obj[1] ;
7328
7329 if (!args) SWIG_fail;
7330 swig_obj[0] = args;
7331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7332 if (!SWIG_IsOK(res1)) {
7333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7334 }
7335 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7336 {
7337 PyThreadState* __tstate = wxPyBeginAllowThreads();
7338 result = (bool)(arg1)->ShiftDown();
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 {
7343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7344 }
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7352 PyObject *resultobj = 0;
7353 wxMouseState *arg1 = (wxMouseState *) 0 ;
7354 bool result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 PyObject *swig_obj[1] ;
7358
7359 if (!args) SWIG_fail;
7360 swig_obj[0] = args;
7361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7362 if (!SWIG_IsOK(res1)) {
7363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7364 }
7365 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 result = (bool)(arg1)->AltDown();
7369 wxPyEndAllowThreads(__tstate);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 {
7373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7374 }
7375 return resultobj;
7376 fail:
7377 return NULL;
7378 }
7379
7380
7381 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7382 PyObject *resultobj = 0;
7383 wxMouseState *arg1 = (wxMouseState *) 0 ;
7384 bool result;
7385 void *argp1 = 0 ;
7386 int res1 = 0 ;
7387 PyObject *swig_obj[1] ;
7388
7389 if (!args) SWIG_fail;
7390 swig_obj[0] = args;
7391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7392 if (!SWIG_IsOK(res1)) {
7393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7394 }
7395 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7396 {
7397 PyThreadState* __tstate = wxPyBeginAllowThreads();
7398 result = (bool)(arg1)->MetaDown();
7399 wxPyEndAllowThreads(__tstate);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 {
7403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7404 }
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7412 PyObject *resultobj = 0;
7413 wxMouseState *arg1 = (wxMouseState *) 0 ;
7414 bool result;
7415 void *argp1 = 0 ;
7416 int res1 = 0 ;
7417 PyObject *swig_obj[1] ;
7418
7419 if (!args) SWIG_fail;
7420 swig_obj[0] = args;
7421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7422 if (!SWIG_IsOK(res1)) {
7423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7424 }
7425 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7426 {
7427 PyThreadState* __tstate = wxPyBeginAllowThreads();
7428 result = (bool)(arg1)->CmdDown();
7429 wxPyEndAllowThreads(__tstate);
7430 if (PyErr_Occurred()) SWIG_fail;
7431 }
7432 {
7433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7434 }
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = 0;
7443 wxMouseState *arg1 = (wxMouseState *) 0 ;
7444 int arg2 ;
7445 void *argp1 = 0 ;
7446 int res1 = 0 ;
7447 int val2 ;
7448 int ecode2 = 0 ;
7449 PyObject * obj0 = 0 ;
7450 PyObject * obj1 = 0 ;
7451 char * kwnames[] = {
7452 (char *) "self",(char *) "x", NULL
7453 };
7454
7455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7457 if (!SWIG_IsOK(res1)) {
7458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7459 }
7460 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7461 ecode2 = SWIG_AsVal_int(obj1, &val2);
7462 if (!SWIG_IsOK(ecode2)) {
7463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7464 }
7465 arg2 = static_cast< int >(val2);
7466 {
7467 PyThreadState* __tstate = wxPyBeginAllowThreads();
7468 (arg1)->SetX(arg2);
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 resultobj = SWIG_Py_Void();
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7480 PyObject *resultobj = 0;
7481 wxMouseState *arg1 = (wxMouseState *) 0 ;
7482 int arg2 ;
7483 void *argp1 = 0 ;
7484 int res1 = 0 ;
7485 int val2 ;
7486 int ecode2 = 0 ;
7487 PyObject * obj0 = 0 ;
7488 PyObject * obj1 = 0 ;
7489 char * kwnames[] = {
7490 (char *) "self",(char *) "y", NULL
7491 };
7492
7493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7495 if (!SWIG_IsOK(res1)) {
7496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7497 }
7498 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7499 ecode2 = SWIG_AsVal_int(obj1, &val2);
7500 if (!SWIG_IsOK(ecode2)) {
7501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7502 }
7503 arg2 = static_cast< int >(val2);
7504 {
7505 PyThreadState* __tstate = wxPyBeginAllowThreads();
7506 (arg1)->SetY(arg2);
7507 wxPyEndAllowThreads(__tstate);
7508 if (PyErr_Occurred()) SWIG_fail;
7509 }
7510 resultobj = SWIG_Py_Void();
7511 return resultobj;
7512 fail:
7513 return NULL;
7514 }
7515
7516
7517 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7518 PyObject *resultobj = 0;
7519 wxMouseState *arg1 = (wxMouseState *) 0 ;
7520 bool arg2 ;
7521 void *argp1 = 0 ;
7522 int res1 = 0 ;
7523 bool val2 ;
7524 int ecode2 = 0 ;
7525 PyObject * obj0 = 0 ;
7526 PyObject * obj1 = 0 ;
7527 char * kwnames[] = {
7528 (char *) "self",(char *) "down", NULL
7529 };
7530
7531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7533 if (!SWIG_IsOK(res1)) {
7534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7535 }
7536 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7537 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7538 if (!SWIG_IsOK(ecode2)) {
7539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7540 }
7541 arg2 = static_cast< bool >(val2);
7542 {
7543 PyThreadState* __tstate = wxPyBeginAllowThreads();
7544 (arg1)->SetLeftDown(arg2);
7545 wxPyEndAllowThreads(__tstate);
7546 if (PyErr_Occurred()) SWIG_fail;
7547 }
7548 resultobj = SWIG_Py_Void();
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7556 PyObject *resultobj = 0;
7557 wxMouseState *arg1 = (wxMouseState *) 0 ;
7558 bool arg2 ;
7559 void *argp1 = 0 ;
7560 int res1 = 0 ;
7561 bool val2 ;
7562 int ecode2 = 0 ;
7563 PyObject * obj0 = 0 ;
7564 PyObject * obj1 = 0 ;
7565 char * kwnames[] = {
7566 (char *) "self",(char *) "down", NULL
7567 };
7568
7569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7571 if (!SWIG_IsOK(res1)) {
7572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7573 }
7574 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7575 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7576 if (!SWIG_IsOK(ecode2)) {
7577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7578 }
7579 arg2 = static_cast< bool >(val2);
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 (arg1)->SetMiddleDown(arg2);
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 resultobj = SWIG_Py_Void();
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7594 PyObject *resultobj = 0;
7595 wxMouseState *arg1 = (wxMouseState *) 0 ;
7596 bool arg2 ;
7597 void *argp1 = 0 ;
7598 int res1 = 0 ;
7599 bool val2 ;
7600 int ecode2 = 0 ;
7601 PyObject * obj0 = 0 ;
7602 PyObject * obj1 = 0 ;
7603 char * kwnames[] = {
7604 (char *) "self",(char *) "down", NULL
7605 };
7606
7607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7609 if (!SWIG_IsOK(res1)) {
7610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7611 }
7612 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7613 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7614 if (!SWIG_IsOK(ecode2)) {
7615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7616 }
7617 arg2 = static_cast< bool >(val2);
7618 {
7619 PyThreadState* __tstate = wxPyBeginAllowThreads();
7620 (arg1)->SetRightDown(arg2);
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 resultobj = SWIG_Py_Void();
7625 return resultobj;
7626 fail:
7627 return NULL;
7628 }
7629
7630
7631 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7632 PyObject *resultobj = 0;
7633 wxMouseState *arg1 = (wxMouseState *) 0 ;
7634 bool arg2 ;
7635 void *argp1 = 0 ;
7636 int res1 = 0 ;
7637 bool val2 ;
7638 int ecode2 = 0 ;
7639 PyObject * obj0 = 0 ;
7640 PyObject * obj1 = 0 ;
7641 char * kwnames[] = {
7642 (char *) "self",(char *) "down", NULL
7643 };
7644
7645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7647 if (!SWIG_IsOK(res1)) {
7648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7649 }
7650 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7651 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7652 if (!SWIG_IsOK(ecode2)) {
7653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7654 }
7655 arg2 = static_cast< bool >(val2);
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 (arg1)->SetControlDown(arg2);
7659 wxPyEndAllowThreads(__tstate);
7660 if (PyErr_Occurred()) SWIG_fail;
7661 }
7662 resultobj = SWIG_Py_Void();
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7670 PyObject *resultobj = 0;
7671 wxMouseState *arg1 = (wxMouseState *) 0 ;
7672 bool arg2 ;
7673 void *argp1 = 0 ;
7674 int res1 = 0 ;
7675 bool val2 ;
7676 int ecode2 = 0 ;
7677 PyObject * obj0 = 0 ;
7678 PyObject * obj1 = 0 ;
7679 char * kwnames[] = {
7680 (char *) "self",(char *) "down", NULL
7681 };
7682
7683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7685 if (!SWIG_IsOK(res1)) {
7686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7687 }
7688 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7689 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7690 if (!SWIG_IsOK(ecode2)) {
7691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7692 }
7693 arg2 = static_cast< bool >(val2);
7694 {
7695 PyThreadState* __tstate = wxPyBeginAllowThreads();
7696 (arg1)->SetShiftDown(arg2);
7697 wxPyEndAllowThreads(__tstate);
7698 if (PyErr_Occurred()) SWIG_fail;
7699 }
7700 resultobj = SWIG_Py_Void();
7701 return resultobj;
7702 fail:
7703 return NULL;
7704 }
7705
7706
7707 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7708 PyObject *resultobj = 0;
7709 wxMouseState *arg1 = (wxMouseState *) 0 ;
7710 bool arg2 ;
7711 void *argp1 = 0 ;
7712 int res1 = 0 ;
7713 bool val2 ;
7714 int ecode2 = 0 ;
7715 PyObject * obj0 = 0 ;
7716 PyObject * obj1 = 0 ;
7717 char * kwnames[] = {
7718 (char *) "self",(char *) "down", NULL
7719 };
7720
7721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7723 if (!SWIG_IsOK(res1)) {
7724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7725 }
7726 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7727 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7728 if (!SWIG_IsOK(ecode2)) {
7729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7730 }
7731 arg2 = static_cast< bool >(val2);
7732 {
7733 PyThreadState* __tstate = wxPyBeginAllowThreads();
7734 (arg1)->SetAltDown(arg2);
7735 wxPyEndAllowThreads(__tstate);
7736 if (PyErr_Occurred()) SWIG_fail;
7737 }
7738 resultobj = SWIG_Py_Void();
7739 return resultobj;
7740 fail:
7741 return NULL;
7742 }
7743
7744
7745 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7746 PyObject *resultobj = 0;
7747 wxMouseState *arg1 = (wxMouseState *) 0 ;
7748 bool arg2 ;
7749 void *argp1 = 0 ;
7750 int res1 = 0 ;
7751 bool val2 ;
7752 int ecode2 = 0 ;
7753 PyObject * obj0 = 0 ;
7754 PyObject * obj1 = 0 ;
7755 char * kwnames[] = {
7756 (char *) "self",(char *) "down", NULL
7757 };
7758
7759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7761 if (!SWIG_IsOK(res1)) {
7762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7763 }
7764 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7765 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7766 if (!SWIG_IsOK(ecode2)) {
7767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7768 }
7769 arg2 = static_cast< bool >(val2);
7770 {
7771 PyThreadState* __tstate = wxPyBeginAllowThreads();
7772 (arg1)->SetMetaDown(arg2);
7773 wxPyEndAllowThreads(__tstate);
7774 if (PyErr_Occurred()) SWIG_fail;
7775 }
7776 resultobj = SWIG_Py_Void();
7777 return resultobj;
7778 fail:
7779 return NULL;
7780 }
7781
7782
7783 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7784 PyObject *obj;
7785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7786 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7787 return SWIG_Py_Void();
7788 }
7789
7790 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7791 return SWIG_Python_InitShadowInstance(args);
7792 }
7793
7794 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7795 PyObject *resultobj = 0;
7796 wxMouseState result;
7797
7798 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7799 {
7800 PyThreadState* __tstate = wxPyBeginAllowThreads();
7801 result = wxGetMouseState();
7802 wxPyEndAllowThreads(__tstate);
7803 if (PyErr_Occurred()) SWIG_fail;
7804 }
7805 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7813 PyObject *resultobj = 0;
7814
7815 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7816 {
7817 if (!wxPyCheckForApp()) SWIG_fail;
7818 PyThreadState* __tstate = wxPyBeginAllowThreads();
7819 wxWakeUpMainThread();
7820 wxPyEndAllowThreads(__tstate);
7821 if (PyErr_Occurred()) SWIG_fail;
7822 }
7823 resultobj = SWIG_Py_Void();
7824 return resultobj;
7825 fail:
7826 return NULL;
7827 }
7828
7829
7830 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7831 PyObject *resultobj = 0;
7832
7833 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7834 {
7835 if (!wxPyCheckForApp()) SWIG_fail;
7836 PyThreadState* __tstate = wxPyBeginAllowThreads();
7837 wxMutexGuiEnter();
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 resultobj = SWIG_Py_Void();
7842 return resultobj;
7843 fail:
7844 return NULL;
7845 }
7846
7847
7848 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7849 PyObject *resultobj = 0;
7850
7851 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7852 {
7853 if (!wxPyCheckForApp()) SWIG_fail;
7854 PyThreadState* __tstate = wxPyBeginAllowThreads();
7855 wxMutexGuiLeave();
7856 wxPyEndAllowThreads(__tstate);
7857 if (PyErr_Occurred()) SWIG_fail;
7858 }
7859 resultobj = SWIG_Py_Void();
7860 return resultobj;
7861 fail:
7862 return NULL;
7863 }
7864
7865
7866 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7867 PyObject *resultobj = 0;
7868 wxMutexGuiLocker *result = 0 ;
7869
7870 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7871 {
7872 if (!wxPyCheckForApp()) SWIG_fail;
7873 PyThreadState* __tstate = wxPyBeginAllowThreads();
7874 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7875 wxPyEndAllowThreads(__tstate);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7879 return resultobj;
7880 fail:
7881 return NULL;
7882 }
7883
7884
7885 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7886 PyObject *resultobj = 0;
7887 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7888 void *argp1 = 0 ;
7889 int res1 = 0 ;
7890 PyObject *swig_obj[1] ;
7891
7892 if (!args) SWIG_fail;
7893 swig_obj[0] = args;
7894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7895 if (!SWIG_IsOK(res1)) {
7896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7897 }
7898 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 delete arg1;
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 resultobj = SWIG_Py_Void();
7907 return resultobj;
7908 fail:
7909 return NULL;
7910 }
7911
7912
7913 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7914 PyObject *obj;
7915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7916 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7917 return SWIG_Py_Void();
7918 }
7919
7920 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7921 return SWIG_Python_InitShadowInstance(args);
7922 }
7923
7924 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7925 PyObject *resultobj = 0;
7926 bool result;
7927
7928 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7929 {
7930 PyThreadState* __tstate = wxPyBeginAllowThreads();
7931 result = (bool)wxThread_IsMain();
7932 wxPyEndAllowThreads(__tstate);
7933 if (PyErr_Occurred()) SWIG_fail;
7934 }
7935 {
7936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7937 }
7938 return resultobj;
7939 fail:
7940 return NULL;
7941 }
7942
7943
7944 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7945 PyObject *resultobj = 0;
7946 wxString *arg1 = 0 ;
7947 wxToolTip *result = 0 ;
7948 bool temp1 = false ;
7949 PyObject * obj0 = 0 ;
7950 char * kwnames[] = {
7951 (char *) "tip", NULL
7952 };
7953
7954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7955 {
7956 arg1 = wxString_in_helper(obj0);
7957 if (arg1 == NULL) SWIG_fail;
7958 temp1 = true;
7959 }
7960 {
7961 if (!wxPyCheckForApp()) SWIG_fail;
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7968 {
7969 if (temp1)
7970 delete arg1;
7971 }
7972 return resultobj;
7973 fail:
7974 {
7975 if (temp1)
7976 delete arg1;
7977 }
7978 return NULL;
7979 }
7980
7981
7982 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7983 PyObject *resultobj = 0;
7984 wxToolTip *arg1 = (wxToolTip *) 0 ;
7985 void *argp1 = 0 ;
7986 int res1 = 0 ;
7987 PyObject *swig_obj[1] ;
7988
7989 if (!args) SWIG_fail;
7990 swig_obj[0] = args;
7991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
7992 if (!SWIG_IsOK(res1)) {
7993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
7994 }
7995 arg1 = reinterpret_cast< wxToolTip * >(argp1);
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 delete arg1;
7999
8000 wxPyEndAllowThreads(__tstate);
8001 if (PyErr_Occurred()) SWIG_fail;
8002 }
8003 resultobj = SWIG_Py_Void();
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8011 PyObject *resultobj = 0;
8012 wxToolTip *arg1 = (wxToolTip *) 0 ;
8013 wxString *arg2 = 0 ;
8014 void *argp1 = 0 ;
8015 int res1 = 0 ;
8016 bool temp2 = false ;
8017 PyObject * obj0 = 0 ;
8018 PyObject * obj1 = 0 ;
8019 char * kwnames[] = {
8020 (char *) "self",(char *) "tip", NULL
8021 };
8022
8023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8025 if (!SWIG_IsOK(res1)) {
8026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8027 }
8028 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8029 {
8030 arg2 = wxString_in_helper(obj1);
8031 if (arg2 == NULL) SWIG_fail;
8032 temp2 = true;
8033 }
8034 {
8035 PyThreadState* __tstate = wxPyBeginAllowThreads();
8036 (arg1)->SetTip((wxString const &)*arg2);
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 resultobj = SWIG_Py_Void();
8041 {
8042 if (temp2)
8043 delete arg2;
8044 }
8045 return resultobj;
8046 fail:
8047 {
8048 if (temp2)
8049 delete arg2;
8050 }
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8056 PyObject *resultobj = 0;
8057 wxToolTip *arg1 = (wxToolTip *) 0 ;
8058 wxString result;
8059 void *argp1 = 0 ;
8060 int res1 = 0 ;
8061 PyObject *swig_obj[1] ;
8062
8063 if (!args) SWIG_fail;
8064 swig_obj[0] = args;
8065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8066 if (!SWIG_IsOK(res1)) {
8067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8068 }
8069 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8070 {
8071 PyThreadState* __tstate = wxPyBeginAllowThreads();
8072 result = (arg1)->GetTip();
8073 wxPyEndAllowThreads(__tstate);
8074 if (PyErr_Occurred()) SWIG_fail;
8075 }
8076 {
8077 #if wxUSE_UNICODE
8078 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8079 #else
8080 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8081 #endif
8082 }
8083 return resultobj;
8084 fail:
8085 return NULL;
8086 }
8087
8088
8089 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8090 PyObject *resultobj = 0;
8091 wxToolTip *arg1 = (wxToolTip *) 0 ;
8092 wxWindow *result = 0 ;
8093 void *argp1 = 0 ;
8094 int res1 = 0 ;
8095 PyObject *swig_obj[1] ;
8096
8097 if (!args) SWIG_fail;
8098 swig_obj[0] = args;
8099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8100 if (!SWIG_IsOK(res1)) {
8101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8102 }
8103 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8104 {
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 result = (wxWindow *)(arg1)->GetWindow();
8107 wxPyEndAllowThreads(__tstate);
8108 if (PyErr_Occurred()) SWIG_fail;
8109 }
8110 {
8111 resultobj = wxPyMake_wxObject(result, 0);
8112 }
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj = 0;
8121 bool arg1 ;
8122 bool val1 ;
8123 int ecode1 = 0 ;
8124 PyObject * obj0 = 0 ;
8125 char * kwnames[] = {
8126 (char *) "flag", NULL
8127 };
8128
8129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8130 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8131 if (!SWIG_IsOK(ecode1)) {
8132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8133 }
8134 arg1 = static_cast< bool >(val1);
8135 {
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 wxToolTip::Enable(arg1);
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_Py_Void();
8142 return resultobj;
8143 fail:
8144 return NULL;
8145 }
8146
8147
8148 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8149 PyObject *resultobj = 0;
8150 long arg1 ;
8151 long val1 ;
8152 int ecode1 = 0 ;
8153 PyObject * obj0 = 0 ;
8154 char * kwnames[] = {
8155 (char *) "milliseconds", NULL
8156 };
8157
8158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8159 ecode1 = SWIG_AsVal_long(obj0, &val1);
8160 if (!SWIG_IsOK(ecode1)) {
8161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8162 }
8163 arg1 = static_cast< long >(val1);
8164 {
8165 PyThreadState* __tstate = wxPyBeginAllowThreads();
8166 wxToolTip::SetDelay(arg1);
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 resultobj = SWIG_Py_Void();
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8178 PyObject *obj;
8179 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8180 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8181 return SWIG_Py_Void();
8182 }
8183
8184 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8185 return SWIG_Python_InitShadowInstance(args);
8186 }
8187
8188 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8189 PyObject *resultobj = 0;
8190 wxWindow *arg1 = (wxWindow *) 0 ;
8191 wxSize *arg2 = 0 ;
8192 wxCaret *result = 0 ;
8193 void *argp1 = 0 ;
8194 int res1 = 0 ;
8195 wxSize temp2 ;
8196 PyObject * obj0 = 0 ;
8197 PyObject * obj1 = 0 ;
8198 char * kwnames[] = {
8199 (char *) "window",(char *) "size", NULL
8200 };
8201
8202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8204 if (!SWIG_IsOK(res1)) {
8205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8206 }
8207 arg1 = reinterpret_cast< wxWindow * >(argp1);
8208 {
8209 arg2 = &temp2;
8210 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8211 }
8212 {
8213 if (!wxPyCheckForApp()) SWIG_fail;
8214 PyThreadState* __tstate = wxPyBeginAllowThreads();
8215 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8216 wxPyEndAllowThreads(__tstate);
8217 if (PyErr_Occurred()) SWIG_fail;
8218 }
8219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8220 return resultobj;
8221 fail:
8222 return NULL;
8223 }
8224
8225
8226 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8227 PyObject *resultobj = 0;
8228 wxCaret *arg1 = (wxCaret *) 0 ;
8229 void *argp1 = 0 ;
8230 int res1 = 0 ;
8231 PyObject *swig_obj[1] ;
8232
8233 if (!args) SWIG_fail;
8234 swig_obj[0] = args;
8235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8236 if (!SWIG_IsOK(res1)) {
8237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8238 }
8239 arg1 = reinterpret_cast< wxCaret * >(argp1);
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 delete arg1;
8243
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 resultobj = SWIG_Py_Void();
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8255 PyObject *resultobj = 0;
8256 wxCaret *arg1 = (wxCaret *) 0 ;
8257 void *argp1 = 0 ;
8258 int res1 = 0 ;
8259 PyObject *swig_obj[1] ;
8260
8261 if (!args) SWIG_fail;
8262 swig_obj[0] = args;
8263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8264 if (!SWIG_IsOK(res1)) {
8265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8266 }
8267 arg1 = reinterpret_cast< wxCaret * >(argp1);
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 wxCaret_Destroy(arg1);
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = SWIG_Py_Void();
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8282 PyObject *resultobj = 0;
8283 wxCaret *arg1 = (wxCaret *) 0 ;
8284 bool result;
8285 void *argp1 = 0 ;
8286 int res1 = 0 ;
8287 PyObject *swig_obj[1] ;
8288
8289 if (!args) SWIG_fail;
8290 swig_obj[0] = args;
8291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8292 if (!SWIG_IsOK(res1)) {
8293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8294 }
8295 arg1 = reinterpret_cast< wxCaret * >(argp1);
8296 {
8297 PyThreadState* __tstate = wxPyBeginAllowThreads();
8298 result = (bool)(arg1)->IsOk();
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 {
8303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8304 }
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8312 PyObject *resultobj = 0;
8313 wxCaret *arg1 = (wxCaret *) 0 ;
8314 bool result;
8315 void *argp1 = 0 ;
8316 int res1 = 0 ;
8317 PyObject *swig_obj[1] ;
8318
8319 if (!args) SWIG_fail;
8320 swig_obj[0] = args;
8321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8322 if (!SWIG_IsOK(res1)) {
8323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8324 }
8325 arg1 = reinterpret_cast< wxCaret * >(argp1);
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (bool)(arg1)->IsVisible();
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 {
8333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8334 }
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8342 PyObject *resultobj = 0;
8343 wxCaret *arg1 = (wxCaret *) 0 ;
8344 wxPoint result;
8345 void *argp1 = 0 ;
8346 int res1 = 0 ;
8347 PyObject *swig_obj[1] ;
8348
8349 if (!args) SWIG_fail;
8350 swig_obj[0] = args;
8351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8352 if (!SWIG_IsOK(res1)) {
8353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8354 }
8355 arg1 = reinterpret_cast< wxCaret * >(argp1);
8356 {
8357 PyThreadState* __tstate = wxPyBeginAllowThreads();
8358 result = (arg1)->GetPosition();
8359 wxPyEndAllowThreads(__tstate);
8360 if (PyErr_Occurred()) SWIG_fail;
8361 }
8362 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8363 return resultobj;
8364 fail:
8365 return NULL;
8366 }
8367
8368
8369 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8370 PyObject *resultobj = 0;
8371 wxCaret *arg1 = (wxCaret *) 0 ;
8372 int *arg2 = (int *) 0 ;
8373 int *arg3 = (int *) 0 ;
8374 void *argp1 = 0 ;
8375 int res1 = 0 ;
8376 int temp2 ;
8377 int res2 = SWIG_TMPOBJ ;
8378 int temp3 ;
8379 int res3 = SWIG_TMPOBJ ;
8380 PyObject *swig_obj[1] ;
8381
8382 arg2 = &temp2;
8383 arg3 = &temp3;
8384 if (!args) SWIG_fail;
8385 swig_obj[0] = args;
8386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8387 if (!SWIG_IsOK(res1)) {
8388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8389 }
8390 arg1 = reinterpret_cast< wxCaret * >(argp1);
8391 {
8392 PyThreadState* __tstate = wxPyBeginAllowThreads();
8393 (arg1)->GetPosition(arg2,arg3);
8394 wxPyEndAllowThreads(__tstate);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 resultobj = SWIG_Py_Void();
8398 if (SWIG_IsTmpObj(res2)) {
8399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8400 } else {
8401 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8403 }
8404 if (SWIG_IsTmpObj(res3)) {
8405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8406 } else {
8407 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8409 }
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8417 PyObject *resultobj = 0;
8418 wxCaret *arg1 = (wxCaret *) 0 ;
8419 wxSize result;
8420 void *argp1 = 0 ;
8421 int res1 = 0 ;
8422 PyObject *swig_obj[1] ;
8423
8424 if (!args) SWIG_fail;
8425 swig_obj[0] = args;
8426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8427 if (!SWIG_IsOK(res1)) {
8428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8429 }
8430 arg1 = reinterpret_cast< wxCaret * >(argp1);
8431 {
8432 PyThreadState* __tstate = wxPyBeginAllowThreads();
8433 result = (arg1)->GetSize();
8434 wxPyEndAllowThreads(__tstate);
8435 if (PyErr_Occurred()) SWIG_fail;
8436 }
8437 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8438 return resultobj;
8439 fail:
8440 return NULL;
8441 }
8442
8443
8444 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8445 PyObject *resultobj = 0;
8446 wxCaret *arg1 = (wxCaret *) 0 ;
8447 int *arg2 = (int *) 0 ;
8448 int *arg3 = (int *) 0 ;
8449 void *argp1 = 0 ;
8450 int res1 = 0 ;
8451 int temp2 ;
8452 int res2 = SWIG_TMPOBJ ;
8453 int temp3 ;
8454 int res3 = SWIG_TMPOBJ ;
8455 PyObject *swig_obj[1] ;
8456
8457 arg2 = &temp2;
8458 arg3 = &temp3;
8459 if (!args) SWIG_fail;
8460 swig_obj[0] = args;
8461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8462 if (!SWIG_IsOK(res1)) {
8463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8464 }
8465 arg1 = reinterpret_cast< wxCaret * >(argp1);
8466 {
8467 PyThreadState* __tstate = wxPyBeginAllowThreads();
8468 (arg1)->GetSize(arg2,arg3);
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 resultobj = SWIG_Py_Void();
8473 if (SWIG_IsTmpObj(res2)) {
8474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8475 } else {
8476 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8478 }
8479 if (SWIG_IsTmpObj(res3)) {
8480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8481 } else {
8482 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8483 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8484 }
8485 return resultobj;
8486 fail:
8487 return NULL;
8488 }
8489
8490
8491 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8492 PyObject *resultobj = 0;
8493 wxCaret *arg1 = (wxCaret *) 0 ;
8494 wxWindow *result = 0 ;
8495 void *argp1 = 0 ;
8496 int res1 = 0 ;
8497 PyObject *swig_obj[1] ;
8498
8499 if (!args) SWIG_fail;
8500 swig_obj[0] = args;
8501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8502 if (!SWIG_IsOK(res1)) {
8503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8504 }
8505 arg1 = reinterpret_cast< wxCaret * >(argp1);
8506 {
8507 PyThreadState* __tstate = wxPyBeginAllowThreads();
8508 result = (wxWindow *)(arg1)->GetWindow();
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 {
8513 resultobj = wxPyMake_wxObject(result, 0);
8514 }
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj = 0;
8523 wxCaret *arg1 = (wxCaret *) 0 ;
8524 int arg2 ;
8525 int arg3 ;
8526 void *argp1 = 0 ;
8527 int res1 = 0 ;
8528 int val2 ;
8529 int ecode2 = 0 ;
8530 int val3 ;
8531 int ecode3 = 0 ;
8532 PyObject * obj0 = 0 ;
8533 PyObject * obj1 = 0 ;
8534 PyObject * obj2 = 0 ;
8535 char * kwnames[] = {
8536 (char *) "self",(char *) "x",(char *) "y", NULL
8537 };
8538
8539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8543 }
8544 arg1 = reinterpret_cast< wxCaret * >(argp1);
8545 ecode2 = SWIG_AsVal_int(obj1, &val2);
8546 if (!SWIG_IsOK(ecode2)) {
8547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8548 }
8549 arg2 = static_cast< int >(val2);
8550 ecode3 = SWIG_AsVal_int(obj2, &val3);
8551 if (!SWIG_IsOK(ecode3)) {
8552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8553 }
8554 arg3 = static_cast< int >(val3);
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 (arg1)->Move(arg2,arg3);
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 resultobj = SWIG_Py_Void();
8562 return resultobj;
8563 fail:
8564 return NULL;
8565 }
8566
8567
8568 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8569 PyObject *resultobj = 0;
8570 wxCaret *arg1 = (wxCaret *) 0 ;
8571 wxPoint *arg2 = 0 ;
8572 void *argp1 = 0 ;
8573 int res1 = 0 ;
8574 wxPoint temp2 ;
8575 PyObject * obj0 = 0 ;
8576 PyObject * obj1 = 0 ;
8577 char * kwnames[] = {
8578 (char *) "self",(char *) "pt", NULL
8579 };
8580
8581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8583 if (!SWIG_IsOK(res1)) {
8584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8585 }
8586 arg1 = reinterpret_cast< wxCaret * >(argp1);
8587 {
8588 arg2 = &temp2;
8589 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8590 }
8591 {
8592 PyThreadState* __tstate = wxPyBeginAllowThreads();
8593 (arg1)->Move((wxPoint const &)*arg2);
8594 wxPyEndAllowThreads(__tstate);
8595 if (PyErr_Occurred()) SWIG_fail;
8596 }
8597 resultobj = SWIG_Py_Void();
8598 return resultobj;
8599 fail:
8600 return NULL;
8601 }
8602
8603
8604 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8605 PyObject *resultobj = 0;
8606 wxCaret *arg1 = (wxCaret *) 0 ;
8607 int arg2 ;
8608 int arg3 ;
8609 void *argp1 = 0 ;
8610 int res1 = 0 ;
8611 int val2 ;
8612 int ecode2 = 0 ;
8613 int val3 ;
8614 int ecode3 = 0 ;
8615 PyObject * obj0 = 0 ;
8616 PyObject * obj1 = 0 ;
8617 PyObject * obj2 = 0 ;
8618 char * kwnames[] = {
8619 (char *) "self",(char *) "width",(char *) "height", NULL
8620 };
8621
8622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8624 if (!SWIG_IsOK(res1)) {
8625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8626 }
8627 arg1 = reinterpret_cast< wxCaret * >(argp1);
8628 ecode2 = SWIG_AsVal_int(obj1, &val2);
8629 if (!SWIG_IsOK(ecode2)) {
8630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8631 }
8632 arg2 = static_cast< int >(val2);
8633 ecode3 = SWIG_AsVal_int(obj2, &val3);
8634 if (!SWIG_IsOK(ecode3)) {
8635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8636 }
8637 arg3 = static_cast< int >(val3);
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 (arg1)->SetSize(arg2,arg3);
8641 wxPyEndAllowThreads(__tstate);
8642 if (PyErr_Occurred()) SWIG_fail;
8643 }
8644 resultobj = SWIG_Py_Void();
8645 return resultobj;
8646 fail:
8647 return NULL;
8648 }
8649
8650
8651 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj = 0;
8653 wxCaret *arg1 = (wxCaret *) 0 ;
8654 wxSize *arg2 = 0 ;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 wxSize temp2 ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char * kwnames[] = {
8661 (char *) "self",(char *) "size", NULL
8662 };
8663
8664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8666 if (!SWIG_IsOK(res1)) {
8667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8668 }
8669 arg1 = reinterpret_cast< wxCaret * >(argp1);
8670 {
8671 arg2 = &temp2;
8672 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8673 }
8674 {
8675 PyThreadState* __tstate = wxPyBeginAllowThreads();
8676 (arg1)->SetSize((wxSize const &)*arg2);
8677 wxPyEndAllowThreads(__tstate);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 resultobj = SWIG_Py_Void();
8681 return resultobj;
8682 fail:
8683 return NULL;
8684 }
8685
8686
8687 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8688 PyObject *resultobj = 0;
8689 wxCaret *arg1 = (wxCaret *) 0 ;
8690 int arg2 = (int) true ;
8691 void *argp1 = 0 ;
8692 int res1 = 0 ;
8693 int val2 ;
8694 int ecode2 = 0 ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 char * kwnames[] = {
8698 (char *) "self",(char *) "show", NULL
8699 };
8700
8701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8703 if (!SWIG_IsOK(res1)) {
8704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8705 }
8706 arg1 = reinterpret_cast< wxCaret * >(argp1);
8707 if (obj1) {
8708 ecode2 = SWIG_AsVal_int(obj1, &val2);
8709 if (!SWIG_IsOK(ecode2)) {
8710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8711 }
8712 arg2 = static_cast< int >(val2);
8713 }
8714 {
8715 PyThreadState* __tstate = wxPyBeginAllowThreads();
8716 (arg1)->Show(arg2);
8717 wxPyEndAllowThreads(__tstate);
8718 if (PyErr_Occurred()) SWIG_fail;
8719 }
8720 resultobj = SWIG_Py_Void();
8721 return resultobj;
8722 fail:
8723 return NULL;
8724 }
8725
8726
8727 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8728 PyObject *resultobj = 0;
8729 wxCaret *arg1 = (wxCaret *) 0 ;
8730 void *argp1 = 0 ;
8731 int res1 = 0 ;
8732 PyObject *swig_obj[1] ;
8733
8734 if (!args) SWIG_fail;
8735 swig_obj[0] = args;
8736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8737 if (!SWIG_IsOK(res1)) {
8738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8739 }
8740 arg1 = reinterpret_cast< wxCaret * >(argp1);
8741 {
8742 PyThreadState* __tstate = wxPyBeginAllowThreads();
8743 (arg1)->Hide();
8744 wxPyEndAllowThreads(__tstate);
8745 if (PyErr_Occurred()) SWIG_fail;
8746 }
8747 resultobj = SWIG_Py_Void();
8748 return resultobj;
8749 fail:
8750 return NULL;
8751 }
8752
8753
8754 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8755 PyObject *resultobj = 0;
8756 int result;
8757
8758 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8759 {
8760 PyThreadState* __tstate = wxPyBeginAllowThreads();
8761 result = (int)wxCaret::GetBlinkTime();
8762 wxPyEndAllowThreads(__tstate);
8763 if (PyErr_Occurred()) SWIG_fail;
8764 }
8765 resultobj = SWIG_From_int(static_cast< int >(result));
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8773 PyObject *resultobj = 0;
8774 int arg1 ;
8775 int val1 ;
8776 int ecode1 = 0 ;
8777 PyObject * obj0 = 0 ;
8778 char * kwnames[] = {
8779 (char *) "milliseconds", NULL
8780 };
8781
8782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8783 ecode1 = SWIG_AsVal_int(obj0, &val1);
8784 if (!SWIG_IsOK(ecode1)) {
8785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8786 }
8787 arg1 = static_cast< int >(val1);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 wxCaret::SetBlinkTime(arg1);
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 *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8802 PyObject *obj;
8803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8804 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8805 return SWIG_Py_Void();
8806 }
8807
8808 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8809 return SWIG_Python_InitShadowInstance(args);
8810 }
8811
8812 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8813 PyObject *resultobj = 0;
8814 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8815 wxBusyCursor *result = 0 ;
8816 void *argp1 = 0 ;
8817 int res1 = 0 ;
8818 PyObject * obj0 = 0 ;
8819 char * kwnames[] = {
8820 (char *) "cursor", NULL
8821 };
8822
8823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8824 if (obj0) {
8825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8826 if (!SWIG_IsOK(res1)) {
8827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8828 }
8829 arg1 = reinterpret_cast< wxCursor * >(argp1);
8830 }
8831 {
8832 if (!wxPyCheckForApp()) SWIG_fail;
8833 PyThreadState* __tstate = wxPyBeginAllowThreads();
8834 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8839 return resultobj;
8840 fail:
8841 return NULL;
8842 }
8843
8844
8845 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8846 PyObject *resultobj = 0;
8847 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8848 void *argp1 = 0 ;
8849 int res1 = 0 ;
8850 PyObject *swig_obj[1] ;
8851
8852 if (!args) SWIG_fail;
8853 swig_obj[0] = args;
8854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8855 if (!SWIG_IsOK(res1)) {
8856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8857 }
8858 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 delete arg1;
8862
8863 wxPyEndAllowThreads(__tstate);
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 resultobj = SWIG_Py_Void();
8867 return resultobj;
8868 fail:
8869 return NULL;
8870 }
8871
8872
8873 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8874 PyObject *obj;
8875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8876 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8877 return SWIG_Py_Void();
8878 }
8879
8880 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8881 return SWIG_Python_InitShadowInstance(args);
8882 }
8883
8884 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj = 0;
8886 wxWindow *arg1 = (wxWindow *) NULL ;
8887 wxWindowDisabler *result = 0 ;
8888 void *argp1 = 0 ;
8889 int res1 = 0 ;
8890 PyObject * obj0 = 0 ;
8891 char * kwnames[] = {
8892 (char *) "winToSkip", NULL
8893 };
8894
8895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8896 if (obj0) {
8897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8898 if (!SWIG_IsOK(res1)) {
8899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8900 }
8901 arg1 = reinterpret_cast< wxWindow * >(argp1);
8902 }
8903 {
8904 if (!wxPyCheckForApp()) SWIG_fail;
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8907 wxPyEndAllowThreads(__tstate);
8908 if (PyErr_Occurred()) SWIG_fail;
8909 }
8910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8911 return resultobj;
8912 fail:
8913 return NULL;
8914 }
8915
8916
8917 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8918 PyObject *resultobj = 0;
8919 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 PyObject *swig_obj[1] ;
8923
8924 if (!args) SWIG_fail;
8925 swig_obj[0] = args;
8926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8927 if (!SWIG_IsOK(res1)) {
8928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8929 }
8930 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 delete arg1;
8934
8935 wxPyEndAllowThreads(__tstate);
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 resultobj = SWIG_Py_Void();
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8946 PyObject *obj;
8947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8948 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8949 return SWIG_Py_Void();
8950 }
8951
8952 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8953 return SWIG_Python_InitShadowInstance(args);
8954 }
8955
8956 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj = 0;
8958 wxString *arg1 = 0 ;
8959 wxBusyInfo *result = 0 ;
8960 bool temp1 = false ;
8961 PyObject * obj0 = 0 ;
8962 char * kwnames[] = {
8963 (char *) "message", NULL
8964 };
8965
8966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8967 {
8968 arg1 = wxString_in_helper(obj0);
8969 if (arg1 == NULL) SWIG_fail;
8970 temp1 = true;
8971 }
8972 {
8973 if (!wxPyCheckForApp()) SWIG_fail;
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8980 {
8981 if (temp1)
8982 delete arg1;
8983 }
8984 return resultobj;
8985 fail:
8986 {
8987 if (temp1)
8988 delete arg1;
8989 }
8990 return NULL;
8991 }
8992
8993
8994 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8995 PyObject *resultobj = 0;
8996 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
8997 void *argp1 = 0 ;
8998 int res1 = 0 ;
8999 PyObject *swig_obj[1] ;
9000
9001 if (!args) SWIG_fail;
9002 swig_obj[0] = args;
9003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9004 if (!SWIG_IsOK(res1)) {
9005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9006 }
9007 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9008 {
9009 PyThreadState* __tstate = wxPyBeginAllowThreads();
9010 delete arg1;
9011
9012 wxPyEndAllowThreads(__tstate);
9013 if (PyErr_Occurred()) SWIG_fail;
9014 }
9015 resultobj = SWIG_Py_Void();
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *obj;
9024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9025 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9026 return SWIG_Py_Void();
9027 }
9028
9029 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030 return SWIG_Python_InitShadowInstance(args);
9031 }
9032
9033 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 PyObject *resultobj = 0;
9035 wxStopWatch *result = 0 ;
9036
9037 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 result = (wxStopWatch *)new wxStopWatch();
9041 wxPyEndAllowThreads(__tstate);
9042 if (PyErr_Occurred()) SWIG_fail;
9043 }
9044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9045 return resultobj;
9046 fail:
9047 return NULL;
9048 }
9049
9050
9051 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9052 PyObject *resultobj = 0;
9053 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9054 long arg2 = (long) 0 ;
9055 void *argp1 = 0 ;
9056 int res1 = 0 ;
9057 long val2 ;
9058 int ecode2 = 0 ;
9059 PyObject * obj0 = 0 ;
9060 PyObject * obj1 = 0 ;
9061 char * kwnames[] = {
9062 (char *) "self",(char *) "t0", NULL
9063 };
9064
9065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9067 if (!SWIG_IsOK(res1)) {
9068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9069 }
9070 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9071 if (obj1) {
9072 ecode2 = SWIG_AsVal_long(obj1, &val2);
9073 if (!SWIG_IsOK(ecode2)) {
9074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9075 }
9076 arg2 = static_cast< long >(val2);
9077 }
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 (arg1)->Start(arg2);
9081 wxPyEndAllowThreads(__tstate);
9082 if (PyErr_Occurred()) SWIG_fail;
9083 }
9084 resultobj = SWIG_Py_Void();
9085 return resultobj;
9086 fail:
9087 return NULL;
9088 }
9089
9090
9091 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9092 PyObject *resultobj = 0;
9093 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9094 void *argp1 = 0 ;
9095 int res1 = 0 ;
9096 PyObject *swig_obj[1] ;
9097
9098 if (!args) SWIG_fail;
9099 swig_obj[0] = args;
9100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9101 if (!SWIG_IsOK(res1)) {
9102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9103 }
9104 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9105 {
9106 PyThreadState* __tstate = wxPyBeginAllowThreads();
9107 (arg1)->Pause();
9108 wxPyEndAllowThreads(__tstate);
9109 if (PyErr_Occurred()) SWIG_fail;
9110 }
9111 resultobj = SWIG_Py_Void();
9112 return resultobj;
9113 fail:
9114 return NULL;
9115 }
9116
9117
9118 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9119 PyObject *resultobj = 0;
9120 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 PyObject *swig_obj[1] ;
9124
9125 if (!args) SWIG_fail;
9126 swig_obj[0] = args;
9127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9128 if (!SWIG_IsOK(res1)) {
9129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9130 }
9131 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9132 {
9133 PyThreadState* __tstate = wxPyBeginAllowThreads();
9134 (arg1)->Resume();
9135 wxPyEndAllowThreads(__tstate);
9136 if (PyErr_Occurred()) SWIG_fail;
9137 }
9138 resultobj = SWIG_Py_Void();
9139 return resultobj;
9140 fail:
9141 return NULL;
9142 }
9143
9144
9145 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9146 PyObject *resultobj = 0;
9147 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9148 long result;
9149 void *argp1 = 0 ;
9150 int res1 = 0 ;
9151 PyObject *swig_obj[1] ;
9152
9153 if (!args) SWIG_fail;
9154 swig_obj[0] = args;
9155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9156 if (!SWIG_IsOK(res1)) {
9157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9158 }
9159 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 result = (long)((wxStopWatch const *)arg1)->Time();
9163 wxPyEndAllowThreads(__tstate);
9164 if (PyErr_Occurred()) SWIG_fail;
9165 }
9166 resultobj = SWIG_From_long(static_cast< long >(result));
9167 return resultobj;
9168 fail:
9169 return NULL;
9170 }
9171
9172
9173 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9174 PyObject *obj;
9175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9176 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9177 return SWIG_Py_Void();
9178 }
9179
9180 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9181 return SWIG_Python_InitShadowInstance(args);
9182 }
9183
9184 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9185 PyObject *resultobj = 0;
9186 int arg1 = (int) 9 ;
9187 int arg2 = (int) wxID_FILE1 ;
9188 wxFileHistory *result = 0 ;
9189 int val1 ;
9190 int ecode1 = 0 ;
9191 int val2 ;
9192 int ecode2 = 0 ;
9193 PyObject * obj0 = 0 ;
9194 PyObject * obj1 = 0 ;
9195 char * kwnames[] = {
9196 (char *) "maxFiles",(char *) "idBase", NULL
9197 };
9198
9199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9200 if (obj0) {
9201 ecode1 = SWIG_AsVal_int(obj0, &val1);
9202 if (!SWIG_IsOK(ecode1)) {
9203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9204 }
9205 arg1 = static_cast< int >(val1);
9206 }
9207 if (obj1) {
9208 ecode2 = SWIG_AsVal_int(obj1, &val2);
9209 if (!SWIG_IsOK(ecode2)) {
9210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9211 }
9212 arg2 = static_cast< int >(val2);
9213 }
9214 {
9215 PyThreadState* __tstate = wxPyBeginAllowThreads();
9216 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9217 wxPyEndAllowThreads(__tstate);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9221 return resultobj;
9222 fail:
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9239 }
9240 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 delete arg1;
9244
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 resultobj = SWIG_Py_Void();
9249 return resultobj;
9250 fail:
9251 return NULL;
9252 }
9253
9254
9255 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9256 PyObject *resultobj = 0;
9257 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9258 wxString *arg2 = 0 ;
9259 void *argp1 = 0 ;
9260 int res1 = 0 ;
9261 bool temp2 = false ;
9262 PyObject * obj0 = 0 ;
9263 PyObject * obj1 = 0 ;
9264 char * kwnames[] = {
9265 (char *) "self",(char *) "file", NULL
9266 };
9267
9268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9270 if (!SWIG_IsOK(res1)) {
9271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9272 }
9273 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9274 {
9275 arg2 = wxString_in_helper(obj1);
9276 if (arg2 == NULL) SWIG_fail;
9277 temp2 = true;
9278 }
9279 {
9280 PyThreadState* __tstate = wxPyBeginAllowThreads();
9281 (arg1)->AddFileToHistory((wxString const &)*arg2);
9282 wxPyEndAllowThreads(__tstate);
9283 if (PyErr_Occurred()) SWIG_fail;
9284 }
9285 resultobj = SWIG_Py_Void();
9286 {
9287 if (temp2)
9288 delete arg2;
9289 }
9290 return resultobj;
9291 fail:
9292 {
9293 if (temp2)
9294 delete arg2;
9295 }
9296 return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9301 PyObject *resultobj = 0;
9302 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9303 int arg2 ;
9304 void *argp1 = 0 ;
9305 int res1 = 0 ;
9306 int val2 ;
9307 int ecode2 = 0 ;
9308 PyObject * obj0 = 0 ;
9309 PyObject * obj1 = 0 ;
9310 char * kwnames[] = {
9311 (char *) "self",(char *) "i", NULL
9312 };
9313
9314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9316 if (!SWIG_IsOK(res1)) {
9317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9318 }
9319 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9320 ecode2 = SWIG_AsVal_int(obj1, &val2);
9321 if (!SWIG_IsOK(ecode2)) {
9322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9323 }
9324 arg2 = static_cast< int >(val2);
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 (arg1)->RemoveFileFromHistory(arg2);
9328 wxPyEndAllowThreads(__tstate);
9329 if (PyErr_Occurred()) SWIG_fail;
9330 }
9331 resultobj = SWIG_Py_Void();
9332 return resultobj;
9333 fail:
9334 return NULL;
9335 }
9336
9337
9338 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9339 PyObject *resultobj = 0;
9340 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9341 int result;
9342 void *argp1 = 0 ;
9343 int res1 = 0 ;
9344 PyObject *swig_obj[1] ;
9345
9346 if (!args) SWIG_fail;
9347 swig_obj[0] = args;
9348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9349 if (!SWIG_IsOK(res1)) {
9350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9351 }
9352 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_From_int(static_cast< int >(result));
9360 return resultobj;
9361 fail:
9362 return NULL;
9363 }
9364
9365
9366 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9367 PyObject *resultobj = 0;
9368 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9369 wxMenu *arg2 = (wxMenu *) 0 ;
9370 void *argp1 = 0 ;
9371 int res1 = 0 ;
9372 void *argp2 = 0 ;
9373 int res2 = 0 ;
9374 PyObject * obj0 = 0 ;
9375 PyObject * obj1 = 0 ;
9376 char * kwnames[] = {
9377 (char *) "self",(char *) "menu", NULL
9378 };
9379
9380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9384 }
9385 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9387 if (!SWIG_IsOK(res2)) {
9388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9389 }
9390 arg2 = reinterpret_cast< wxMenu * >(argp2);
9391 {
9392 PyThreadState* __tstate = wxPyBeginAllowThreads();
9393 (arg1)->UseMenu(arg2);
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 resultobj = SWIG_Py_Void();
9398 return resultobj;
9399 fail:
9400 return NULL;
9401 }
9402
9403
9404 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj = 0;
9406 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9407 wxMenu *arg2 = (wxMenu *) 0 ;
9408 void *argp1 = 0 ;
9409 int res1 = 0 ;
9410 void *argp2 = 0 ;
9411 int res2 = 0 ;
9412 PyObject * obj0 = 0 ;
9413 PyObject * obj1 = 0 ;
9414 char * kwnames[] = {
9415 (char *) "self",(char *) "menu", NULL
9416 };
9417
9418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9420 if (!SWIG_IsOK(res1)) {
9421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9422 }
9423 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9425 if (!SWIG_IsOK(res2)) {
9426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9427 }
9428 arg2 = reinterpret_cast< wxMenu * >(argp2);
9429 {
9430 PyThreadState* __tstate = wxPyBeginAllowThreads();
9431 (arg1)->RemoveMenu(arg2);
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 resultobj = SWIG_Py_Void();
9436 return resultobj;
9437 fail:
9438 return NULL;
9439 }
9440
9441
9442 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9443 PyObject *resultobj = 0;
9444 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9445 wxConfigBase *arg2 = 0 ;
9446 void *argp1 = 0 ;
9447 int res1 = 0 ;
9448 void *argp2 = 0 ;
9449 int res2 = 0 ;
9450 PyObject * obj0 = 0 ;
9451 PyObject * obj1 = 0 ;
9452 char * kwnames[] = {
9453 (char *) "self",(char *) "config", NULL
9454 };
9455
9456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9460 }
9461 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9462 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9463 if (!SWIG_IsOK(res2)) {
9464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9465 }
9466 if (!argp2) {
9467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9468 }
9469 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 (arg1)->Load(*arg2);
9473 wxPyEndAllowThreads(__tstate);
9474 if (PyErr_Occurred()) SWIG_fail;
9475 }
9476 resultobj = SWIG_Py_Void();
9477 return resultobj;
9478 fail:
9479 return NULL;
9480 }
9481
9482
9483 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9484 PyObject *resultobj = 0;
9485 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9486 wxConfigBase *arg2 = 0 ;
9487 void *argp1 = 0 ;
9488 int res1 = 0 ;
9489 void *argp2 = 0 ;
9490 int res2 = 0 ;
9491 PyObject * obj0 = 0 ;
9492 PyObject * obj1 = 0 ;
9493 char * kwnames[] = {
9494 (char *) "self",(char *) "config", NULL
9495 };
9496
9497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9499 if (!SWIG_IsOK(res1)) {
9500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9501 }
9502 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9503 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9504 if (!SWIG_IsOK(res2)) {
9505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9506 }
9507 if (!argp2) {
9508 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9509 }
9510 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9511 {
9512 PyThreadState* __tstate = wxPyBeginAllowThreads();
9513 (arg1)->Save(*arg2);
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 resultobj = SWIG_Py_Void();
9518 return resultobj;
9519 fail:
9520 return NULL;
9521 }
9522
9523
9524 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9525 PyObject *resultobj = 0;
9526 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9527 void *argp1 = 0 ;
9528 int res1 = 0 ;
9529 PyObject *swig_obj[1] ;
9530
9531 if (!args) SWIG_fail;
9532 swig_obj[0] = args;
9533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9534 if (!SWIG_IsOK(res1)) {
9535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9536 }
9537 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9538 {
9539 PyThreadState* __tstate = wxPyBeginAllowThreads();
9540 (arg1)->AddFilesToMenu();
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 resultobj = SWIG_Py_Void();
9545 return resultobj;
9546 fail:
9547 return NULL;
9548 }
9549
9550
9551 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9552 PyObject *resultobj = 0;
9553 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9554 wxMenu *arg2 = (wxMenu *) 0 ;
9555 void *argp1 = 0 ;
9556 int res1 = 0 ;
9557 void *argp2 = 0 ;
9558 int res2 = 0 ;
9559 PyObject * obj0 = 0 ;
9560 PyObject * obj1 = 0 ;
9561 char * kwnames[] = {
9562 (char *) "self",(char *) "menu", NULL
9563 };
9564
9565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9567 if (!SWIG_IsOK(res1)) {
9568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9569 }
9570 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9572 if (!SWIG_IsOK(res2)) {
9573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9574 }
9575 arg2 = reinterpret_cast< wxMenu * >(argp2);
9576 {
9577 PyThreadState* __tstate = wxPyBeginAllowThreads();
9578 (arg1)->AddFilesToMenu(arg2);
9579 wxPyEndAllowThreads(__tstate);
9580 if (PyErr_Occurred()) SWIG_fail;
9581 }
9582 resultobj = SWIG_Py_Void();
9583 return resultobj;
9584 fail:
9585 return NULL;
9586 }
9587
9588
9589 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9590 PyObject *resultobj = 0;
9591 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9592 int arg2 ;
9593 wxString result;
9594 void *argp1 = 0 ;
9595 int res1 = 0 ;
9596 int val2 ;
9597 int ecode2 = 0 ;
9598 PyObject * obj0 = 0 ;
9599 PyObject * obj1 = 0 ;
9600 char * kwnames[] = {
9601 (char *) "self",(char *) "i", NULL
9602 };
9603
9604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9606 if (!SWIG_IsOK(res1)) {
9607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9608 }
9609 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9610 ecode2 = SWIG_AsVal_int(obj1, &val2);
9611 if (!SWIG_IsOK(ecode2)) {
9612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9613 }
9614 arg2 = static_cast< int >(val2);
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9618 wxPyEndAllowThreads(__tstate);
9619 if (PyErr_Occurred()) SWIG_fail;
9620 }
9621 {
9622 #if wxUSE_UNICODE
9623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9624 #else
9625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9626 #endif
9627 }
9628 return resultobj;
9629 fail:
9630 return NULL;
9631 }
9632
9633
9634 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9635 PyObject *resultobj = 0;
9636 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9637 int result;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 PyObject *swig_obj[1] ;
9641
9642 if (!args) SWIG_fail;
9643 swig_obj[0] = args;
9644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9645 if (!SWIG_IsOK(res1)) {
9646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9647 }
9648 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 result = (int)((wxFileHistory const *)arg1)->GetCount();
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 resultobj = SWIG_From_int(static_cast< int >(result));
9656 return resultobj;
9657 fail:
9658 return NULL;
9659 }
9660
9661
9662 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9663 PyObject *obj;
9664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9665 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9666 return SWIG_Py_Void();
9667 }
9668
9669 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9670 return SWIG_Python_InitShadowInstance(args);
9671 }
9672
9673 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj = 0;
9675 wxString *arg1 = 0 ;
9676 wxString const &arg2_defvalue = wxPyEmptyString ;
9677 wxString *arg2 = (wxString *) &arg2_defvalue ;
9678 wxSingleInstanceChecker *result = 0 ;
9679 bool temp1 = false ;
9680 bool temp2 = false ;
9681 PyObject * obj0 = 0 ;
9682 PyObject * obj1 = 0 ;
9683 char * kwnames[] = {
9684 (char *) "name",(char *) "path", NULL
9685 };
9686
9687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9688 {
9689 arg1 = wxString_in_helper(obj0);
9690 if (arg1 == NULL) SWIG_fail;
9691 temp1 = true;
9692 }
9693 if (obj1) {
9694 {
9695 arg2 = wxString_in_helper(obj1);
9696 if (arg2 == NULL) SWIG_fail;
9697 temp2 = true;
9698 }
9699 }
9700 {
9701 PyThreadState* __tstate = wxPyBeginAllowThreads();
9702 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9703 wxPyEndAllowThreads(__tstate);
9704 if (PyErr_Occurred()) SWIG_fail;
9705 }
9706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9707 {
9708 if (temp1)
9709 delete arg1;
9710 }
9711 {
9712 if (temp2)
9713 delete arg2;
9714 }
9715 return resultobj;
9716 fail:
9717 {
9718 if (temp1)
9719 delete arg1;
9720 }
9721 {
9722 if (temp2)
9723 delete arg2;
9724 }
9725 return NULL;
9726 }
9727
9728
9729 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9730 PyObject *resultobj = 0;
9731 wxSingleInstanceChecker *result = 0 ;
9732
9733 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9734 {
9735 PyThreadState* __tstate = wxPyBeginAllowThreads();
9736 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9737 wxPyEndAllowThreads(__tstate);
9738 if (PyErr_Occurred()) SWIG_fail;
9739 }
9740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9741 return resultobj;
9742 fail:
9743 return NULL;
9744 }
9745
9746
9747 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9748 PyObject *resultobj = 0;
9749 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9750 void *argp1 = 0 ;
9751 int res1 = 0 ;
9752 PyObject *swig_obj[1] ;
9753
9754 if (!args) SWIG_fail;
9755 swig_obj[0] = args;
9756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9757 if (!SWIG_IsOK(res1)) {
9758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9759 }
9760 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9761 {
9762 PyThreadState* __tstate = wxPyBeginAllowThreads();
9763 delete arg1;
9764
9765 wxPyEndAllowThreads(__tstate);
9766 if (PyErr_Occurred()) SWIG_fail;
9767 }
9768 resultobj = SWIG_Py_Void();
9769 return resultobj;
9770 fail:
9771 return NULL;
9772 }
9773
9774
9775 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9776 PyObject *resultobj = 0;
9777 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9778 wxString *arg2 = 0 ;
9779 wxString const &arg3_defvalue = wxPyEmptyString ;
9780 wxString *arg3 = (wxString *) &arg3_defvalue ;
9781 bool result;
9782 void *argp1 = 0 ;
9783 int res1 = 0 ;
9784 bool temp2 = false ;
9785 bool temp3 = false ;
9786 PyObject * obj0 = 0 ;
9787 PyObject * obj1 = 0 ;
9788 PyObject * obj2 = 0 ;
9789 char * kwnames[] = {
9790 (char *) "self",(char *) "name",(char *) "path", NULL
9791 };
9792
9793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9795 if (!SWIG_IsOK(res1)) {
9796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9797 }
9798 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9799 {
9800 arg2 = wxString_in_helper(obj1);
9801 if (arg2 == NULL) SWIG_fail;
9802 temp2 = true;
9803 }
9804 if (obj2) {
9805 {
9806 arg3 = wxString_in_helper(obj2);
9807 if (arg3 == NULL) SWIG_fail;
9808 temp3 = true;
9809 }
9810 }
9811 {
9812 PyThreadState* __tstate = wxPyBeginAllowThreads();
9813 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 {
9818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9819 }
9820 {
9821 if (temp2)
9822 delete arg2;
9823 }
9824 {
9825 if (temp3)
9826 delete arg3;
9827 }
9828 return resultobj;
9829 fail:
9830 {
9831 if (temp2)
9832 delete arg2;
9833 }
9834 {
9835 if (temp3)
9836 delete arg3;
9837 }
9838 return NULL;
9839 }
9840
9841
9842 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9843 PyObject *resultobj = 0;
9844 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9845 bool result;
9846 void *argp1 = 0 ;
9847 int res1 = 0 ;
9848 PyObject *swig_obj[1] ;
9849
9850 if (!args) SWIG_fail;
9851 swig_obj[0] = args;
9852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9853 if (!SWIG_IsOK(res1)) {
9854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9855 }
9856 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9857 {
9858 PyThreadState* __tstate = wxPyBeginAllowThreads();
9859 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9860 wxPyEndAllowThreads(__tstate);
9861 if (PyErr_Occurred()) SWIG_fail;
9862 }
9863 {
9864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9865 }
9866 return resultobj;
9867 fail:
9868 return NULL;
9869 }
9870
9871
9872 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9873 PyObject *obj;
9874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9875 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9876 return SWIG_Py_Void();
9877 }
9878
9879 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9880 return SWIG_Python_InitShadowInstance(args);
9881 }
9882
9883 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9884 PyObject *resultobj = 0;
9885 wxWindow *arg1 = (wxWindow *) 0 ;
9886 wxDC *arg2 = 0 ;
9887 bool result;
9888 void *argp1 = 0 ;
9889 int res1 = 0 ;
9890 void *argp2 = 0 ;
9891 int res2 = 0 ;
9892 PyObject * obj0 = 0 ;
9893 PyObject * obj1 = 0 ;
9894 char * kwnames[] = {
9895 (char *) "window",(char *) "dc", NULL
9896 };
9897
9898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9900 if (!SWIG_IsOK(res1)) {
9901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9902 }
9903 arg1 = reinterpret_cast< wxWindow * >(argp1);
9904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9905 if (!SWIG_IsOK(res2)) {
9906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9907 }
9908 if (!argp2) {
9909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9910 }
9911 arg2 = reinterpret_cast< wxDC * >(argp2);
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 {
9919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9920 }
9921 return resultobj;
9922 fail:
9923 return NULL;
9924 }
9925
9926
9927 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9928 PyObject *resultobj = 0;
9929 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9930 void *argp1 = 0 ;
9931 int res1 = 0 ;
9932 PyObject *swig_obj[1] ;
9933
9934 if (!args) SWIG_fail;
9935 swig_obj[0] = args;
9936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9937 if (!SWIG_IsOK(res1)) {
9938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9939 }
9940 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 delete arg1;
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 resultobj = SWIG_Py_Void();
9949 return resultobj;
9950 fail:
9951 return NULL;
9952 }
9953
9954
9955 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9956 PyObject *resultobj = 0;
9957 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9958 wxString result;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 PyObject *swig_obj[1] ;
9962
9963 if (!args) SWIG_fail;
9964 swig_obj[0] = args;
9965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9968 }
9969 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 result = (arg1)->GetTip();
9973 wxPyEndAllowThreads(__tstate);
9974 if (PyErr_Occurred()) SWIG_fail;
9975 }
9976 {
9977 #if wxUSE_UNICODE
9978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9979 #else
9980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9981 #endif
9982 }
9983 return resultobj;
9984 fail:
9985 return NULL;
9986 }
9987
9988
9989 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9990 PyObject *resultobj = 0;
9991 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9992 size_t result;
9993 void *argp1 = 0 ;
9994 int res1 = 0 ;
9995 PyObject *swig_obj[1] ;
9996
9997 if (!args) SWIG_fail;
9998 swig_obj[0] = args;
9999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10000 if (!SWIG_IsOK(res1)) {
10001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10002 }
10003 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10004 {
10005 PyThreadState* __tstate = wxPyBeginAllowThreads();
10006 result = (size_t)(arg1)->GetCurrentTip();
10007 wxPyEndAllowThreads(__tstate);
10008 if (PyErr_Occurred()) SWIG_fail;
10009 }
10010 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10011 return resultobj;
10012 fail:
10013 return NULL;
10014 }
10015
10016
10017 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10018 PyObject *resultobj = 0;
10019 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10020 wxString *arg2 = 0 ;
10021 wxString result;
10022 void *argp1 = 0 ;
10023 int res1 = 0 ;
10024 bool temp2 = false ;
10025 PyObject * obj0 = 0 ;
10026 PyObject * obj1 = 0 ;
10027 char * kwnames[] = {
10028 (char *) "self",(char *) "tip", NULL
10029 };
10030
10031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10033 if (!SWIG_IsOK(res1)) {
10034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10035 }
10036 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10037 {
10038 arg2 = wxString_in_helper(obj1);
10039 if (arg2 == NULL) SWIG_fail;
10040 temp2 = true;
10041 }
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 {
10049 #if wxUSE_UNICODE
10050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10051 #else
10052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10053 #endif
10054 }
10055 {
10056 if (temp2)
10057 delete arg2;
10058 }
10059 return resultobj;
10060 fail:
10061 {
10062 if (temp2)
10063 delete arg2;
10064 }
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10070 PyObject *obj;
10071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10072 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10073 return SWIG_Py_Void();
10074 }
10075
10076 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10077 PyObject *resultobj = 0;
10078 size_t arg1 ;
10079 wxPyTipProvider *result = 0 ;
10080 size_t val1 ;
10081 int ecode1 = 0 ;
10082 PyObject * obj0 = 0 ;
10083 char * kwnames[] = {
10084 (char *) "currentTip", NULL
10085 };
10086
10087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10088 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10089 if (!SWIG_IsOK(ecode1)) {
10090 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10091 }
10092 arg1 = static_cast< size_t >(val1);
10093 {
10094 PyThreadState* __tstate = wxPyBeginAllowThreads();
10095 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10096 wxPyEndAllowThreads(__tstate);
10097 if (PyErr_Occurred()) SWIG_fail;
10098 }
10099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10100 return resultobj;
10101 fail:
10102 return NULL;
10103 }
10104
10105
10106 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10107 PyObject *resultobj = 0;
10108 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10109 PyObject *arg2 = (PyObject *) 0 ;
10110 PyObject *arg3 = (PyObject *) 0 ;
10111 void *argp1 = 0 ;
10112 int res1 = 0 ;
10113 PyObject * obj0 = 0 ;
10114 PyObject * obj1 = 0 ;
10115 PyObject * obj2 = 0 ;
10116 char * kwnames[] = {
10117 (char *) "self",(char *) "self",(char *) "_class", NULL
10118 };
10119
10120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10122 if (!SWIG_IsOK(res1)) {
10123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10124 }
10125 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10126 arg2 = obj1;
10127 arg3 = obj2;
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 (arg1)->_setCallbackInfo(arg2,arg3);
10131 wxPyEndAllowThreads(__tstate);
10132 if (PyErr_Occurred()) SWIG_fail;
10133 }
10134 resultobj = SWIG_Py_Void();
10135 return resultobj;
10136 fail:
10137 return NULL;
10138 }
10139
10140
10141 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10142 PyObject *obj;
10143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10144 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10145 return SWIG_Py_Void();
10146 }
10147
10148 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10149 return SWIG_Python_InitShadowInstance(args);
10150 }
10151
10152 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10153 PyObject *resultobj = 0;
10154 wxWindow *arg1 = (wxWindow *) 0 ;
10155 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10156 bool arg3 = (bool) true ;
10157 bool result;
10158 void *argp1 = 0 ;
10159 int res1 = 0 ;
10160 void *argp2 = 0 ;
10161 int res2 = 0 ;
10162 bool val3 ;
10163 int ecode3 = 0 ;
10164 PyObject * obj0 = 0 ;
10165 PyObject * obj1 = 0 ;
10166 PyObject * obj2 = 0 ;
10167 char * kwnames[] = {
10168 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10169 };
10170
10171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10173 if (!SWIG_IsOK(res1)) {
10174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10175 }
10176 arg1 = reinterpret_cast< wxWindow * >(argp1);
10177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10178 if (!SWIG_IsOK(res2)) {
10179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10180 }
10181 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10182 if (obj2) {
10183 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10184 if (!SWIG_IsOK(ecode3)) {
10185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10186 }
10187 arg3 = static_cast< bool >(val3);
10188 }
10189 {
10190 if (!wxPyCheckForApp()) SWIG_fail;
10191 PyThreadState* __tstate = wxPyBeginAllowThreads();
10192 result = (bool)wxShowTip(arg1,arg2,arg3);
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 {
10197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10198 }
10199 return resultobj;
10200 fail:
10201 return NULL;
10202 }
10203
10204
10205 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10206 PyObject *resultobj = 0;
10207 wxString *arg1 = 0 ;
10208 size_t arg2 ;
10209 wxTipProvider *result = 0 ;
10210 bool temp1 = false ;
10211 size_t val2 ;
10212 int ecode2 = 0 ;
10213 PyObject * obj0 = 0 ;
10214 PyObject * obj1 = 0 ;
10215 char * kwnames[] = {
10216 (char *) "filename",(char *) "currentTip", NULL
10217 };
10218
10219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10220 {
10221 arg1 = wxString_in_helper(obj0);
10222 if (arg1 == NULL) SWIG_fail;
10223 temp1 = true;
10224 }
10225 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10226 if (!SWIG_IsOK(ecode2)) {
10227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10228 }
10229 arg2 = static_cast< size_t >(val2);
10230 {
10231 if (!wxPyCheckForApp()) SWIG_fail;
10232 PyThreadState* __tstate = wxPyBeginAllowThreads();
10233 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10238 {
10239 if (temp1)
10240 delete arg1;
10241 }
10242 return resultobj;
10243 fail:
10244 {
10245 if (temp1)
10246 delete arg1;
10247 }
10248 return NULL;
10249 }
10250
10251
10252 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10253 PyObject *resultobj = 0;
10254 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10255 int arg2 = (int) wxID_ANY ;
10256 wxPyTimer *result = 0 ;
10257 void *argp1 = 0 ;
10258 int res1 = 0 ;
10259 int val2 ;
10260 int ecode2 = 0 ;
10261 PyObject * obj0 = 0 ;
10262 PyObject * obj1 = 0 ;
10263 char * kwnames[] = {
10264 (char *) "owner",(char *) "id", NULL
10265 };
10266
10267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10268 if (obj0) {
10269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10270 if (!SWIG_IsOK(res1)) {
10271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10272 }
10273 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10274 }
10275 if (obj1) {
10276 ecode2 = SWIG_AsVal_int(obj1, &val2);
10277 if (!SWIG_IsOK(ecode2)) {
10278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10279 }
10280 arg2 = static_cast< int >(val2);
10281 }
10282 {
10283 if (!wxPyCheckForApp()) SWIG_fail;
10284 PyThreadState* __tstate = wxPyBeginAllowThreads();
10285 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10286 wxPyEndAllowThreads(__tstate);
10287 if (PyErr_Occurred()) SWIG_fail;
10288 }
10289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10290 return resultobj;
10291 fail:
10292 return NULL;
10293 }
10294
10295
10296 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10297 PyObject *resultobj = 0;
10298 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10299 void *argp1 = 0 ;
10300 int res1 = 0 ;
10301 PyObject *swig_obj[1] ;
10302
10303 if (!args) SWIG_fail;
10304 swig_obj[0] = args;
10305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10306 if (!SWIG_IsOK(res1)) {
10307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10308 }
10309 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10310 {
10311 PyThreadState* __tstate = wxPyBeginAllowThreads();
10312 delete arg1;
10313
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 resultobj = SWIG_Py_Void();
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10325 PyObject *resultobj = 0;
10326 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10327 PyObject *arg2 = (PyObject *) 0 ;
10328 PyObject *arg3 = (PyObject *) 0 ;
10329 int arg4 = (int) 1 ;
10330 void *argp1 = 0 ;
10331 int res1 = 0 ;
10332 int val4 ;
10333 int ecode4 = 0 ;
10334 PyObject * obj0 = 0 ;
10335 PyObject * obj1 = 0 ;
10336 PyObject * obj2 = 0 ;
10337 PyObject * obj3 = 0 ;
10338 char * kwnames[] = {
10339 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10340 };
10341
10342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10344 if (!SWIG_IsOK(res1)) {
10345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10346 }
10347 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10348 arg2 = obj1;
10349 arg3 = obj2;
10350 if (obj3) {
10351 ecode4 = SWIG_AsVal_int(obj3, &val4);
10352 if (!SWIG_IsOK(ecode4)) {
10353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10354 }
10355 arg4 = static_cast< int >(val4);
10356 }
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10360 wxPyEndAllowThreads(__tstate);
10361 if (PyErr_Occurred()) SWIG_fail;
10362 }
10363 resultobj = SWIG_Py_Void();
10364 return resultobj;
10365 fail:
10366 return NULL;
10367 }
10368
10369
10370 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10371 PyObject *resultobj = 0;
10372 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10373 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10374 int arg3 = (int) wxID_ANY ;
10375 void *argp1 = 0 ;
10376 int res1 = 0 ;
10377 void *argp2 = 0 ;
10378 int res2 = 0 ;
10379 int val3 ;
10380 int ecode3 = 0 ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 PyObject * obj2 = 0 ;
10384 char * kwnames[] = {
10385 (char *) "self",(char *) "owner",(char *) "id", NULL
10386 };
10387
10388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10390 if (!SWIG_IsOK(res1)) {
10391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10392 }
10393 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10395 if (!SWIG_IsOK(res2)) {
10396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10397 }
10398 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10399 if (obj2) {
10400 ecode3 = SWIG_AsVal_int(obj2, &val3);
10401 if (!SWIG_IsOK(ecode3)) {
10402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10403 }
10404 arg3 = static_cast< int >(val3);
10405 }
10406 {
10407 PyThreadState* __tstate = wxPyBeginAllowThreads();
10408 (arg1)->SetOwner(arg2,arg3);
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 resultobj = SWIG_Py_Void();
10413 return resultobj;
10414 fail:
10415 return NULL;
10416 }
10417
10418
10419 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10420 PyObject *resultobj = 0;
10421 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10422 wxEvtHandler *result = 0 ;
10423 void *argp1 = 0 ;
10424 int res1 = 0 ;
10425 PyObject *swig_obj[1] ;
10426
10427 if (!args) SWIG_fail;
10428 swig_obj[0] = args;
10429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10430 if (!SWIG_IsOK(res1)) {
10431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10432 }
10433 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10434 {
10435 PyThreadState* __tstate = wxPyBeginAllowThreads();
10436 result = (wxEvtHandler *)(arg1)->GetOwner();
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 {
10441 resultobj = wxPyMake_wxObject(result, 0);
10442 }
10443 return resultobj;
10444 fail:
10445 return NULL;
10446 }
10447
10448
10449 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10450 PyObject *resultobj = 0;
10451 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10452 int arg2 = (int) -1 ;
10453 bool arg3 = (bool) false ;
10454 bool result;
10455 void *argp1 = 0 ;
10456 int res1 = 0 ;
10457 int val2 ;
10458 int ecode2 = 0 ;
10459 bool val3 ;
10460 int ecode3 = 0 ;
10461 PyObject * obj0 = 0 ;
10462 PyObject * obj1 = 0 ;
10463 PyObject * obj2 = 0 ;
10464 char * kwnames[] = {
10465 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10466 };
10467
10468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10470 if (!SWIG_IsOK(res1)) {
10471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10472 }
10473 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10474 if (obj1) {
10475 ecode2 = SWIG_AsVal_int(obj1, &val2);
10476 if (!SWIG_IsOK(ecode2)) {
10477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10478 }
10479 arg2 = static_cast< int >(val2);
10480 }
10481 if (obj2) {
10482 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10483 if (!SWIG_IsOK(ecode3)) {
10484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10485 }
10486 arg3 = static_cast< bool >(val3);
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (bool)(arg1)->Start(arg2,arg3);
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_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10504 PyObject *resultobj = 0;
10505 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10506 void *argp1 = 0 ;
10507 int res1 = 0 ;
10508 PyObject *swig_obj[1] ;
10509
10510 if (!args) SWIG_fail;
10511 swig_obj[0] = args;
10512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10513 if (!SWIG_IsOK(res1)) {
10514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10515 }
10516 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10517 {
10518 PyThreadState* __tstate = wxPyBeginAllowThreads();
10519 (arg1)->Stop();
10520 wxPyEndAllowThreads(__tstate);
10521 if (PyErr_Occurred()) SWIG_fail;
10522 }
10523 resultobj = SWIG_Py_Void();
10524 return resultobj;
10525 fail:
10526 return NULL;
10527 }
10528
10529
10530 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10531 PyObject *resultobj = 0;
10532 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10533 void *argp1 = 0 ;
10534 int res1 = 0 ;
10535 PyObject *swig_obj[1] ;
10536
10537 if (!args) SWIG_fail;
10538 swig_obj[0] = args;
10539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10540 if (!SWIG_IsOK(res1)) {
10541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10542 }
10543 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10544 {
10545 PyThreadState* __tstate = wxPyBeginAllowThreads();
10546 (arg1)->Notify();
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 resultobj = SWIG_Py_Void();
10551 return resultobj;
10552 fail:
10553 return NULL;
10554 }
10555
10556
10557 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10558 PyObject *resultobj = 0;
10559 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10560 bool result;
10561 void *argp1 = 0 ;
10562 int res1 = 0 ;
10563 PyObject *swig_obj[1] ;
10564
10565 if (!args) SWIG_fail;
10566 swig_obj[0] = args;
10567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10568 if (!SWIG_IsOK(res1)) {
10569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10570 }
10571 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10572 {
10573 PyThreadState* __tstate = wxPyBeginAllowThreads();
10574 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10575 wxPyEndAllowThreads(__tstate);
10576 if (PyErr_Occurred()) SWIG_fail;
10577 }
10578 {
10579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10580 }
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10588 PyObject *resultobj = 0;
10589 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10590 int 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_wxPyTimer, 0 | 0 );
10598 if (!SWIG_IsOK(res1)) {
10599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10600 }
10601 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10602 {
10603 PyThreadState* __tstate = wxPyBeginAllowThreads();
10604 result = (int)((wxPyTimer const *)arg1)->GetInterval();
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_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10616 PyObject *resultobj = 0;
10617 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10618 int 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_wxPyTimer, 0 | 0 );
10626 if (!SWIG_IsOK(res1)) {
10627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10628 }
10629 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = (int)((wxPyTimer const *)arg1)->GetId();
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 resultobj = SWIG_From_int(static_cast< int >(result));
10637 return resultobj;
10638 fail:
10639 return NULL;
10640 }
10641
10642
10643 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10644 PyObject *resultobj = 0;
10645 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10646 bool result;
10647 void *argp1 = 0 ;
10648 int res1 = 0 ;
10649 PyObject *swig_obj[1] ;
10650
10651 if (!args) SWIG_fail;
10652 swig_obj[0] = args;
10653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10654 if (!SWIG_IsOK(res1)) {
10655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10656 }
10657 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10658 {
10659 PyThreadState* __tstate = wxPyBeginAllowThreads();
10660 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10661 wxPyEndAllowThreads(__tstate);
10662 if (PyErr_Occurred()) SWIG_fail;
10663 }
10664 {
10665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10666 }
10667 return resultobj;
10668 fail:
10669 return NULL;
10670 }
10671
10672
10673 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10674 PyObject *obj;
10675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10676 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10677 return SWIG_Py_Void();
10678 }
10679
10680 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10681 return SWIG_Python_InitShadowInstance(args);
10682 }
10683
10684 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10685 PyObject *resultobj = 0;
10686 int arg1 = (int) 0 ;
10687 int arg2 = (int) 0 ;
10688 wxTimerEvent *result = 0 ;
10689 int val1 ;
10690 int ecode1 = 0 ;
10691 int val2 ;
10692 int ecode2 = 0 ;
10693 PyObject * obj0 = 0 ;
10694 PyObject * obj1 = 0 ;
10695 char * kwnames[] = {
10696 (char *) "timerid",(char *) "interval", NULL
10697 };
10698
10699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10700 if (obj0) {
10701 ecode1 = SWIG_AsVal_int(obj0, &val1);
10702 if (!SWIG_IsOK(ecode1)) {
10703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10704 }
10705 arg1 = static_cast< int >(val1);
10706 }
10707 if (obj1) {
10708 ecode2 = SWIG_AsVal_int(obj1, &val2);
10709 if (!SWIG_IsOK(ecode2)) {
10710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10711 }
10712 arg2 = static_cast< int >(val2);
10713 }
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10721 return resultobj;
10722 fail:
10723 return NULL;
10724 }
10725
10726
10727 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10728 PyObject *resultobj = 0;
10729 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10730 int result;
10731 void *argp1 = 0 ;
10732 int res1 = 0 ;
10733 PyObject *swig_obj[1] ;
10734
10735 if (!args) SWIG_fail;
10736 swig_obj[0] = args;
10737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10738 if (!SWIG_IsOK(res1)) {
10739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10740 }
10741 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 resultobj = SWIG_From_int(static_cast< int >(result));
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10756 PyObject *obj;
10757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10758 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10759 return SWIG_Py_Void();
10760 }
10761
10762 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10763 return SWIG_Python_InitShadowInstance(args);
10764 }
10765
10766 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10767 PyObject *resultobj = 0;
10768 wxTimer *arg1 = 0 ;
10769 wxTimerRunner *result = 0 ;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772
10773 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10775 if (!SWIG_IsOK(res1)) {
10776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10777 }
10778 if (!argp1) {
10779 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10780 }
10781 arg1 = reinterpret_cast< wxTimer * >(argp1);
10782 {
10783 if (!wxPyCheckForApp()) SWIG_fail;
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10797 PyObject *resultobj = 0;
10798 wxTimer *arg1 = 0 ;
10799 int arg2 ;
10800 bool arg3 = (bool) false ;
10801 wxTimerRunner *result = 0 ;
10802 void *argp1 = 0 ;
10803 int res1 = 0 ;
10804 int val2 ;
10805 int ecode2 = 0 ;
10806 bool val3 ;
10807 int ecode3 = 0 ;
10808
10809 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10811 if (!SWIG_IsOK(res1)) {
10812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10813 }
10814 if (!argp1) {
10815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10816 }
10817 arg1 = reinterpret_cast< wxTimer * >(argp1);
10818 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10819 if (!SWIG_IsOK(ecode2)) {
10820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10821 }
10822 arg2 = static_cast< int >(val2);
10823 if (swig_obj[2]) {
10824 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10825 if (!SWIG_IsOK(ecode3)) {
10826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10827 }
10828 arg3 = static_cast< bool >(val3);
10829 }
10830 {
10831 if (!wxPyCheckForApp()) SWIG_fail;
10832 PyThreadState* __tstate = wxPyBeginAllowThreads();
10833 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10834 wxPyEndAllowThreads(__tstate);
10835 if (PyErr_Occurred()) SWIG_fail;
10836 }
10837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10845 int argc;
10846 PyObject *argv[4];
10847
10848 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10849 --argc;
10850 if (argc == 1) {
10851 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10852 }
10853 if ((argc >= 2) && (argc <= 3)) {
10854 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10855 }
10856
10857 fail:
10858 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10859 return NULL;
10860 }
10861
10862
10863 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10864 PyObject *resultobj = 0;
10865 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10866 void *argp1 = 0 ;
10867 int res1 = 0 ;
10868 PyObject *swig_obj[1] ;
10869
10870 if (!args) SWIG_fail;
10871 swig_obj[0] = args;
10872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10873 if (!SWIG_IsOK(res1)) {
10874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10875 }
10876 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10877 {
10878 PyThreadState* __tstate = wxPyBeginAllowThreads();
10879 delete arg1;
10880
10881 wxPyEndAllowThreads(__tstate);
10882 if (PyErr_Occurred()) SWIG_fail;
10883 }
10884 resultobj = SWIG_Py_Void();
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10892 PyObject *resultobj = 0;
10893 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10894 int arg2 ;
10895 bool arg3 = (bool) false ;
10896 void *argp1 = 0 ;
10897 int res1 = 0 ;
10898 int val2 ;
10899 int ecode2 = 0 ;
10900 bool val3 ;
10901 int ecode3 = 0 ;
10902 PyObject * obj0 = 0 ;
10903 PyObject * obj1 = 0 ;
10904 PyObject * obj2 = 0 ;
10905 char * kwnames[] = {
10906 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10907 };
10908
10909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10911 if (!SWIG_IsOK(res1)) {
10912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10913 }
10914 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10915 ecode2 = SWIG_AsVal_int(obj1, &val2);
10916 if (!SWIG_IsOK(ecode2)) {
10917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10918 }
10919 arg2 = static_cast< int >(val2);
10920 if (obj2) {
10921 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10922 if (!SWIG_IsOK(ecode3)) {
10923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10924 }
10925 arg3 = static_cast< bool >(val3);
10926 }
10927 {
10928 PyThreadState* __tstate = wxPyBeginAllowThreads();
10929 (arg1)->Start(arg2,arg3);
10930 wxPyEndAllowThreads(__tstate);
10931 if (PyErr_Occurred()) SWIG_fail;
10932 }
10933 resultobj = SWIG_Py_Void();
10934 return resultobj;
10935 fail:
10936 return NULL;
10937 }
10938
10939
10940 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10941 PyObject *obj;
10942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10943 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10944 return SWIG_Py_Void();
10945 }
10946
10947 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10948 return SWIG_Python_InitShadowInstance(args);
10949 }
10950
10951 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10952 PyObject *resultobj = 0;
10953 wxLog *result = 0 ;
10954
10955 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10956 {
10957 PyThreadState* __tstate = wxPyBeginAllowThreads();
10958 result = (wxLog *)new wxLog();
10959 wxPyEndAllowThreads(__tstate);
10960 if (PyErr_Occurred()) SWIG_fail;
10961 }
10962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10970 PyObject *resultobj = 0;
10971 wxLog *arg1 = (wxLog *) 0 ;
10972 void *argp1 = 0 ;
10973 int res1 = 0 ;
10974 PyObject *swig_obj[1] ;
10975
10976 if (!args) SWIG_fail;
10977 swig_obj[0] = args;
10978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10981 }
10982 arg1 = reinterpret_cast< wxLog * >(argp1);
10983 {
10984 PyThreadState* __tstate = wxPyBeginAllowThreads();
10985 delete arg1;
10986
10987 wxPyEndAllowThreads(__tstate);
10988 if (PyErr_Occurred()) SWIG_fail;
10989 }
10990 resultobj = SWIG_Py_Void();
10991 return resultobj;
10992 fail:
10993 return NULL;
10994 }
10995
10996
10997 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10998 PyObject *resultobj = 0;
10999 bool result;
11000
11001 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 result = (bool)wxLog::IsEnabled();
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 {
11009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11010 }
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11018 PyObject *resultobj = 0;
11019 bool arg1 = (bool) true ;
11020 bool result;
11021 bool val1 ;
11022 int ecode1 = 0 ;
11023 PyObject * obj0 = 0 ;
11024 char * kwnames[] = {
11025 (char *) "doIt", NULL
11026 };
11027
11028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11029 if (obj0) {
11030 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11031 if (!SWIG_IsOK(ecode1)) {
11032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11033 }
11034 arg1 = static_cast< bool >(val1);
11035 }
11036 {
11037 PyThreadState* __tstate = wxPyBeginAllowThreads();
11038 result = (bool)wxLog::EnableLogging(arg1);
11039 wxPyEndAllowThreads(__tstate);
11040 if (PyErr_Occurred()) SWIG_fail;
11041 }
11042 {
11043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11044 }
11045 return resultobj;
11046 fail:
11047 return NULL;
11048 }
11049
11050
11051 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11052 PyObject *resultobj = 0;
11053 wxLogLevel arg1 ;
11054 wxChar *arg2 = (wxChar *) 0 ;
11055 time_t arg3 ;
11056 unsigned long val1 ;
11057 int ecode1 = 0 ;
11058 void *argp2 = 0 ;
11059 int res2 = 0 ;
11060 unsigned int val3 ;
11061 int ecode3 = 0 ;
11062 PyObject * obj0 = 0 ;
11063 PyObject * obj1 = 0 ;
11064 PyObject * obj2 = 0 ;
11065 char * kwnames[] = {
11066 (char *) "level",(char *) "szString",(char *) "t", NULL
11067 };
11068
11069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11070 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11071 if (!SWIG_IsOK(ecode1)) {
11072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11073 }
11074 arg1 = static_cast< wxLogLevel >(val1);
11075 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11076 if (!SWIG_IsOK(res2)) {
11077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11078 }
11079 arg2 = reinterpret_cast< wxChar * >(argp2);
11080 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11081 if (!SWIG_IsOK(ecode3)) {
11082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11083 }
11084 arg3 = static_cast< time_t >(val3);
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 resultobj = SWIG_Py_Void();
11092 return resultobj;
11093 fail:
11094 return NULL;
11095 }
11096
11097
11098 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11099 PyObject *resultobj = 0;
11100 wxLog *arg1 = (wxLog *) 0 ;
11101 void *argp1 = 0 ;
11102 int res1 = 0 ;
11103 PyObject *swig_obj[1] ;
11104
11105 if (!args) SWIG_fail;
11106 swig_obj[0] = args;
11107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11108 if (!SWIG_IsOK(res1)) {
11109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11110 }
11111 arg1 = reinterpret_cast< wxLog * >(argp1);
11112 {
11113 PyThreadState* __tstate = wxPyBeginAllowThreads();
11114 (arg1)->Flush();
11115 wxPyEndAllowThreads(__tstate);
11116 if (PyErr_Occurred()) SWIG_fail;
11117 }
11118 resultobj = SWIG_Py_Void();
11119 return resultobj;
11120 fail:
11121 return NULL;
11122 }
11123
11124
11125 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11126 PyObject *resultobj = 0;
11127
11128 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11129 {
11130 PyThreadState* __tstate = wxPyBeginAllowThreads();
11131 wxLog::FlushActive();
11132 wxPyEndAllowThreads(__tstate);
11133 if (PyErr_Occurred()) SWIG_fail;
11134 }
11135 resultobj = SWIG_Py_Void();
11136 return resultobj;
11137 fail:
11138 return NULL;
11139 }
11140
11141
11142 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11143 PyObject *resultobj = 0;
11144 wxLog *result = 0 ;
11145
11146 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 result = (wxLog *)wxLog::GetActiveTarget();
11150 wxPyEndAllowThreads(__tstate);
11151 if (PyErr_Occurred()) SWIG_fail;
11152 }
11153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11154 return resultobj;
11155 fail:
11156 return NULL;
11157 }
11158
11159
11160 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11161 PyObject *resultobj = 0;
11162 wxLog *arg1 = (wxLog *) 0 ;
11163 wxLog *result = 0 ;
11164 int res1 = 0 ;
11165 PyObject * obj0 = 0 ;
11166 char * kwnames[] = {
11167 (char *) "pLogger", NULL
11168 };
11169
11170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11171 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11172 if (!SWIG_IsOK(res1)) {
11173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11174 }
11175 {
11176 PyThreadState* __tstate = wxPyBeginAllowThreads();
11177 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11178 wxPyEndAllowThreads(__tstate);
11179 if (PyErr_Occurred()) SWIG_fail;
11180 }
11181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11189 PyObject *resultobj = 0;
11190
11191 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 wxLog::Suspend();
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 resultobj = SWIG_Py_Void();
11199 return resultobj;
11200 fail:
11201 return NULL;
11202 }
11203
11204
11205 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11206 PyObject *resultobj = 0;
11207
11208 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11209 {
11210 PyThreadState* __tstate = wxPyBeginAllowThreads();
11211 wxLog::Resume();
11212 wxPyEndAllowThreads(__tstate);
11213 if (PyErr_Occurred()) SWIG_fail;
11214 }
11215 resultobj = SWIG_Py_Void();
11216 return resultobj;
11217 fail:
11218 return NULL;
11219 }
11220
11221
11222 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11223 PyObject *resultobj = 0;
11224 bool arg1 = (bool) true ;
11225 bool val1 ;
11226 int ecode1 = 0 ;
11227 PyObject * obj0 = 0 ;
11228 char * kwnames[] = {
11229 (char *) "bVerbose", NULL
11230 };
11231
11232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11233 if (obj0) {
11234 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11235 if (!SWIG_IsOK(ecode1)) {
11236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11237 }
11238 arg1 = static_cast< bool >(val1);
11239 }
11240 {
11241 PyThreadState* __tstate = wxPyBeginAllowThreads();
11242 wxLog::SetVerbose(arg1);
11243 wxPyEndAllowThreads(__tstate);
11244 if (PyErr_Occurred()) SWIG_fail;
11245 }
11246 resultobj = SWIG_Py_Void();
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11254 PyObject *resultobj = 0;
11255 wxLogLevel arg1 ;
11256 unsigned long val1 ;
11257 int ecode1 = 0 ;
11258 PyObject * obj0 = 0 ;
11259 char * kwnames[] = {
11260 (char *) "logLevel", NULL
11261 };
11262
11263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11264 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11265 if (!SWIG_IsOK(ecode1)) {
11266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11267 }
11268 arg1 = static_cast< wxLogLevel >(val1);
11269 {
11270 PyThreadState* __tstate = wxPyBeginAllowThreads();
11271 wxLog::SetLogLevel(arg1);
11272 wxPyEndAllowThreads(__tstate);
11273 if (PyErr_Occurred()) SWIG_fail;
11274 }
11275 resultobj = SWIG_Py_Void();
11276 return resultobj;
11277 fail:
11278 return NULL;
11279 }
11280
11281
11282 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11283 PyObject *resultobj = 0;
11284
11285 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 wxLog::DontCreateOnDemand();
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 resultobj = SWIG_Py_Void();
11293 return resultobj;
11294 fail:
11295 return NULL;
11296 }
11297
11298
11299 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11300 PyObject *resultobj = 0;
11301 wxTraceMask arg1 ;
11302 unsigned long val1 ;
11303 int ecode1 = 0 ;
11304 PyObject * obj0 = 0 ;
11305 char * kwnames[] = {
11306 (char *) "ulMask", NULL
11307 };
11308
11309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11310 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11311 if (!SWIG_IsOK(ecode1)) {
11312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11313 }
11314 arg1 = static_cast< wxTraceMask >(val1);
11315 {
11316 PyThreadState* __tstate = wxPyBeginAllowThreads();
11317 wxLog::SetTraceMask(arg1);
11318 wxPyEndAllowThreads(__tstate);
11319 if (PyErr_Occurred()) SWIG_fail;
11320 }
11321 resultobj = SWIG_Py_Void();
11322 return resultobj;
11323 fail:
11324 return NULL;
11325 }
11326
11327
11328 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11329 PyObject *resultobj = 0;
11330 wxString *arg1 = 0 ;
11331 bool temp1 = false ;
11332 PyObject * obj0 = 0 ;
11333 char * kwnames[] = {
11334 (char *) "str", NULL
11335 };
11336
11337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11338 {
11339 arg1 = wxString_in_helper(obj0);
11340 if (arg1 == NULL) SWIG_fail;
11341 temp1 = true;
11342 }
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 wxLog::AddTraceMask((wxString const &)*arg1);
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 resultobj = SWIG_Py_Void();
11350 {
11351 if (temp1)
11352 delete arg1;
11353 }
11354 return resultobj;
11355 fail:
11356 {
11357 if (temp1)
11358 delete arg1;
11359 }
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11365 PyObject *resultobj = 0;
11366 wxString *arg1 = 0 ;
11367 bool temp1 = false ;
11368 PyObject * obj0 = 0 ;
11369 char * kwnames[] = {
11370 (char *) "str", NULL
11371 };
11372
11373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11374 {
11375 arg1 = wxString_in_helper(obj0);
11376 if (arg1 == NULL) SWIG_fail;
11377 temp1 = true;
11378 }
11379 {
11380 PyThreadState* __tstate = wxPyBeginAllowThreads();
11381 wxLog::RemoveTraceMask((wxString const &)*arg1);
11382 wxPyEndAllowThreads(__tstate);
11383 if (PyErr_Occurred()) SWIG_fail;
11384 }
11385 resultobj = SWIG_Py_Void();
11386 {
11387 if (temp1)
11388 delete arg1;
11389 }
11390 return resultobj;
11391 fail:
11392 {
11393 if (temp1)
11394 delete arg1;
11395 }
11396 return NULL;
11397 }
11398
11399
11400 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11401 PyObject *resultobj = 0;
11402
11403 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11404 {
11405 PyThreadState* __tstate = wxPyBeginAllowThreads();
11406 wxLog::ClearTraceMasks();
11407 wxPyEndAllowThreads(__tstate);
11408 if (PyErr_Occurred()) SWIG_fail;
11409 }
11410 resultobj = SWIG_Py_Void();
11411 return resultobj;
11412 fail:
11413 return NULL;
11414 }
11415
11416
11417 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11418 PyObject *resultobj = 0;
11419 wxArrayString *result = 0 ;
11420
11421 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11422 {
11423 PyThreadState* __tstate = wxPyBeginAllowThreads();
11424 {
11425 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11426 result = (wxArrayString *) &_result_ref;
11427 }
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 {
11432 resultobj = wxArrayString2PyList_helper(*result);
11433 }
11434 return resultobj;
11435 fail:
11436 return NULL;
11437 }
11438
11439
11440 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11441 PyObject *resultobj = 0;
11442 wxChar *arg1 = (wxChar *) 0 ;
11443 void *argp1 = 0 ;
11444 int res1 = 0 ;
11445 PyObject * obj0 = 0 ;
11446 char * kwnames[] = {
11447 (char *) "ts", NULL
11448 };
11449
11450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11452 if (!SWIG_IsOK(res1)) {
11453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11454 }
11455 arg1 = reinterpret_cast< wxChar * >(argp1);
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 wxLog::SetTimestamp((wxChar const *)arg1);
11459 wxPyEndAllowThreads(__tstate);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 resultobj = SWIG_Py_Void();
11463 return resultobj;
11464 fail:
11465 return NULL;
11466 }
11467
11468
11469 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11470 PyObject *resultobj = 0;
11471 bool result;
11472
11473 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (bool)wxLog::GetVerbose();
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 {
11481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11482 }
11483 return resultobj;
11484 fail:
11485 return NULL;
11486 }
11487
11488
11489 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11490 PyObject *resultobj = 0;
11491 wxTraceMask result;
11492
11493 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11494 {
11495 PyThreadState* __tstate = wxPyBeginAllowThreads();
11496 result = (wxTraceMask)wxLog::GetTraceMask();
11497 wxPyEndAllowThreads(__tstate);
11498 if (PyErr_Occurred()) SWIG_fail;
11499 }
11500 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11501 return resultobj;
11502 fail:
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj = 0;
11509 wxChar *arg1 = (wxChar *) 0 ;
11510 bool result;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 PyObject * obj0 = 0 ;
11514 char * kwnames[] = {
11515 (char *) "mask", NULL
11516 };
11517
11518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11520 if (!SWIG_IsOK(res1)) {
11521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11522 }
11523 arg1 = reinterpret_cast< wxChar * >(argp1);
11524 {
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 {
11531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11532 }
11533 return resultobj;
11534 fail:
11535 return NULL;
11536 }
11537
11538
11539 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11540 PyObject *resultobj = 0;
11541 wxLogLevel result;
11542
11543 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 result = (wxLogLevel)wxLog::GetLogLevel();
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11551 return resultobj;
11552 fail:
11553 return NULL;
11554 }
11555
11556
11557 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11558 PyObject *resultobj = 0;
11559 wxChar *result = 0 ;
11560
11561 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11562 {
11563 PyThreadState* __tstate = wxPyBeginAllowThreads();
11564 result = (wxChar *)wxLog::GetTimestamp();
11565 wxPyEndAllowThreads(__tstate);
11566 if (PyErr_Occurred()) SWIG_fail;
11567 }
11568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11569 return resultobj;
11570 fail:
11571 return NULL;
11572 }
11573
11574
11575 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11576 PyObject *resultobj = 0;
11577 wxString result;
11578
11579 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11580 {
11581 PyThreadState* __tstate = wxPyBeginAllowThreads();
11582 result = wxLog_TimeStamp();
11583 wxPyEndAllowThreads(__tstate);
11584 if (PyErr_Occurred()) SWIG_fail;
11585 }
11586 {
11587 #if wxUSE_UNICODE
11588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11589 #else
11590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11591 #endif
11592 }
11593 return resultobj;
11594 fail:
11595 return NULL;
11596 }
11597
11598
11599 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11600 PyObject *resultobj = 0;
11601 wxLog *arg1 = (wxLog *) 0 ;
11602 void *argp1 = 0 ;
11603 int res1 = 0 ;
11604 PyObject *swig_obj[1] ;
11605
11606 if (!args) SWIG_fail;
11607 swig_obj[0] = args;
11608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11609 if (!SWIG_IsOK(res1)) {
11610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11611 }
11612 arg1 = reinterpret_cast< wxLog * >(argp1);
11613 {
11614 PyThreadState* __tstate = wxPyBeginAllowThreads();
11615 wxLog_Destroy(arg1);
11616 wxPyEndAllowThreads(__tstate);
11617 if (PyErr_Occurred()) SWIG_fail;
11618 }
11619 resultobj = SWIG_Py_Void();
11620 return resultobj;
11621 fail:
11622 return NULL;
11623 }
11624
11625
11626 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11627 PyObject *obj;
11628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11629 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11630 return SWIG_Py_Void();
11631 }
11632
11633 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11634 return SWIG_Python_InitShadowInstance(args);
11635 }
11636
11637 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11638 PyObject *resultobj = 0;
11639 wxLogStderr *result = 0 ;
11640
11641 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 result = (wxLogStderr *)new wxLogStderr();
11645 wxPyEndAllowThreads(__tstate);
11646 if (PyErr_Occurred()) SWIG_fail;
11647 }
11648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11649 return resultobj;
11650 fail:
11651 return NULL;
11652 }
11653
11654
11655 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11656 PyObject *obj;
11657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11658 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11659 return SWIG_Py_Void();
11660 }
11661
11662 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11663 return SWIG_Python_InitShadowInstance(args);
11664 }
11665
11666 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11667 PyObject *resultobj = 0;
11668 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11669 wxLogTextCtrl *result = 0 ;
11670 void *argp1 = 0 ;
11671 int res1 = 0 ;
11672 PyObject * obj0 = 0 ;
11673 char * kwnames[] = {
11674 (char *) "pTextCtrl", NULL
11675 };
11676
11677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11679 if (!SWIG_IsOK(res1)) {
11680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11681 }
11682 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11683 {
11684 PyThreadState* __tstate = wxPyBeginAllowThreads();
11685 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11690 return resultobj;
11691 fail:
11692 return NULL;
11693 }
11694
11695
11696 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11697 PyObject *obj;
11698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11699 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11700 return SWIG_Py_Void();
11701 }
11702
11703 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11704 return SWIG_Python_InitShadowInstance(args);
11705 }
11706
11707 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11708 PyObject *resultobj = 0;
11709 wxLogGui *result = 0 ;
11710
11711 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11712 {
11713 PyThreadState* __tstate = wxPyBeginAllowThreads();
11714 result = (wxLogGui *)new wxLogGui();
11715 wxPyEndAllowThreads(__tstate);
11716 if (PyErr_Occurred()) SWIG_fail;
11717 }
11718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11719 return resultobj;
11720 fail:
11721 return NULL;
11722 }
11723
11724
11725 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11726 PyObject *obj;
11727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11728 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11729 return SWIG_Py_Void();
11730 }
11731
11732 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11733 return SWIG_Python_InitShadowInstance(args);
11734 }
11735
11736 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11737 PyObject *resultobj = 0;
11738 wxFrame *arg1 = (wxFrame *) 0 ;
11739 wxString *arg2 = 0 ;
11740 bool arg3 = (bool) true ;
11741 bool arg4 = (bool) true ;
11742 wxLogWindow *result = 0 ;
11743 void *argp1 = 0 ;
11744 int res1 = 0 ;
11745 bool temp2 = false ;
11746 bool val3 ;
11747 int ecode3 = 0 ;
11748 bool val4 ;
11749 int ecode4 = 0 ;
11750 PyObject * obj0 = 0 ;
11751 PyObject * obj1 = 0 ;
11752 PyObject * obj2 = 0 ;
11753 PyObject * obj3 = 0 ;
11754 char * kwnames[] = {
11755 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11756 };
11757
11758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11760 if (!SWIG_IsOK(res1)) {
11761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11762 }
11763 arg1 = reinterpret_cast< wxFrame * >(argp1);
11764 {
11765 arg2 = wxString_in_helper(obj1);
11766 if (arg2 == NULL) SWIG_fail;
11767 temp2 = true;
11768 }
11769 if (obj2) {
11770 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11771 if (!SWIG_IsOK(ecode3)) {
11772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11773 }
11774 arg3 = static_cast< bool >(val3);
11775 }
11776 if (obj3) {
11777 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11778 if (!SWIG_IsOK(ecode4)) {
11779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11780 }
11781 arg4 = static_cast< bool >(val4);
11782 }
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11786 wxPyEndAllowThreads(__tstate);
11787 if (PyErr_Occurred()) SWIG_fail;
11788 }
11789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11790 {
11791 if (temp2)
11792 delete arg2;
11793 }
11794 return resultobj;
11795 fail:
11796 {
11797 if (temp2)
11798 delete arg2;
11799 }
11800 return NULL;
11801 }
11802
11803
11804 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11805 PyObject *resultobj = 0;
11806 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11807 bool arg2 = (bool) true ;
11808 void *argp1 = 0 ;
11809 int res1 = 0 ;
11810 bool val2 ;
11811 int ecode2 = 0 ;
11812 PyObject * obj0 = 0 ;
11813 PyObject * obj1 = 0 ;
11814 char * kwnames[] = {
11815 (char *) "self",(char *) "bShow", NULL
11816 };
11817
11818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11820 if (!SWIG_IsOK(res1)) {
11821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11822 }
11823 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11824 if (obj1) {
11825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11826 if (!SWIG_IsOK(ecode2)) {
11827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11828 }
11829 arg2 = static_cast< bool >(val2);
11830 }
11831 {
11832 PyThreadState* __tstate = wxPyBeginAllowThreads();
11833 (arg1)->Show(arg2);
11834 wxPyEndAllowThreads(__tstate);
11835 if (PyErr_Occurred()) SWIG_fail;
11836 }
11837 resultobj = SWIG_Py_Void();
11838 return resultobj;
11839 fail:
11840 return NULL;
11841 }
11842
11843
11844 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11845 PyObject *resultobj = 0;
11846 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11847 wxFrame *result = 0 ;
11848 void *argp1 = 0 ;
11849 int res1 = 0 ;
11850 PyObject *swig_obj[1] ;
11851
11852 if (!args) SWIG_fail;
11853 swig_obj[0] = args;
11854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11855 if (!SWIG_IsOK(res1)) {
11856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11857 }
11858 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11859 {
11860 PyThreadState* __tstate = wxPyBeginAllowThreads();
11861 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11862 wxPyEndAllowThreads(__tstate);
11863 if (PyErr_Occurred()) SWIG_fail;
11864 }
11865 {
11866 resultobj = wxPyMake_wxObject(result, (bool)0);
11867 }
11868 return resultobj;
11869 fail:
11870 return NULL;
11871 }
11872
11873
11874 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11875 PyObject *resultobj = 0;
11876 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11877 wxLog *result = 0 ;
11878 void *argp1 = 0 ;
11879 int res1 = 0 ;
11880 PyObject *swig_obj[1] ;
11881
11882 if (!args) SWIG_fail;
11883 swig_obj[0] = args;
11884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11885 if (!SWIG_IsOK(res1)) {
11886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11887 }
11888 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11896 return resultobj;
11897 fail:
11898 return NULL;
11899 }
11900
11901
11902 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11903 PyObject *resultobj = 0;
11904 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11905 bool result;
11906 void *argp1 = 0 ;
11907 int res1 = 0 ;
11908 PyObject *swig_obj[1] ;
11909
11910 if (!args) SWIG_fail;
11911 swig_obj[0] = args;
11912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11913 if (!SWIG_IsOK(res1)) {
11914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11915 }
11916 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 {
11924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11925 }
11926 return resultobj;
11927 fail:
11928 return NULL;
11929 }
11930
11931
11932 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj = 0;
11934 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11935 bool arg2 ;
11936 void *argp1 = 0 ;
11937 int res1 = 0 ;
11938 bool val2 ;
11939 int ecode2 = 0 ;
11940 PyObject * obj0 = 0 ;
11941 PyObject * obj1 = 0 ;
11942 char * kwnames[] = {
11943 (char *) "self",(char *) "bDoPass", NULL
11944 };
11945
11946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11948 if (!SWIG_IsOK(res1)) {
11949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11950 }
11951 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11953 if (!SWIG_IsOK(ecode2)) {
11954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11955 }
11956 arg2 = static_cast< bool >(val2);
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 (arg1)->PassMessages(arg2);
11960 wxPyEndAllowThreads(__tstate);
11961 if (PyErr_Occurred()) SWIG_fail;
11962 }
11963 resultobj = SWIG_Py_Void();
11964 return resultobj;
11965 fail:
11966 return NULL;
11967 }
11968
11969
11970 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11971 PyObject *obj;
11972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11973 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11974 return SWIG_Py_Void();
11975 }
11976
11977 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11978 return SWIG_Python_InitShadowInstance(args);
11979 }
11980
11981 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11982 PyObject *resultobj = 0;
11983 wxLog *arg1 = (wxLog *) 0 ;
11984 wxLogChain *result = 0 ;
11985 void *argp1 = 0 ;
11986 int res1 = 0 ;
11987 PyObject * obj0 = 0 ;
11988 char * kwnames[] = {
11989 (char *) "logger", NULL
11990 };
11991
11992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
11993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11994 if (!SWIG_IsOK(res1)) {
11995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
11996 }
11997 arg1 = reinterpret_cast< wxLog * >(argp1);
11998 {
11999 PyThreadState* __tstate = wxPyBeginAllowThreads();
12000 result = (wxLogChain *)new wxLogChain(arg1);
12001 wxPyEndAllowThreads(__tstate);
12002 if (PyErr_Occurred()) SWIG_fail;
12003 }
12004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12005 return resultobj;
12006 fail:
12007 return NULL;
12008 }
12009
12010
12011 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12012 PyObject *resultobj = 0;
12013 wxLogChain *arg1 = (wxLogChain *) 0 ;
12014 wxLog *arg2 = (wxLog *) 0 ;
12015 void *argp1 = 0 ;
12016 int res1 = 0 ;
12017 void *argp2 = 0 ;
12018 int res2 = 0 ;
12019 PyObject * obj0 = 0 ;
12020 PyObject * obj1 = 0 ;
12021 char * kwnames[] = {
12022 (char *) "self",(char *) "logger", NULL
12023 };
12024
12025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12027 if (!SWIG_IsOK(res1)) {
12028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12029 }
12030 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12032 if (!SWIG_IsOK(res2)) {
12033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12034 }
12035 arg2 = reinterpret_cast< wxLog * >(argp2);
12036 {
12037 PyThreadState* __tstate = wxPyBeginAllowThreads();
12038 (arg1)->SetLog(arg2);
12039 wxPyEndAllowThreads(__tstate);
12040 if (PyErr_Occurred()) SWIG_fail;
12041 }
12042 resultobj = SWIG_Py_Void();
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj = 0;
12051 wxLogChain *arg1 = (wxLogChain *) 0 ;
12052 bool arg2 ;
12053 void *argp1 = 0 ;
12054 int res1 = 0 ;
12055 bool val2 ;
12056 int ecode2 = 0 ;
12057 PyObject * obj0 = 0 ;
12058 PyObject * obj1 = 0 ;
12059 char * kwnames[] = {
12060 (char *) "self",(char *) "bDoPass", NULL
12061 };
12062
12063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12065 if (!SWIG_IsOK(res1)) {
12066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12067 }
12068 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12069 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12070 if (!SWIG_IsOK(ecode2)) {
12071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12072 }
12073 arg2 = static_cast< bool >(val2);
12074 {
12075 PyThreadState* __tstate = wxPyBeginAllowThreads();
12076 (arg1)->PassMessages(arg2);
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 resultobj = SWIG_Py_Void();
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12088 PyObject *resultobj = 0;
12089 wxLogChain *arg1 = (wxLogChain *) 0 ;
12090 bool result;
12091 void *argp1 = 0 ;
12092 int res1 = 0 ;
12093 PyObject *swig_obj[1] ;
12094
12095 if (!args) SWIG_fail;
12096 swig_obj[0] = args;
12097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12098 if (!SWIG_IsOK(res1)) {
12099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12100 }
12101 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12102 {
12103 PyThreadState* __tstate = wxPyBeginAllowThreads();
12104 result = (bool)(arg1)->IsPassingMessages();
12105 wxPyEndAllowThreads(__tstate);
12106 if (PyErr_Occurred()) SWIG_fail;
12107 }
12108 {
12109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12110 }
12111 return resultobj;
12112 fail:
12113 return NULL;
12114 }
12115
12116
12117 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12118 PyObject *resultobj = 0;
12119 wxLogChain *arg1 = (wxLogChain *) 0 ;
12120 wxLog *result = 0 ;
12121 void *argp1 = 0 ;
12122 int res1 = 0 ;
12123 PyObject *swig_obj[1] ;
12124
12125 if (!args) SWIG_fail;
12126 swig_obj[0] = args;
12127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12128 if (!SWIG_IsOK(res1)) {
12129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12130 }
12131 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 result = (wxLog *)(arg1)->GetOldLog();
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12139 return resultobj;
12140 fail:
12141 return NULL;
12142 }
12143
12144
12145 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12146 PyObject *obj;
12147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12148 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12149 return SWIG_Py_Void();
12150 }
12151
12152 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 return SWIG_Python_InitShadowInstance(args);
12154 }
12155
12156 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12157 PyObject *resultobj = 0;
12158 wxLogBuffer *result = 0 ;
12159
12160 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12161 {
12162 PyThreadState* __tstate = wxPyBeginAllowThreads();
12163 result = (wxLogBuffer *)new wxLogBuffer();
12164 wxPyEndAllowThreads(__tstate);
12165 if (PyErr_Occurred()) SWIG_fail;
12166 }
12167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12168 return resultobj;
12169 fail:
12170 return NULL;
12171 }
12172
12173
12174 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12175 PyObject *resultobj = 0;
12176 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12177 wxString *result = 0 ;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 PyObject *swig_obj[1] ;
12181
12182 if (!args) SWIG_fail;
12183 swig_obj[0] = args;
12184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12185 if (!SWIG_IsOK(res1)) {
12186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12187 }
12188 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12189 {
12190 PyThreadState* __tstate = wxPyBeginAllowThreads();
12191 {
12192 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12193 result = (wxString *) &_result_ref;
12194 }
12195 wxPyEndAllowThreads(__tstate);
12196 if (PyErr_Occurred()) SWIG_fail;
12197 }
12198 {
12199 #if wxUSE_UNICODE
12200 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12201 #else
12202 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12203 #endif
12204 }
12205 return resultobj;
12206 fail:
12207 return NULL;
12208 }
12209
12210
12211 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12212 PyObject *obj;
12213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12214 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12215 return SWIG_Py_Void();
12216 }
12217
12218 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12219 return SWIG_Python_InitShadowInstance(args);
12220 }
12221
12222 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12223 PyObject *resultobj = 0;
12224 unsigned long result;
12225
12226 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 result = (unsigned long)wxSysErrorCode();
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj = 0;
12242 unsigned long arg1 = (unsigned long) 0 ;
12243 wxString result;
12244 unsigned long val1 ;
12245 int ecode1 = 0 ;
12246 PyObject * obj0 = 0 ;
12247 char * kwnames[] = {
12248 (char *) "nErrCode", NULL
12249 };
12250
12251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12252 if (obj0) {
12253 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12254 if (!SWIG_IsOK(ecode1)) {
12255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12256 }
12257 arg1 = static_cast< unsigned long >(val1);
12258 }
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 result = wxSysErrorMsg(arg1);
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 #if wxUSE_UNICODE
12267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12268 #else
12269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12270 #endif
12271 }
12272 return resultobj;
12273 fail:
12274 return NULL;
12275 }
12276
12277
12278 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12279 PyObject *resultobj = 0;
12280 wxString *arg1 = 0 ;
12281 bool temp1 = false ;
12282 PyObject * obj0 = 0 ;
12283 char * kwnames[] = {
12284 (char *) "msg", NULL
12285 };
12286
12287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12288 {
12289 arg1 = wxString_in_helper(obj0);
12290 if (arg1 == NULL) SWIG_fail;
12291 temp1 = true;
12292 }
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 wxPyLogFatalError((wxString const &)*arg1);
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 resultobj = SWIG_Py_Void();
12300 {
12301 if (temp1)
12302 delete arg1;
12303 }
12304 return resultobj;
12305 fail:
12306 {
12307 if (temp1)
12308 delete arg1;
12309 }
12310 return NULL;
12311 }
12312
12313
12314 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12315 PyObject *resultobj = 0;
12316 wxString *arg1 = 0 ;
12317 bool temp1 = false ;
12318 PyObject * obj0 = 0 ;
12319 char * kwnames[] = {
12320 (char *) "msg", NULL
12321 };
12322
12323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12324 {
12325 arg1 = wxString_in_helper(obj0);
12326 if (arg1 == NULL) SWIG_fail;
12327 temp1 = true;
12328 }
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 wxPyLogError((wxString const &)*arg1);
12332 wxPyEndAllowThreads(__tstate);
12333 if (PyErr_Occurred()) SWIG_fail;
12334 }
12335 resultobj = SWIG_Py_Void();
12336 {
12337 if (temp1)
12338 delete arg1;
12339 }
12340 return resultobj;
12341 fail:
12342 {
12343 if (temp1)
12344 delete arg1;
12345 }
12346 return NULL;
12347 }
12348
12349
12350 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12351 PyObject *resultobj = 0;
12352 wxString *arg1 = 0 ;
12353 bool temp1 = false ;
12354 PyObject * obj0 = 0 ;
12355 char * kwnames[] = {
12356 (char *) "msg", NULL
12357 };
12358
12359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12360 {
12361 arg1 = wxString_in_helper(obj0);
12362 if (arg1 == NULL) SWIG_fail;
12363 temp1 = true;
12364 }
12365 {
12366 PyThreadState* __tstate = wxPyBeginAllowThreads();
12367 wxPyLogWarning((wxString const &)*arg1);
12368 wxPyEndAllowThreads(__tstate);
12369 if (PyErr_Occurred()) SWIG_fail;
12370 }
12371 resultobj = SWIG_Py_Void();
12372 {
12373 if (temp1)
12374 delete arg1;
12375 }
12376 return resultobj;
12377 fail:
12378 {
12379 if (temp1)
12380 delete arg1;
12381 }
12382 return NULL;
12383 }
12384
12385
12386 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12387 PyObject *resultobj = 0;
12388 wxString *arg1 = 0 ;
12389 bool temp1 = false ;
12390 PyObject * obj0 = 0 ;
12391 char * kwnames[] = {
12392 (char *) "msg", NULL
12393 };
12394
12395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12396 {
12397 arg1 = wxString_in_helper(obj0);
12398 if (arg1 == NULL) SWIG_fail;
12399 temp1 = true;
12400 }
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 wxPyLogMessage((wxString const &)*arg1);
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 resultobj = SWIG_Py_Void();
12408 {
12409 if (temp1)
12410 delete arg1;
12411 }
12412 return resultobj;
12413 fail:
12414 {
12415 if (temp1)
12416 delete arg1;
12417 }
12418 return NULL;
12419 }
12420
12421
12422 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj = 0;
12424 wxString *arg1 = 0 ;
12425 bool temp1 = false ;
12426 PyObject * obj0 = 0 ;
12427 char * kwnames[] = {
12428 (char *) "msg", NULL
12429 };
12430
12431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12432 {
12433 arg1 = wxString_in_helper(obj0);
12434 if (arg1 == NULL) SWIG_fail;
12435 temp1 = true;
12436 }
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 wxPyLogInfo((wxString const &)*arg1);
12440 wxPyEndAllowThreads(__tstate);
12441 if (PyErr_Occurred()) SWIG_fail;
12442 }
12443 resultobj = SWIG_Py_Void();
12444 {
12445 if (temp1)
12446 delete arg1;
12447 }
12448 return resultobj;
12449 fail:
12450 {
12451 if (temp1)
12452 delete arg1;
12453 }
12454 return NULL;
12455 }
12456
12457
12458 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12459 PyObject *resultobj = 0;
12460 wxString *arg1 = 0 ;
12461 bool temp1 = false ;
12462 PyObject * obj0 = 0 ;
12463 char * kwnames[] = {
12464 (char *) "msg", NULL
12465 };
12466
12467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12468 {
12469 arg1 = wxString_in_helper(obj0);
12470 if (arg1 == NULL) SWIG_fail;
12471 temp1 = true;
12472 }
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 wxPyLogDebug((wxString const &)*arg1);
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 resultobj = SWIG_Py_Void();
12480 {
12481 if (temp1)
12482 delete arg1;
12483 }
12484 return resultobj;
12485 fail:
12486 {
12487 if (temp1)
12488 delete arg1;
12489 }
12490 return NULL;
12491 }
12492
12493
12494 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12495 PyObject *resultobj = 0;
12496 wxString *arg1 = 0 ;
12497 bool temp1 = false ;
12498 PyObject * obj0 = 0 ;
12499 char * kwnames[] = {
12500 (char *) "msg", NULL
12501 };
12502
12503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12504 {
12505 arg1 = wxString_in_helper(obj0);
12506 if (arg1 == NULL) SWIG_fail;
12507 temp1 = true;
12508 }
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 wxPyLogVerbose((wxString const &)*arg1);
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 resultobj = SWIG_Py_Void();
12516 {
12517 if (temp1)
12518 delete arg1;
12519 }
12520 return resultobj;
12521 fail:
12522 {
12523 if (temp1)
12524 delete arg1;
12525 }
12526 return NULL;
12527 }
12528
12529
12530 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12531 PyObject *resultobj = 0;
12532 wxString *arg1 = 0 ;
12533 bool temp1 = false ;
12534 PyObject * obj0 = 0 ;
12535 char * kwnames[] = {
12536 (char *) "msg", NULL
12537 };
12538
12539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12540 {
12541 arg1 = wxString_in_helper(obj0);
12542 if (arg1 == NULL) SWIG_fail;
12543 temp1 = true;
12544 }
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 wxPyLogStatus((wxString const &)*arg1);
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 resultobj = SWIG_Py_Void();
12552 {
12553 if (temp1)
12554 delete arg1;
12555 }
12556 return resultobj;
12557 fail:
12558 {
12559 if (temp1)
12560 delete arg1;
12561 }
12562 return NULL;
12563 }
12564
12565
12566 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12567 PyObject *resultobj = 0;
12568 wxFrame *arg1 = (wxFrame *) 0 ;
12569 wxString *arg2 = 0 ;
12570 void *argp1 = 0 ;
12571 int res1 = 0 ;
12572 bool temp2 = false ;
12573 PyObject * obj0 = 0 ;
12574 PyObject * obj1 = 0 ;
12575 char * kwnames[] = {
12576 (char *) "pFrame",(char *) "msg", NULL
12577 };
12578
12579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12581 if (!SWIG_IsOK(res1)) {
12582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12583 }
12584 arg1 = reinterpret_cast< wxFrame * >(argp1);
12585 {
12586 arg2 = wxString_in_helper(obj1);
12587 if (arg2 == NULL) SWIG_fail;
12588 temp2 = true;
12589 }
12590 {
12591 PyThreadState* __tstate = wxPyBeginAllowThreads();
12592 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12593 wxPyEndAllowThreads(__tstate);
12594 if (PyErr_Occurred()) SWIG_fail;
12595 }
12596 resultobj = SWIG_Py_Void();
12597 {
12598 if (temp2)
12599 delete arg2;
12600 }
12601 return resultobj;
12602 fail:
12603 {
12604 if (temp2)
12605 delete arg2;
12606 }
12607 return NULL;
12608 }
12609
12610
12611 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12612 PyObject *resultobj = 0;
12613 wxString *arg1 = 0 ;
12614 bool temp1 = false ;
12615 PyObject * obj0 = 0 ;
12616 char * kwnames[] = {
12617 (char *) "msg", NULL
12618 };
12619
12620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12621 {
12622 arg1 = wxString_in_helper(obj0);
12623 if (arg1 == NULL) SWIG_fail;
12624 temp1 = true;
12625 }
12626 {
12627 PyThreadState* __tstate = wxPyBeginAllowThreads();
12628 wxPyLogSysError((wxString const &)*arg1);
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 resultobj = SWIG_Py_Void();
12633 {
12634 if (temp1)
12635 delete arg1;
12636 }
12637 return resultobj;
12638 fail:
12639 {
12640 if (temp1)
12641 delete arg1;
12642 }
12643 return NULL;
12644 }
12645
12646
12647 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj = 0;
12649 unsigned long arg1 ;
12650 wxString *arg2 = 0 ;
12651 unsigned long val1 ;
12652 int ecode1 = 0 ;
12653 bool temp2 = false ;
12654 PyObject * obj0 = 0 ;
12655 PyObject * obj1 = 0 ;
12656 char * kwnames[] = {
12657 (char *) "level",(char *) "msg", NULL
12658 };
12659
12660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12661 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12662 if (!SWIG_IsOK(ecode1)) {
12663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12664 }
12665 arg1 = static_cast< unsigned long >(val1);
12666 {
12667 arg2 = wxString_in_helper(obj1);
12668 if (arg2 == NULL) SWIG_fail;
12669 temp2 = true;
12670 }
12671 {
12672 PyThreadState* __tstate = wxPyBeginAllowThreads();
12673 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12674 wxPyEndAllowThreads(__tstate);
12675 if (PyErr_Occurred()) SWIG_fail;
12676 }
12677 resultobj = SWIG_Py_Void();
12678 {
12679 if (temp2)
12680 delete arg2;
12681 }
12682 return resultobj;
12683 fail:
12684 {
12685 if (temp2)
12686 delete arg2;
12687 }
12688 return NULL;
12689 }
12690
12691
12692 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12693 PyObject *resultobj = 0;
12694 unsigned long arg1 ;
12695 wxString *arg2 = 0 ;
12696 unsigned long val1 ;
12697 int ecode1 = 0 ;
12698 bool temp2 = false ;
12699
12700 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12701 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12702 if (!SWIG_IsOK(ecode1)) {
12703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12704 }
12705 arg1 = static_cast< unsigned long >(val1);
12706 {
12707 arg2 = wxString_in_helper(swig_obj[1]);
12708 if (arg2 == NULL) SWIG_fail;
12709 temp2 = true;
12710 }
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 wxPyLogTrace(arg1,(wxString const &)*arg2);
12714 wxPyEndAllowThreads(__tstate);
12715 if (PyErr_Occurred()) SWIG_fail;
12716 }
12717 resultobj = SWIG_Py_Void();
12718 {
12719 if (temp2)
12720 delete arg2;
12721 }
12722 return resultobj;
12723 fail:
12724 {
12725 if (temp2)
12726 delete arg2;
12727 }
12728 return NULL;
12729 }
12730
12731
12732 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12733 PyObject *resultobj = 0;
12734 wxString *arg1 = 0 ;
12735 wxString *arg2 = 0 ;
12736 bool temp1 = false ;
12737 bool temp2 = false ;
12738
12739 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12740 {
12741 arg1 = wxString_in_helper(swig_obj[0]);
12742 if (arg1 == NULL) SWIG_fail;
12743 temp1 = true;
12744 }
12745 {
12746 arg2 = wxString_in_helper(swig_obj[1]);
12747 if (arg2 == NULL) SWIG_fail;
12748 temp2 = true;
12749 }
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 resultobj = SWIG_Py_Void();
12757 {
12758 if (temp1)
12759 delete arg1;
12760 }
12761 {
12762 if (temp2)
12763 delete arg2;
12764 }
12765 return resultobj;
12766 fail:
12767 {
12768 if (temp1)
12769 delete arg1;
12770 }
12771 {
12772 if (temp2)
12773 delete arg2;
12774 }
12775 return NULL;
12776 }
12777
12778
12779 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12780 int argc;
12781 PyObject *argv[3];
12782
12783 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12784 --argc;
12785 if (argc == 2) {
12786 int _v = 0;
12787 {
12788 {
12789 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12790 }
12791 }
12792 if (!_v) goto check_1;
12793 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12794 }
12795 check_1:
12796
12797 if (argc == 2) {
12798 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12799 }
12800
12801 fail:
12802 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12803 return NULL;
12804 }
12805
12806
12807 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12808 PyObject *resultobj = 0;
12809 wxString *arg1 = 0 ;
12810 wxString *arg2 = 0 ;
12811 bool temp1 = false ;
12812 bool temp2 = false ;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 char * kwnames[] = {
12816 (char *) "title",(char *) "text", NULL
12817 };
12818
12819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12820 {
12821 arg1 = wxString_in_helper(obj0);
12822 if (arg1 == NULL) SWIG_fail;
12823 temp1 = true;
12824 }
12825 {
12826 arg2 = wxString_in_helper(obj1);
12827 if (arg2 == NULL) SWIG_fail;
12828 temp2 = true;
12829 }
12830 {
12831 PyThreadState* __tstate = wxPyBeginAllowThreads();
12832 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12833 wxPyEndAllowThreads(__tstate);
12834 if (PyErr_Occurred()) SWIG_fail;
12835 }
12836 resultobj = SWIG_Py_Void();
12837 {
12838 if (temp1)
12839 delete arg1;
12840 }
12841 {
12842 if (temp2)
12843 delete arg2;
12844 }
12845 return resultobj;
12846 fail:
12847 {
12848 if (temp1)
12849 delete arg1;
12850 }
12851 {
12852 if (temp2)
12853 delete arg2;
12854 }
12855 return NULL;
12856 }
12857
12858
12859 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12860 PyObject *resultobj = 0;
12861 wxLogNull *result = 0 ;
12862
12863 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12864 {
12865 PyThreadState* __tstate = wxPyBeginAllowThreads();
12866 result = (wxLogNull *)new wxLogNull();
12867 wxPyEndAllowThreads(__tstate);
12868 if (PyErr_Occurred()) SWIG_fail;
12869 }
12870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12871 return resultobj;
12872 fail:
12873 return NULL;
12874 }
12875
12876
12877 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12878 PyObject *resultobj = 0;
12879 wxLogNull *arg1 = (wxLogNull *) 0 ;
12880 void *argp1 = 0 ;
12881 int res1 = 0 ;
12882 PyObject *swig_obj[1] ;
12883
12884 if (!args) SWIG_fail;
12885 swig_obj[0] = args;
12886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12887 if (!SWIG_IsOK(res1)) {
12888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12889 }
12890 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 delete arg1;
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 resultobj = SWIG_Py_Void();
12899 return resultobj;
12900 fail:
12901 return NULL;
12902 }
12903
12904
12905 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12906 PyObject *obj;
12907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12908 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12909 return SWIG_Py_Void();
12910 }
12911
12912 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913 return SWIG_Python_InitShadowInstance(args);
12914 }
12915
12916 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12917 PyObject *resultobj = 0;
12918 wxPyLog *result = 0 ;
12919
12920 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 result = (wxPyLog *)new wxPyLog();
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12928 return resultobj;
12929 fail:
12930 return NULL;
12931 }
12932
12933
12934 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12935 PyObject *resultobj = 0;
12936 wxPyLog *arg1 = (wxPyLog *) 0 ;
12937 PyObject *arg2 = (PyObject *) 0 ;
12938 PyObject *arg3 = (PyObject *) 0 ;
12939 void *argp1 = 0 ;
12940 int res1 = 0 ;
12941 PyObject * obj0 = 0 ;
12942 PyObject * obj1 = 0 ;
12943 PyObject * obj2 = 0 ;
12944 char * kwnames[] = {
12945 (char *) "self",(char *) "self",(char *) "_class", NULL
12946 };
12947
12948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12950 if (!SWIG_IsOK(res1)) {
12951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12952 }
12953 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12954 arg2 = obj1;
12955 arg3 = obj2;
12956 {
12957 PyThreadState* __tstate = wxPyBeginAllowThreads();
12958 (arg1)->_setCallbackInfo(arg2,arg3);
12959 wxPyEndAllowThreads(__tstate);
12960 if (PyErr_Occurred()) SWIG_fail;
12961 }
12962 resultobj = SWIG_Py_Void();
12963 return resultobj;
12964 fail:
12965 return NULL;
12966 }
12967
12968
12969 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12970 PyObject *obj;
12971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12972 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12973 return SWIG_Py_Void();
12974 }
12975
12976 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12977 return SWIG_Python_InitShadowInstance(args);
12978 }
12979
12980 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12981 PyObject *resultobj = 0;
12982 int arg1 ;
12983 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12984 int arg3 = (int) wxKILL_NOCHILDREN ;
12985 wxKillError result;
12986 int val1 ;
12987 int ecode1 = 0 ;
12988 int val2 ;
12989 int ecode2 = 0 ;
12990 int val3 ;
12991 int ecode3 = 0 ;
12992 PyObject * obj0 = 0 ;
12993 PyObject * obj1 = 0 ;
12994 PyObject * obj2 = 0 ;
12995 char * kwnames[] = {
12996 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12997 };
12998
12999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13000 ecode1 = SWIG_AsVal_int(obj0, &val1);
13001 if (!SWIG_IsOK(ecode1)) {
13002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13003 }
13004 arg1 = static_cast< int >(val1);
13005 if (obj1) {
13006 ecode2 = SWIG_AsVal_int(obj1, &val2);
13007 if (!SWIG_IsOK(ecode2)) {
13008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13009 }
13010 arg2 = static_cast< wxSignal >(val2);
13011 }
13012 if (obj2) {
13013 ecode3 = SWIG_AsVal_int(obj2, &val3);
13014 if (!SWIG_IsOK(ecode3)) {
13015 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13016 }
13017 arg3 = static_cast< int >(val3);
13018 }
13019 {
13020 PyThreadState* __tstate = wxPyBeginAllowThreads();
13021 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 resultobj = SWIG_From_int(static_cast< int >(result));
13026 return resultobj;
13027 fail:
13028 return NULL;
13029 }
13030
13031
13032 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13033 PyObject *resultobj = 0;
13034 int arg1 ;
13035 bool result;
13036 int val1 ;
13037 int ecode1 = 0 ;
13038 PyObject * obj0 = 0 ;
13039 char * kwnames[] = {
13040 (char *) "pid", NULL
13041 };
13042
13043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13044 ecode1 = SWIG_AsVal_int(obj0, &val1);
13045 if (!SWIG_IsOK(ecode1)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13047 }
13048 arg1 = static_cast< int >(val1);
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 result = (bool)wxPyProcess::Exists(arg1);
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 {
13056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13057 }
13058 return resultobj;
13059 fail:
13060 return NULL;
13061 }
13062
13063
13064 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13065 PyObject *resultobj = 0;
13066 wxString *arg1 = 0 ;
13067 int arg2 = (int) wxEXEC_ASYNC ;
13068 wxPyProcess *result = 0 ;
13069 bool temp1 = false ;
13070 int val2 ;
13071 int ecode2 = 0 ;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 char * kwnames[] = {
13075 (char *) "cmd",(char *) "flags", NULL
13076 };
13077
13078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13079 {
13080 arg1 = wxString_in_helper(obj0);
13081 if (arg1 == NULL) SWIG_fail;
13082 temp1 = true;
13083 }
13084 if (obj1) {
13085 ecode2 = SWIG_AsVal_int(obj1, &val2);
13086 if (!SWIG_IsOK(ecode2)) {
13087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13088 }
13089 arg2 = static_cast< int >(val2);
13090 }
13091 {
13092 PyThreadState* __tstate = wxPyBeginAllowThreads();
13093 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13094 wxPyEndAllowThreads(__tstate);
13095 if (PyErr_Occurred()) SWIG_fail;
13096 }
13097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13098 {
13099 if (temp1)
13100 delete arg1;
13101 }
13102 return resultobj;
13103 fail:
13104 {
13105 if (temp1)
13106 delete arg1;
13107 }
13108 return NULL;
13109 }
13110
13111
13112 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13113 PyObject *resultobj = 0;
13114 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13115 int arg2 = (int) -1 ;
13116 wxPyProcess *result = 0 ;
13117 void *argp1 = 0 ;
13118 int res1 = 0 ;
13119 int val2 ;
13120 int ecode2 = 0 ;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 char * kwnames[] = {
13124 (char *) "parent",(char *) "id", NULL
13125 };
13126
13127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13128 if (obj0) {
13129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13130 if (!SWIG_IsOK(res1)) {
13131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13132 }
13133 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13134 }
13135 if (obj1) {
13136 ecode2 = SWIG_AsVal_int(obj1, &val2);
13137 if (!SWIG_IsOK(ecode2)) {
13138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13139 }
13140 arg2 = static_cast< int >(val2);
13141 }
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13145 wxPyEndAllowThreads(__tstate);
13146 if (PyErr_Occurred()) SWIG_fail;
13147 }
13148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj = 0;
13157 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13158 PyObject *arg2 = (PyObject *) 0 ;
13159 PyObject *arg3 = (PyObject *) 0 ;
13160 void *argp1 = 0 ;
13161 int res1 = 0 ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 PyObject * obj2 = 0 ;
13165 char * kwnames[] = {
13166 (char *) "self",(char *) "self",(char *) "_class", NULL
13167 };
13168
13169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13171 if (!SWIG_IsOK(res1)) {
13172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13173 }
13174 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13175 arg2 = obj1;
13176 arg3 = obj2;
13177 {
13178 PyThreadState* __tstate = wxPyBeginAllowThreads();
13179 (arg1)->_setCallbackInfo(arg2,arg3);
13180 wxPyEndAllowThreads(__tstate);
13181 if (PyErr_Occurred()) SWIG_fail;
13182 }
13183 resultobj = SWIG_Py_Void();
13184 return resultobj;
13185 fail:
13186 return NULL;
13187 }
13188
13189
13190 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13191 PyObject *resultobj = 0;
13192 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13193 int arg2 ;
13194 int arg3 ;
13195 void *argp1 = 0 ;
13196 int res1 = 0 ;
13197 int val2 ;
13198 int ecode2 = 0 ;
13199 int val3 ;
13200 int ecode3 = 0 ;
13201 PyObject * obj0 = 0 ;
13202 PyObject * obj1 = 0 ;
13203 PyObject * obj2 = 0 ;
13204 char * kwnames[] = {
13205 (char *) "self",(char *) "pid",(char *) "status", NULL
13206 };
13207
13208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13210 if (!SWIG_IsOK(res1)) {
13211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13212 }
13213 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13214 ecode2 = SWIG_AsVal_int(obj1, &val2);
13215 if (!SWIG_IsOK(ecode2)) {
13216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13217 }
13218 arg2 = static_cast< int >(val2);
13219 ecode3 = SWIG_AsVal_int(obj2, &val3);
13220 if (!SWIG_IsOK(ecode3)) {
13221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13222 }
13223 arg3 = static_cast< int >(val3);
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 (arg1)->OnTerminate(arg2,arg3);
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 resultobj = SWIG_Py_Void();
13231 return resultobj;
13232 fail:
13233 return NULL;
13234 }
13235
13236
13237 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13238 PyObject *resultobj = 0;
13239 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13240 void *argp1 = 0 ;
13241 int res1 = 0 ;
13242 PyObject *swig_obj[1] ;
13243
13244 if (!args) SWIG_fail;
13245 swig_obj[0] = args;
13246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13247 if (!SWIG_IsOK(res1)) {
13248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13249 }
13250 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13251 {
13252 PyThreadState* __tstate = wxPyBeginAllowThreads();
13253 (arg1)->Redirect();
13254 wxPyEndAllowThreads(__tstate);
13255 if (PyErr_Occurred()) SWIG_fail;
13256 }
13257 resultobj = SWIG_Py_Void();
13258 return resultobj;
13259 fail:
13260 return NULL;
13261 }
13262
13263
13264 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13265 PyObject *resultobj = 0;
13266 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13267 bool result;
13268 void *argp1 = 0 ;
13269 int res1 = 0 ;
13270 PyObject *swig_obj[1] ;
13271
13272 if (!args) SWIG_fail;
13273 swig_obj[0] = args;
13274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13275 if (!SWIG_IsOK(res1)) {
13276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13277 }
13278 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 result = (bool)(arg1)->IsRedirected();
13282 wxPyEndAllowThreads(__tstate);
13283 if (PyErr_Occurred()) SWIG_fail;
13284 }
13285 {
13286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13287 }
13288 return resultobj;
13289 fail:
13290 return NULL;
13291 }
13292
13293
13294 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13295 PyObject *resultobj = 0;
13296 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13297 void *argp1 = 0 ;
13298 int res1 = 0 ;
13299 PyObject *swig_obj[1] ;
13300
13301 if (!args) SWIG_fail;
13302 swig_obj[0] = args;
13303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13304 if (!SWIG_IsOK(res1)) {
13305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13306 }
13307 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13308 {
13309 PyThreadState* __tstate = wxPyBeginAllowThreads();
13310 (arg1)->Detach();
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 resultobj = SWIG_Py_Void();
13315 return resultobj;
13316 fail:
13317 return NULL;
13318 }
13319
13320
13321 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13322 PyObject *resultobj = 0;
13323 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13324 wxInputStream *result = 0 ;
13325 void *argp1 = 0 ;
13326 int res1 = 0 ;
13327 PyObject *swig_obj[1] ;
13328
13329 if (!args) SWIG_fail;
13330 swig_obj[0] = args;
13331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13332 if (!SWIG_IsOK(res1)) {
13333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13334 }
13335 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 result = (wxInputStream *)(arg1)->GetInputStream();
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 {
13343 wxPyInputStream * _ptr = NULL;
13344
13345 if (result) {
13346 _ptr = new wxPyInputStream(result);
13347 }
13348 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13349 }
13350 return resultobj;
13351 fail:
13352 return NULL;
13353 }
13354
13355
13356 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13357 PyObject *resultobj = 0;
13358 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13359 wxInputStream *result = 0 ;
13360 void *argp1 = 0 ;
13361 int res1 = 0 ;
13362 PyObject *swig_obj[1] ;
13363
13364 if (!args) SWIG_fail;
13365 swig_obj[0] = args;
13366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13367 if (!SWIG_IsOK(res1)) {
13368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13369 }
13370 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 result = (wxInputStream *)(arg1)->GetErrorStream();
13374 wxPyEndAllowThreads(__tstate);
13375 if (PyErr_Occurred()) SWIG_fail;
13376 }
13377 {
13378 wxPyInputStream * _ptr = NULL;
13379
13380 if (result) {
13381 _ptr = new wxPyInputStream(result);
13382 }
13383 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13384 }
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392 PyObject *resultobj = 0;
13393 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13394 wxOutputStream *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_wxPyProcess, 0 | 0 );
13402 if (!SWIG_IsOK(res1)) {
13403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13404 }
13405 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13406 {
13407 PyThreadState* __tstate = wxPyBeginAllowThreads();
13408 result = (wxOutputStream *)(arg1)->GetOutputStream();
13409 wxPyEndAllowThreads(__tstate);
13410 if (PyErr_Occurred()) SWIG_fail;
13411 }
13412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13413 return resultobj;
13414 fail:
13415 return NULL;
13416 }
13417
13418
13419 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13420 PyObject *resultobj = 0;
13421 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13422 void *argp1 = 0 ;
13423 int res1 = 0 ;
13424 PyObject *swig_obj[1] ;
13425
13426 if (!args) SWIG_fail;
13427 swig_obj[0] = args;
13428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13429 if (!SWIG_IsOK(res1)) {
13430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13431 }
13432 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13433 {
13434 PyThreadState* __tstate = wxPyBeginAllowThreads();
13435 (arg1)->CloseOutput();
13436 wxPyEndAllowThreads(__tstate);
13437 if (PyErr_Occurred()) SWIG_fail;
13438 }
13439 resultobj = SWIG_Py_Void();
13440 return resultobj;
13441 fail:
13442 return NULL;
13443 }
13444
13445
13446 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13447 PyObject *resultobj = 0;
13448 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13449 bool result;
13450 void *argp1 = 0 ;
13451 int res1 = 0 ;
13452 PyObject *swig_obj[1] ;
13453
13454 if (!args) SWIG_fail;
13455 swig_obj[0] = args;
13456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13457 if (!SWIG_IsOK(res1)) {
13458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13459 }
13460 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13461 {
13462 PyThreadState* __tstate = wxPyBeginAllowThreads();
13463 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 {
13468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13469 }
13470 return resultobj;
13471 fail:
13472 return NULL;
13473 }
13474
13475
13476 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13477 PyObject *resultobj = 0;
13478 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13479 bool result;
13480 void *argp1 = 0 ;
13481 int res1 = 0 ;
13482 PyObject *swig_obj[1] ;
13483
13484 if (!args) SWIG_fail;
13485 swig_obj[0] = args;
13486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13487 if (!SWIG_IsOK(res1)) {
13488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13489 }
13490 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13499 }
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13507 PyObject *resultobj = 0;
13508 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13509 bool result;
13510 void *argp1 = 0 ;
13511 int res1 = 0 ;
13512 PyObject *swig_obj[1] ;
13513
13514 if (!args) SWIG_fail;
13515 swig_obj[0] = args;
13516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13517 if (!SWIG_IsOK(res1)) {
13518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13519 }
13520 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13521 {
13522 PyThreadState* __tstate = wxPyBeginAllowThreads();
13523 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13524 wxPyEndAllowThreads(__tstate);
13525 if (PyErr_Occurred()) SWIG_fail;
13526 }
13527 {
13528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13529 }
13530 return resultobj;
13531 fail:
13532 return NULL;
13533 }
13534
13535
13536 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13537 PyObject *obj;
13538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13539 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13540 return SWIG_Py_Void();
13541 }
13542
13543 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13544 return SWIG_Python_InitShadowInstance(args);
13545 }
13546
13547 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13548 PyObject *resultobj = 0;
13549 int arg1 = (int) 0 ;
13550 int arg2 = (int) 0 ;
13551 int arg3 = (int) 0 ;
13552 wxProcessEvent *result = 0 ;
13553 int val1 ;
13554 int ecode1 = 0 ;
13555 int val2 ;
13556 int ecode2 = 0 ;
13557 int val3 ;
13558 int ecode3 = 0 ;
13559 PyObject * obj0 = 0 ;
13560 PyObject * obj1 = 0 ;
13561 PyObject * obj2 = 0 ;
13562 char * kwnames[] = {
13563 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13564 };
13565
13566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13567 if (obj0) {
13568 ecode1 = SWIG_AsVal_int(obj0, &val1);
13569 if (!SWIG_IsOK(ecode1)) {
13570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13571 }
13572 arg1 = static_cast< int >(val1);
13573 }
13574 if (obj1) {
13575 ecode2 = SWIG_AsVal_int(obj1, &val2);
13576 if (!SWIG_IsOK(ecode2)) {
13577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13578 }
13579 arg2 = static_cast< int >(val2);
13580 }
13581 if (obj2) {
13582 ecode3 = SWIG_AsVal_int(obj2, &val3);
13583 if (!SWIG_IsOK(ecode3)) {
13584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13585 }
13586 arg3 = static_cast< int >(val3);
13587 }
13588 {
13589 PyThreadState* __tstate = wxPyBeginAllowThreads();
13590 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13595 return resultobj;
13596 fail:
13597 return NULL;
13598 }
13599
13600
13601 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13602 PyObject *resultobj = 0;
13603 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13604 int result;
13605 void *argp1 = 0 ;
13606 int res1 = 0 ;
13607 PyObject *swig_obj[1] ;
13608
13609 if (!args) SWIG_fail;
13610 swig_obj[0] = args;
13611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13612 if (!SWIG_IsOK(res1)) {
13613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13614 }
13615 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13616 {
13617 PyThreadState* __tstate = wxPyBeginAllowThreads();
13618 result = (int)(arg1)->GetPid();
13619 wxPyEndAllowThreads(__tstate);
13620 if (PyErr_Occurred()) SWIG_fail;
13621 }
13622 resultobj = SWIG_From_int(static_cast< int >(result));
13623 return resultobj;
13624 fail:
13625 return NULL;
13626 }
13627
13628
13629 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13630 PyObject *resultobj = 0;
13631 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13632 int result;
13633 void *argp1 = 0 ;
13634 int res1 = 0 ;
13635 PyObject *swig_obj[1] ;
13636
13637 if (!args) SWIG_fail;
13638 swig_obj[0] = args;
13639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13640 if (!SWIG_IsOK(res1)) {
13641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13642 }
13643 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13644 {
13645 PyThreadState* __tstate = wxPyBeginAllowThreads();
13646 result = (int)(arg1)->GetExitCode();
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 resultobj = SWIG_From_int(static_cast< int >(result));
13651 return resultobj;
13652 fail:
13653 return NULL;
13654 }
13655
13656
13657 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13658 PyObject *resultobj = 0;
13659 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13660 int arg2 ;
13661 void *argp1 = 0 ;
13662 int res1 = 0 ;
13663 int val2 ;
13664 int ecode2 = 0 ;
13665 PyObject *swig_obj[2] ;
13666
13667 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13669 if (!SWIG_IsOK(res1)) {
13670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13671 }
13672 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13674 if (!SWIG_IsOK(ecode2)) {
13675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13676 }
13677 arg2 = static_cast< int >(val2);
13678 if (arg1) (arg1)->m_pid = arg2;
13679
13680 resultobj = SWIG_Py_Void();
13681 return resultobj;
13682 fail:
13683 return NULL;
13684 }
13685
13686
13687 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13688 PyObject *resultobj = 0;
13689 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13690 int result;
13691 void *argp1 = 0 ;
13692 int res1 = 0 ;
13693 PyObject *swig_obj[1] ;
13694
13695 if (!args) SWIG_fail;
13696 swig_obj[0] = args;
13697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13698 if (!SWIG_IsOK(res1)) {
13699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13700 }
13701 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13702 result = (int) ((arg1)->m_pid);
13703 resultobj = SWIG_From_int(static_cast< int >(result));
13704 return resultobj;
13705 fail:
13706 return NULL;
13707 }
13708
13709
13710 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13711 PyObject *resultobj = 0;
13712 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13713 int arg2 ;
13714 void *argp1 = 0 ;
13715 int res1 = 0 ;
13716 int val2 ;
13717 int ecode2 = 0 ;
13718 PyObject *swig_obj[2] ;
13719
13720 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13722 if (!SWIG_IsOK(res1)) {
13723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13724 }
13725 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13726 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13727 if (!SWIG_IsOK(ecode2)) {
13728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13729 }
13730 arg2 = static_cast< int >(val2);
13731 if (arg1) (arg1)->m_exitcode = arg2;
13732
13733 resultobj = SWIG_Py_Void();
13734 return resultobj;
13735 fail:
13736 return NULL;
13737 }
13738
13739
13740 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13741 PyObject *resultobj = 0;
13742 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13743 int result;
13744 void *argp1 = 0 ;
13745 int res1 = 0 ;
13746 PyObject *swig_obj[1] ;
13747
13748 if (!args) SWIG_fail;
13749 swig_obj[0] = args;
13750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13751 if (!SWIG_IsOK(res1)) {
13752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13753 }
13754 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13755 result = (int) ((arg1)->m_exitcode);
13756 resultobj = SWIG_From_int(static_cast< int >(result));
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13764 PyObject *obj;
13765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13766 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13767 return SWIG_Py_Void();
13768 }
13769
13770 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13771 return SWIG_Python_InitShadowInstance(args);
13772 }
13773
13774 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13775 PyObject *resultobj = 0;
13776 wxString *arg1 = 0 ;
13777 int arg2 = (int) wxEXEC_ASYNC ;
13778 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13779 long result;
13780 bool temp1 = false ;
13781 int val2 ;
13782 int ecode2 = 0 ;
13783 void *argp3 = 0 ;
13784 int res3 = 0 ;
13785 PyObject * obj0 = 0 ;
13786 PyObject * obj1 = 0 ;
13787 PyObject * obj2 = 0 ;
13788 char * kwnames[] = {
13789 (char *) "command",(char *) "flags",(char *) "process", NULL
13790 };
13791
13792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13793 {
13794 arg1 = wxString_in_helper(obj0);
13795 if (arg1 == NULL) SWIG_fail;
13796 temp1 = true;
13797 }
13798 if (obj1) {
13799 ecode2 = SWIG_AsVal_int(obj1, &val2);
13800 if (!SWIG_IsOK(ecode2)) {
13801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13802 }
13803 arg2 = static_cast< int >(val2);
13804 }
13805 if (obj2) {
13806 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13807 if (!SWIG_IsOK(res3)) {
13808 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13809 }
13810 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13811 }
13812 {
13813 if (!wxPyCheckForApp()) SWIG_fail;
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_From_long(static_cast< long >(result));
13820 {
13821 if (temp1)
13822 delete arg1;
13823 }
13824 return resultobj;
13825 fail:
13826 {
13827 if (temp1)
13828 delete arg1;
13829 }
13830 return NULL;
13831 }
13832
13833
13834 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13835 PyObject *resultobj = 0;
13836 long arg1 ;
13837 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13838 wxKillError *arg3 = (wxKillError *) 0 ;
13839 int arg4 = (int) wxKILL_NOCHILDREN ;
13840 int result;
13841 long val1 ;
13842 int ecode1 = 0 ;
13843 int val2 ;
13844 int ecode2 = 0 ;
13845 wxKillError temp3 ;
13846 int val4 ;
13847 int ecode4 = 0 ;
13848 PyObject * obj0 = 0 ;
13849 PyObject * obj1 = 0 ;
13850 PyObject * obj2 = 0 ;
13851 char * kwnames[] = {
13852 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13853 };
13854
13855 {
13856 arg3 = &temp3;
13857 }
13858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13859 ecode1 = SWIG_AsVal_long(obj0, &val1);
13860 if (!SWIG_IsOK(ecode1)) {
13861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13862 }
13863 arg1 = static_cast< long >(val1);
13864 if (obj1) {
13865 ecode2 = SWIG_AsVal_int(obj1, &val2);
13866 if (!SWIG_IsOK(ecode2)) {
13867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13868 }
13869 arg2 = static_cast< wxSignal >(val2);
13870 }
13871 if (obj2) {
13872 ecode4 = SWIG_AsVal_int(obj2, &val4);
13873 if (!SWIG_IsOK(ecode4)) {
13874 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13875 }
13876 arg4 = static_cast< int >(val4);
13877 }
13878 {
13879 PyThreadState* __tstate = wxPyBeginAllowThreads();
13880 result = (int)wxKill(arg1,arg2,arg3,arg4);
13881 wxPyEndAllowThreads(__tstate);
13882 if (PyErr_Occurred()) SWIG_fail;
13883 }
13884 resultobj = SWIG_From_int(static_cast< int >(result));
13885 {
13886 PyObject* o;
13887 o = PyInt_FromLong((long) (*arg3));
13888
13889
13890
13891 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13892
13893 }
13894 return resultobj;
13895 fail:
13896 return NULL;
13897 }
13898
13899
13900 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13901 PyObject *resultobj = 0;
13902 int arg1 = (int) wxJOYSTICK1 ;
13903 wxJoystick *result = 0 ;
13904 int val1 ;
13905 int ecode1 = 0 ;
13906 PyObject * obj0 = 0 ;
13907 char * kwnames[] = {
13908 (char *) "joystick", NULL
13909 };
13910
13911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13912 if (obj0) {
13913 ecode1 = SWIG_AsVal_int(obj0, &val1);
13914 if (!SWIG_IsOK(ecode1)) {
13915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13916 }
13917 arg1 = static_cast< int >(val1);
13918 }
13919 {
13920 if (!wxPyCheckForApp()) SWIG_fail;
13921 PyThreadState* __tstate = wxPyBeginAllowThreads();
13922 result = (wxJoystick *)new wxJoystick(arg1);
13923 wxPyEndAllowThreads(__tstate);
13924 if (PyErr_Occurred()) SWIG_fail;
13925 }
13926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13927 return resultobj;
13928 fail:
13929 return NULL;
13930 }
13931
13932
13933 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13934 PyObject *resultobj = 0;
13935 wxJoystick *arg1 = (wxJoystick *) 0 ;
13936 void *argp1 = 0 ;
13937 int res1 = 0 ;
13938 PyObject *swig_obj[1] ;
13939
13940 if (!args) SWIG_fail;
13941 swig_obj[0] = args;
13942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13943 if (!SWIG_IsOK(res1)) {
13944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13945 }
13946 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13947 {
13948 PyThreadState* __tstate = wxPyBeginAllowThreads();
13949 delete arg1;
13950
13951 wxPyEndAllowThreads(__tstate);
13952 if (PyErr_Occurred()) SWIG_fail;
13953 }
13954 resultobj = SWIG_Py_Void();
13955 return resultobj;
13956 fail:
13957 return NULL;
13958 }
13959
13960
13961 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13962 PyObject *resultobj = 0;
13963 wxJoystick *arg1 = (wxJoystick *) 0 ;
13964 wxPoint result;
13965 void *argp1 = 0 ;
13966 int res1 = 0 ;
13967 PyObject *swig_obj[1] ;
13968
13969 if (!args) SWIG_fail;
13970 swig_obj[0] = args;
13971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13972 if (!SWIG_IsOK(res1)) {
13973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13974 }
13975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13976 {
13977 PyThreadState* __tstate = wxPyBeginAllowThreads();
13978 result = (arg1)->GetPosition();
13979 wxPyEndAllowThreads(__tstate);
13980 if (PyErr_Occurred()) SWIG_fail;
13981 }
13982 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13983 return resultobj;
13984 fail:
13985 return NULL;
13986 }
13987
13988
13989 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13990 PyObject *resultobj = 0;
13991 wxJoystick *arg1 = (wxJoystick *) 0 ;
13992 int result;
13993 void *argp1 = 0 ;
13994 int res1 = 0 ;
13995 PyObject *swig_obj[1] ;
13996
13997 if (!args) SWIG_fail;
13998 swig_obj[0] = args;
13999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14000 if (!SWIG_IsOK(res1)) {
14001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14002 }
14003 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14004 {
14005 PyThreadState* __tstate = wxPyBeginAllowThreads();
14006 result = (int)(arg1)->GetZPosition();
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 resultobj = SWIG_From_int(static_cast< int >(result));
14011 return resultobj;
14012 fail:
14013 return NULL;
14014 }
14015
14016
14017 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14018 PyObject *resultobj = 0;
14019 wxJoystick *arg1 = (wxJoystick *) 0 ;
14020 int result;
14021 void *argp1 = 0 ;
14022 int res1 = 0 ;
14023 PyObject *swig_obj[1] ;
14024
14025 if (!args) SWIG_fail;
14026 swig_obj[0] = args;
14027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14028 if (!SWIG_IsOK(res1)) {
14029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14030 }
14031 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14032 {
14033 PyThreadState* __tstate = wxPyBeginAllowThreads();
14034 result = (int)(arg1)->GetButtonState();
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 resultobj = SWIG_From_int(static_cast< int >(result));
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14046 PyObject *resultobj = 0;
14047 wxJoystick *arg1 = (wxJoystick *) 0 ;
14048 int result;
14049 void *argp1 = 0 ;
14050 int res1 = 0 ;
14051 PyObject *swig_obj[1] ;
14052
14053 if (!args) SWIG_fail;
14054 swig_obj[0] = args;
14055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14056 if (!SWIG_IsOK(res1)) {
14057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14058 }
14059 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14060 {
14061 PyThreadState* __tstate = wxPyBeginAllowThreads();
14062 result = (int)(arg1)->GetPOVPosition();
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 resultobj = SWIG_From_int(static_cast< int >(result));
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14074 PyObject *resultobj = 0;
14075 wxJoystick *arg1 = (wxJoystick *) 0 ;
14076 int result;
14077 void *argp1 = 0 ;
14078 int res1 = 0 ;
14079 PyObject *swig_obj[1] ;
14080
14081 if (!args) SWIG_fail;
14082 swig_obj[0] = args;
14083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14084 if (!SWIG_IsOK(res1)) {
14085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14086 }
14087 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14088 {
14089 PyThreadState* __tstate = wxPyBeginAllowThreads();
14090 result = (int)(arg1)->GetPOVCTSPosition();
14091 wxPyEndAllowThreads(__tstate);
14092 if (PyErr_Occurred()) SWIG_fail;
14093 }
14094 resultobj = SWIG_From_int(static_cast< int >(result));
14095 return resultobj;
14096 fail:
14097 return NULL;
14098 }
14099
14100
14101 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14102 PyObject *resultobj = 0;
14103 wxJoystick *arg1 = (wxJoystick *) 0 ;
14104 int result;
14105 void *argp1 = 0 ;
14106 int res1 = 0 ;
14107 PyObject *swig_obj[1] ;
14108
14109 if (!args) SWIG_fail;
14110 swig_obj[0] = args;
14111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14112 if (!SWIG_IsOK(res1)) {
14113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14114 }
14115 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14116 {
14117 PyThreadState* __tstate = wxPyBeginAllowThreads();
14118 result = (int)(arg1)->GetRudderPosition();
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 resultobj = SWIG_From_int(static_cast< int >(result));
14123 return resultobj;
14124 fail:
14125 return NULL;
14126 }
14127
14128
14129 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14130 PyObject *resultobj = 0;
14131 wxJoystick *arg1 = (wxJoystick *) 0 ;
14132 int result;
14133 void *argp1 = 0 ;
14134 int res1 = 0 ;
14135 PyObject *swig_obj[1] ;
14136
14137 if (!args) SWIG_fail;
14138 swig_obj[0] = args;
14139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14140 if (!SWIG_IsOK(res1)) {
14141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14142 }
14143 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (int)(arg1)->GetUPosition();
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 resultobj = SWIG_From_int(static_cast< int >(result));
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14158 PyObject *resultobj = 0;
14159 wxJoystick *arg1 = (wxJoystick *) 0 ;
14160 int result;
14161 void *argp1 = 0 ;
14162 int res1 = 0 ;
14163 PyObject *swig_obj[1] ;
14164
14165 if (!args) SWIG_fail;
14166 swig_obj[0] = args;
14167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14168 if (!SWIG_IsOK(res1)) {
14169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14170 }
14171 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14172 {
14173 PyThreadState* __tstate = wxPyBeginAllowThreads();
14174 result = (int)(arg1)->GetVPosition();
14175 wxPyEndAllowThreads(__tstate);
14176 if (PyErr_Occurred()) SWIG_fail;
14177 }
14178 resultobj = SWIG_From_int(static_cast< int >(result));
14179 return resultobj;
14180 fail:
14181 return NULL;
14182 }
14183
14184
14185 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14186 PyObject *resultobj = 0;
14187 wxJoystick *arg1 = (wxJoystick *) 0 ;
14188 int result;
14189 void *argp1 = 0 ;
14190 int res1 = 0 ;
14191 PyObject *swig_obj[1] ;
14192
14193 if (!args) SWIG_fail;
14194 swig_obj[0] = args;
14195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14196 if (!SWIG_IsOK(res1)) {
14197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14198 }
14199 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 result = (int)(arg1)->GetMovementThreshold();
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 resultobj = SWIG_From_int(static_cast< int >(result));
14207 return resultobj;
14208 fail:
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14214 PyObject *resultobj = 0;
14215 wxJoystick *arg1 = (wxJoystick *) 0 ;
14216 int arg2 ;
14217 void *argp1 = 0 ;
14218 int res1 = 0 ;
14219 int val2 ;
14220 int ecode2 = 0 ;
14221 PyObject * obj0 = 0 ;
14222 PyObject * obj1 = 0 ;
14223 char * kwnames[] = {
14224 (char *) "self",(char *) "threshold", NULL
14225 };
14226
14227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14229 if (!SWIG_IsOK(res1)) {
14230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14231 }
14232 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14233 ecode2 = SWIG_AsVal_int(obj1, &val2);
14234 if (!SWIG_IsOK(ecode2)) {
14235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14236 }
14237 arg2 = static_cast< int >(val2);
14238 {
14239 PyThreadState* __tstate = wxPyBeginAllowThreads();
14240 (arg1)->SetMovementThreshold(arg2);
14241 wxPyEndAllowThreads(__tstate);
14242 if (PyErr_Occurred()) SWIG_fail;
14243 }
14244 resultobj = SWIG_Py_Void();
14245 return resultobj;
14246 fail:
14247 return NULL;
14248 }
14249
14250
14251 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14252 PyObject *resultobj = 0;
14253 wxJoystick *arg1 = (wxJoystick *) 0 ;
14254 bool result;
14255 void *argp1 = 0 ;
14256 int res1 = 0 ;
14257 PyObject *swig_obj[1] ;
14258
14259 if (!args) SWIG_fail;
14260 swig_obj[0] = args;
14261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14262 if (!SWIG_IsOK(res1)) {
14263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14264 }
14265 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 result = (bool)(arg1)->IsOk();
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 {
14273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14274 }
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14282 PyObject *resultobj = 0;
14283 wxJoystick *arg1 = (wxJoystick *) 0 ;
14284 int result;
14285 void *argp1 = 0 ;
14286 int res1 = 0 ;
14287 PyObject *swig_obj[1] ;
14288
14289 if (!args) SWIG_fail;
14290 swig_obj[0] = args;
14291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14292 if (!SWIG_IsOK(res1)) {
14293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14294 }
14295 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14296 {
14297 PyThreadState* __tstate = wxPyBeginAllowThreads();
14298 result = (int)(arg1)->GetNumberJoysticks();
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 resultobj = SWIG_From_int(static_cast< int >(result));
14303 return resultobj;
14304 fail:
14305 return NULL;
14306 }
14307
14308
14309 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14310 PyObject *resultobj = 0;
14311 wxJoystick *arg1 = (wxJoystick *) 0 ;
14312 int result;
14313 void *argp1 = 0 ;
14314 int res1 = 0 ;
14315 PyObject *swig_obj[1] ;
14316
14317 if (!args) SWIG_fail;
14318 swig_obj[0] = args;
14319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14320 if (!SWIG_IsOK(res1)) {
14321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14322 }
14323 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (int)(arg1)->GetManufacturerId();
14327 wxPyEndAllowThreads(__tstate);
14328 if (PyErr_Occurred()) SWIG_fail;
14329 }
14330 resultobj = SWIG_From_int(static_cast< int >(result));
14331 return resultobj;
14332 fail:
14333 return NULL;
14334 }
14335
14336
14337 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14338 PyObject *resultobj = 0;
14339 wxJoystick *arg1 = (wxJoystick *) 0 ;
14340 int result;
14341 void *argp1 = 0 ;
14342 int res1 = 0 ;
14343 PyObject *swig_obj[1] ;
14344
14345 if (!args) SWIG_fail;
14346 swig_obj[0] = args;
14347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14348 if (!SWIG_IsOK(res1)) {
14349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14350 }
14351 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14352 {
14353 PyThreadState* __tstate = wxPyBeginAllowThreads();
14354 result = (int)(arg1)->GetProductId();
14355 wxPyEndAllowThreads(__tstate);
14356 if (PyErr_Occurred()) SWIG_fail;
14357 }
14358 resultobj = SWIG_From_int(static_cast< int >(result));
14359 return resultobj;
14360 fail:
14361 return NULL;
14362 }
14363
14364
14365 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14366 PyObject *resultobj = 0;
14367 wxJoystick *arg1 = (wxJoystick *) 0 ;
14368 wxString result;
14369 void *argp1 = 0 ;
14370 int res1 = 0 ;
14371 PyObject *swig_obj[1] ;
14372
14373 if (!args) SWIG_fail;
14374 swig_obj[0] = args;
14375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14376 if (!SWIG_IsOK(res1)) {
14377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14378 }
14379 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14380 {
14381 PyThreadState* __tstate = wxPyBeginAllowThreads();
14382 result = (arg1)->GetProductName();
14383 wxPyEndAllowThreads(__tstate);
14384 if (PyErr_Occurred()) SWIG_fail;
14385 }
14386 {
14387 #if wxUSE_UNICODE
14388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14389 #else
14390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14391 #endif
14392 }
14393 return resultobj;
14394 fail:
14395 return NULL;
14396 }
14397
14398
14399 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14400 PyObject *resultobj = 0;
14401 wxJoystick *arg1 = (wxJoystick *) 0 ;
14402 int result;
14403 void *argp1 = 0 ;
14404 int res1 = 0 ;
14405 PyObject *swig_obj[1] ;
14406
14407 if (!args) SWIG_fail;
14408 swig_obj[0] = args;
14409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14410 if (!SWIG_IsOK(res1)) {
14411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14412 }
14413 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14414 {
14415 PyThreadState* __tstate = wxPyBeginAllowThreads();
14416 result = (int)(arg1)->GetXMin();
14417 wxPyEndAllowThreads(__tstate);
14418 if (PyErr_Occurred()) SWIG_fail;
14419 }
14420 resultobj = SWIG_From_int(static_cast< int >(result));
14421 return resultobj;
14422 fail:
14423 return NULL;
14424 }
14425
14426
14427 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14428 PyObject *resultobj = 0;
14429 wxJoystick *arg1 = (wxJoystick *) 0 ;
14430 int result;
14431 void *argp1 = 0 ;
14432 int res1 = 0 ;
14433 PyObject *swig_obj[1] ;
14434
14435 if (!args) SWIG_fail;
14436 swig_obj[0] = args;
14437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14438 if (!SWIG_IsOK(res1)) {
14439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14440 }
14441 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14442 {
14443 PyThreadState* __tstate = wxPyBeginAllowThreads();
14444 result = (int)(arg1)->GetYMin();
14445 wxPyEndAllowThreads(__tstate);
14446 if (PyErr_Occurred()) SWIG_fail;
14447 }
14448 resultobj = SWIG_From_int(static_cast< int >(result));
14449 return resultobj;
14450 fail:
14451 return NULL;
14452 }
14453
14454
14455 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14456 PyObject *resultobj = 0;
14457 wxJoystick *arg1 = (wxJoystick *) 0 ;
14458 int result;
14459 void *argp1 = 0 ;
14460 int res1 = 0 ;
14461 PyObject *swig_obj[1] ;
14462
14463 if (!args) SWIG_fail;
14464 swig_obj[0] = args;
14465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14466 if (!SWIG_IsOK(res1)) {
14467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14468 }
14469 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14470 {
14471 PyThreadState* __tstate = wxPyBeginAllowThreads();
14472 result = (int)(arg1)->GetZMin();
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 resultobj = SWIG_From_int(static_cast< int >(result));
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14484 PyObject *resultobj = 0;
14485 wxJoystick *arg1 = (wxJoystick *) 0 ;
14486 int result;
14487 void *argp1 = 0 ;
14488 int res1 = 0 ;
14489 PyObject *swig_obj[1] ;
14490
14491 if (!args) SWIG_fail;
14492 swig_obj[0] = args;
14493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14494 if (!SWIG_IsOK(res1)) {
14495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14496 }
14497 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 result = (int)(arg1)->GetXMax();
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 resultobj = SWIG_From_int(static_cast< int >(result));
14505 return resultobj;
14506 fail:
14507 return NULL;
14508 }
14509
14510
14511 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14512 PyObject *resultobj = 0;
14513 wxJoystick *arg1 = (wxJoystick *) 0 ;
14514 int result;
14515 void *argp1 = 0 ;
14516 int res1 = 0 ;
14517 PyObject *swig_obj[1] ;
14518
14519 if (!args) SWIG_fail;
14520 swig_obj[0] = args;
14521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14522 if (!SWIG_IsOK(res1)) {
14523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14524 }
14525 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (int)(arg1)->GetYMax();
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 resultobj = SWIG_From_int(static_cast< int >(result));
14533 return resultobj;
14534 fail:
14535 return NULL;
14536 }
14537
14538
14539 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14540 PyObject *resultobj = 0;
14541 wxJoystick *arg1 = (wxJoystick *) 0 ;
14542 int result;
14543 void *argp1 = 0 ;
14544 int res1 = 0 ;
14545 PyObject *swig_obj[1] ;
14546
14547 if (!args) SWIG_fail;
14548 swig_obj[0] = args;
14549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14550 if (!SWIG_IsOK(res1)) {
14551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14552 }
14553 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14554 {
14555 PyThreadState* __tstate = wxPyBeginAllowThreads();
14556 result = (int)(arg1)->GetZMax();
14557 wxPyEndAllowThreads(__tstate);
14558 if (PyErr_Occurred()) SWIG_fail;
14559 }
14560 resultobj = SWIG_From_int(static_cast< int >(result));
14561 return resultobj;
14562 fail:
14563 return NULL;
14564 }
14565
14566
14567 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14568 PyObject *resultobj = 0;
14569 wxJoystick *arg1 = (wxJoystick *) 0 ;
14570 int result;
14571 void *argp1 = 0 ;
14572 int res1 = 0 ;
14573 PyObject *swig_obj[1] ;
14574
14575 if (!args) SWIG_fail;
14576 swig_obj[0] = args;
14577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14578 if (!SWIG_IsOK(res1)) {
14579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14580 }
14581 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 result = (int)(arg1)->GetNumberButtons();
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 resultobj = SWIG_From_int(static_cast< int >(result));
14589 return resultobj;
14590 fail:
14591 return NULL;
14592 }
14593
14594
14595 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14596 PyObject *resultobj = 0;
14597 wxJoystick *arg1 = (wxJoystick *) 0 ;
14598 int result;
14599 void *argp1 = 0 ;
14600 int res1 = 0 ;
14601 PyObject *swig_obj[1] ;
14602
14603 if (!args) SWIG_fail;
14604 swig_obj[0] = args;
14605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14606 if (!SWIG_IsOK(res1)) {
14607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14608 }
14609 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14610 {
14611 PyThreadState* __tstate = wxPyBeginAllowThreads();
14612 result = (int)(arg1)->GetNumberAxes();
14613 wxPyEndAllowThreads(__tstate);
14614 if (PyErr_Occurred()) SWIG_fail;
14615 }
14616 resultobj = SWIG_From_int(static_cast< int >(result));
14617 return resultobj;
14618 fail:
14619 return NULL;
14620 }
14621
14622
14623 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14624 PyObject *resultobj = 0;
14625 wxJoystick *arg1 = (wxJoystick *) 0 ;
14626 int result;
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_wxJoystick, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14636 }
14637 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14638 {
14639 PyThreadState* __tstate = wxPyBeginAllowThreads();
14640 result = (int)(arg1)->GetMaxButtons();
14641 wxPyEndAllowThreads(__tstate);
14642 if (PyErr_Occurred()) SWIG_fail;
14643 }
14644 resultobj = SWIG_From_int(static_cast< int >(result));
14645 return resultobj;
14646 fail:
14647 return NULL;
14648 }
14649
14650
14651 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14652 PyObject *resultobj = 0;
14653 wxJoystick *arg1 = (wxJoystick *) 0 ;
14654 int result;
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_wxJoystick, 0 | 0 );
14662 if (!SWIG_IsOK(res1)) {
14663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14664 }
14665 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14666 {
14667 PyThreadState* __tstate = wxPyBeginAllowThreads();
14668 result = (int)(arg1)->GetMaxAxes();
14669 wxPyEndAllowThreads(__tstate);
14670 if (PyErr_Occurred()) SWIG_fail;
14671 }
14672 resultobj = SWIG_From_int(static_cast< int >(result));
14673 return resultobj;
14674 fail:
14675 return NULL;
14676 }
14677
14678
14679 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14680 PyObject *resultobj = 0;
14681 wxJoystick *arg1 = (wxJoystick *) 0 ;
14682 int result;
14683 void *argp1 = 0 ;
14684 int res1 = 0 ;
14685 PyObject *swig_obj[1] ;
14686
14687 if (!args) SWIG_fail;
14688 swig_obj[0] = args;
14689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14690 if (!SWIG_IsOK(res1)) {
14691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14692 }
14693 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14694 {
14695 PyThreadState* __tstate = wxPyBeginAllowThreads();
14696 result = (int)(arg1)->GetPollingMin();
14697 wxPyEndAllowThreads(__tstate);
14698 if (PyErr_Occurred()) SWIG_fail;
14699 }
14700 resultobj = SWIG_From_int(static_cast< int >(result));
14701 return resultobj;
14702 fail:
14703 return NULL;
14704 }
14705
14706
14707 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14708 PyObject *resultobj = 0;
14709 wxJoystick *arg1 = (wxJoystick *) 0 ;
14710 int result;
14711 void *argp1 = 0 ;
14712 int res1 = 0 ;
14713 PyObject *swig_obj[1] ;
14714
14715 if (!args) SWIG_fail;
14716 swig_obj[0] = args;
14717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14720 }
14721 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (int)(arg1)->GetPollingMax();
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 resultobj = SWIG_From_int(static_cast< int >(result));
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14736 PyObject *resultobj = 0;
14737 wxJoystick *arg1 = (wxJoystick *) 0 ;
14738 int result;
14739 void *argp1 = 0 ;
14740 int res1 = 0 ;
14741 PyObject *swig_obj[1] ;
14742
14743 if (!args) SWIG_fail;
14744 swig_obj[0] = args;
14745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14746 if (!SWIG_IsOK(res1)) {
14747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14748 }
14749 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14750 {
14751 PyThreadState* __tstate = wxPyBeginAllowThreads();
14752 result = (int)(arg1)->GetRudderMin();
14753 wxPyEndAllowThreads(__tstate);
14754 if (PyErr_Occurred()) SWIG_fail;
14755 }
14756 resultobj = SWIG_From_int(static_cast< int >(result));
14757 return resultobj;
14758 fail:
14759 return NULL;
14760 }
14761
14762
14763 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14764 PyObject *resultobj = 0;
14765 wxJoystick *arg1 = (wxJoystick *) 0 ;
14766 int result;
14767 void *argp1 = 0 ;
14768 int res1 = 0 ;
14769 PyObject *swig_obj[1] ;
14770
14771 if (!args) SWIG_fail;
14772 swig_obj[0] = args;
14773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14774 if (!SWIG_IsOK(res1)) {
14775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14776 }
14777 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 result = (int)(arg1)->GetRudderMax();
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 resultobj = SWIG_From_int(static_cast< int >(result));
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14792 PyObject *resultobj = 0;
14793 wxJoystick *arg1 = (wxJoystick *) 0 ;
14794 int result;
14795 void *argp1 = 0 ;
14796 int res1 = 0 ;
14797 PyObject *swig_obj[1] ;
14798
14799 if (!args) SWIG_fail;
14800 swig_obj[0] = args;
14801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14802 if (!SWIG_IsOK(res1)) {
14803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14804 }
14805 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14806 {
14807 PyThreadState* __tstate = wxPyBeginAllowThreads();
14808 result = (int)(arg1)->GetUMin();
14809 wxPyEndAllowThreads(__tstate);
14810 if (PyErr_Occurred()) SWIG_fail;
14811 }
14812 resultobj = SWIG_From_int(static_cast< int >(result));
14813 return resultobj;
14814 fail:
14815 return NULL;
14816 }
14817
14818
14819 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14820 PyObject *resultobj = 0;
14821 wxJoystick *arg1 = (wxJoystick *) 0 ;
14822 int result;
14823 void *argp1 = 0 ;
14824 int res1 = 0 ;
14825 PyObject *swig_obj[1] ;
14826
14827 if (!args) SWIG_fail;
14828 swig_obj[0] = args;
14829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14830 if (!SWIG_IsOK(res1)) {
14831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14832 }
14833 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14834 {
14835 PyThreadState* __tstate = wxPyBeginAllowThreads();
14836 result = (int)(arg1)->GetUMax();
14837 wxPyEndAllowThreads(__tstate);
14838 if (PyErr_Occurred()) SWIG_fail;
14839 }
14840 resultobj = SWIG_From_int(static_cast< int >(result));
14841 return resultobj;
14842 fail:
14843 return NULL;
14844 }
14845
14846
14847 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14848 PyObject *resultobj = 0;
14849 wxJoystick *arg1 = (wxJoystick *) 0 ;
14850 int result;
14851 void *argp1 = 0 ;
14852 int res1 = 0 ;
14853 PyObject *swig_obj[1] ;
14854
14855 if (!args) SWIG_fail;
14856 swig_obj[0] = args;
14857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14858 if (!SWIG_IsOK(res1)) {
14859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14860 }
14861 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14862 {
14863 PyThreadState* __tstate = wxPyBeginAllowThreads();
14864 result = (int)(arg1)->GetVMin();
14865 wxPyEndAllowThreads(__tstate);
14866 if (PyErr_Occurred()) SWIG_fail;
14867 }
14868 resultobj = SWIG_From_int(static_cast< int >(result));
14869 return resultobj;
14870 fail:
14871 return NULL;
14872 }
14873
14874
14875 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14876 PyObject *resultobj = 0;
14877 wxJoystick *arg1 = (wxJoystick *) 0 ;
14878 int result;
14879 void *argp1 = 0 ;
14880 int res1 = 0 ;
14881 PyObject *swig_obj[1] ;
14882
14883 if (!args) SWIG_fail;
14884 swig_obj[0] = args;
14885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14886 if (!SWIG_IsOK(res1)) {
14887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14888 }
14889 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14890 {
14891 PyThreadState* __tstate = wxPyBeginAllowThreads();
14892 result = (int)(arg1)->GetVMax();
14893 wxPyEndAllowThreads(__tstate);
14894 if (PyErr_Occurred()) SWIG_fail;
14895 }
14896 resultobj = SWIG_From_int(static_cast< int >(result));
14897 return resultobj;
14898 fail:
14899 return NULL;
14900 }
14901
14902
14903 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14904 PyObject *resultobj = 0;
14905 wxJoystick *arg1 = (wxJoystick *) 0 ;
14906 bool result;
14907 void *argp1 = 0 ;
14908 int res1 = 0 ;
14909 PyObject *swig_obj[1] ;
14910
14911 if (!args) SWIG_fail;
14912 swig_obj[0] = args;
14913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14914 if (!SWIG_IsOK(res1)) {
14915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14916 }
14917 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 result = (bool)(arg1)->HasRudder();
14921 wxPyEndAllowThreads(__tstate);
14922 if (PyErr_Occurred()) SWIG_fail;
14923 }
14924 {
14925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14926 }
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14934 PyObject *resultobj = 0;
14935 wxJoystick *arg1 = (wxJoystick *) 0 ;
14936 bool result;
14937 void *argp1 = 0 ;
14938 int res1 = 0 ;
14939 PyObject *swig_obj[1] ;
14940
14941 if (!args) SWIG_fail;
14942 swig_obj[0] = args;
14943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14944 if (!SWIG_IsOK(res1)) {
14945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14946 }
14947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (bool)(arg1)->HasZ();
14951 wxPyEndAllowThreads(__tstate);
14952 if (PyErr_Occurred()) SWIG_fail;
14953 }
14954 {
14955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14956 }
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14964 PyObject *resultobj = 0;
14965 wxJoystick *arg1 = (wxJoystick *) 0 ;
14966 bool result;
14967 void *argp1 = 0 ;
14968 int res1 = 0 ;
14969 PyObject *swig_obj[1] ;
14970
14971 if (!args) SWIG_fail;
14972 swig_obj[0] = args;
14973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14974 if (!SWIG_IsOK(res1)) {
14975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14976 }
14977 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14978 {
14979 PyThreadState* __tstate = wxPyBeginAllowThreads();
14980 result = (bool)(arg1)->HasU();
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 {
14985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14986 }
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14994 PyObject *resultobj = 0;
14995 wxJoystick *arg1 = (wxJoystick *) 0 ;
14996 bool result;
14997 void *argp1 = 0 ;
14998 int res1 = 0 ;
14999 PyObject *swig_obj[1] ;
15000
15001 if (!args) SWIG_fail;
15002 swig_obj[0] = args;
15003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15004 if (!SWIG_IsOK(res1)) {
15005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15006 }
15007 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 result = (bool)(arg1)->HasV();
15011 wxPyEndAllowThreads(__tstate);
15012 if (PyErr_Occurred()) SWIG_fail;
15013 }
15014 {
15015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15016 }
15017 return resultobj;
15018 fail:
15019 return NULL;
15020 }
15021
15022
15023 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15024 PyObject *resultobj = 0;
15025 wxJoystick *arg1 = (wxJoystick *) 0 ;
15026 bool result;
15027 void *argp1 = 0 ;
15028 int res1 = 0 ;
15029 PyObject *swig_obj[1] ;
15030
15031 if (!args) SWIG_fail;
15032 swig_obj[0] = args;
15033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15034 if (!SWIG_IsOK(res1)) {
15035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15036 }
15037 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15038 {
15039 PyThreadState* __tstate = wxPyBeginAllowThreads();
15040 result = (bool)(arg1)->HasPOV();
15041 wxPyEndAllowThreads(__tstate);
15042 if (PyErr_Occurred()) SWIG_fail;
15043 }
15044 {
15045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15046 }
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15054 PyObject *resultobj = 0;
15055 wxJoystick *arg1 = (wxJoystick *) 0 ;
15056 bool result;
15057 void *argp1 = 0 ;
15058 int res1 = 0 ;
15059 PyObject *swig_obj[1] ;
15060
15061 if (!args) SWIG_fail;
15062 swig_obj[0] = args;
15063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15064 if (!SWIG_IsOK(res1)) {
15065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15066 }
15067 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15068 {
15069 PyThreadState* __tstate = wxPyBeginAllowThreads();
15070 result = (bool)(arg1)->HasPOV4Dir();
15071 wxPyEndAllowThreads(__tstate);
15072 if (PyErr_Occurred()) SWIG_fail;
15073 }
15074 {
15075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15076 }
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15084 PyObject *resultobj = 0;
15085 wxJoystick *arg1 = (wxJoystick *) 0 ;
15086 bool result;
15087 void *argp1 = 0 ;
15088 int res1 = 0 ;
15089 PyObject *swig_obj[1] ;
15090
15091 if (!args) SWIG_fail;
15092 swig_obj[0] = args;
15093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15094 if (!SWIG_IsOK(res1)) {
15095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15096 }
15097 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 result = (bool)(arg1)->HasPOVCTS();
15101 wxPyEndAllowThreads(__tstate);
15102 if (PyErr_Occurred()) SWIG_fail;
15103 }
15104 {
15105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15106 }
15107 return resultobj;
15108 fail:
15109 return NULL;
15110 }
15111
15112
15113 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15114 PyObject *resultobj = 0;
15115 wxJoystick *arg1 = (wxJoystick *) 0 ;
15116 wxWindow *arg2 = (wxWindow *) 0 ;
15117 int arg3 = (int) 0 ;
15118 bool result;
15119 void *argp1 = 0 ;
15120 int res1 = 0 ;
15121 void *argp2 = 0 ;
15122 int res2 = 0 ;
15123 int val3 ;
15124 int ecode3 = 0 ;
15125 PyObject * obj0 = 0 ;
15126 PyObject * obj1 = 0 ;
15127 PyObject * obj2 = 0 ;
15128 char * kwnames[] = {
15129 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15130 };
15131
15132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15134 if (!SWIG_IsOK(res1)) {
15135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15136 }
15137 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15139 if (!SWIG_IsOK(res2)) {
15140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15141 }
15142 arg2 = reinterpret_cast< wxWindow * >(argp2);
15143 if (obj2) {
15144 ecode3 = SWIG_AsVal_int(obj2, &val3);
15145 if (!SWIG_IsOK(ecode3)) {
15146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15147 }
15148 arg3 = static_cast< int >(val3);
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (bool)(arg1)->SetCapture(arg2,arg3);
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 {
15157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15158 }
15159 return resultobj;
15160 fail:
15161 return NULL;
15162 }
15163
15164
15165 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15166 PyObject *resultobj = 0;
15167 wxJoystick *arg1 = (wxJoystick *) 0 ;
15168 bool result;
15169 void *argp1 = 0 ;
15170 int res1 = 0 ;
15171 PyObject *swig_obj[1] ;
15172
15173 if (!args) SWIG_fail;
15174 swig_obj[0] = args;
15175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15176 if (!SWIG_IsOK(res1)) {
15177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15178 }
15179 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (bool)(arg1)->ReleaseCapture();
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 {
15187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15188 }
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15196 PyObject *obj;
15197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15198 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15199 return SWIG_Py_Void();
15200 }
15201
15202 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15203 return SWIG_Python_InitShadowInstance(args);
15204 }
15205
15206 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15207 PyObject *resultobj = 0;
15208 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15209 int arg2 = (int) 0 ;
15210 int arg3 = (int) wxJOYSTICK1 ;
15211 int arg4 = (int) 0 ;
15212 wxJoystickEvent *result = 0 ;
15213 int val1 ;
15214 int ecode1 = 0 ;
15215 int val2 ;
15216 int ecode2 = 0 ;
15217 int val3 ;
15218 int ecode3 = 0 ;
15219 int val4 ;
15220 int ecode4 = 0 ;
15221 PyObject * obj0 = 0 ;
15222 PyObject * obj1 = 0 ;
15223 PyObject * obj2 = 0 ;
15224 PyObject * obj3 = 0 ;
15225 char * kwnames[] = {
15226 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15227 };
15228
15229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15230 if (obj0) {
15231 ecode1 = SWIG_AsVal_int(obj0, &val1);
15232 if (!SWIG_IsOK(ecode1)) {
15233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15234 }
15235 arg1 = static_cast< wxEventType >(val1);
15236 }
15237 if (obj1) {
15238 ecode2 = SWIG_AsVal_int(obj1, &val2);
15239 if (!SWIG_IsOK(ecode2)) {
15240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15241 }
15242 arg2 = static_cast< int >(val2);
15243 }
15244 if (obj2) {
15245 ecode3 = SWIG_AsVal_int(obj2, &val3);
15246 if (!SWIG_IsOK(ecode3)) {
15247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15248 }
15249 arg3 = static_cast< int >(val3);
15250 }
15251 if (obj3) {
15252 ecode4 = SWIG_AsVal_int(obj3, &val4);
15253 if (!SWIG_IsOK(ecode4)) {
15254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15255 }
15256 arg4 = static_cast< int >(val4);
15257 }
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15274 wxPoint result;
15275 void *argp1 = 0 ;
15276 int res1 = 0 ;
15277 PyObject *swig_obj[1] ;
15278
15279 if (!args) SWIG_fail;
15280 swig_obj[0] = args;
15281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15282 if (!SWIG_IsOK(res1)) {
15283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15284 }
15285 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15286 {
15287 PyThreadState* __tstate = wxPyBeginAllowThreads();
15288 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300 PyObject *resultobj = 0;
15301 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15302 int result;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 PyObject *swig_obj[1] ;
15306
15307 if (!args) SWIG_fail;
15308 swig_obj[0] = args;
15309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15310 if (!SWIG_IsOK(res1)) {
15311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15312 }
15313 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 resultobj = SWIG_From_int(static_cast< int >(result));
15321 return resultobj;
15322 fail:
15323 return NULL;
15324 }
15325
15326
15327 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15328 PyObject *resultobj = 0;
15329 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15330 int result;
15331 void *argp1 = 0 ;
15332 int res1 = 0 ;
15333 PyObject *swig_obj[1] ;
15334
15335 if (!args) SWIG_fail;
15336 swig_obj[0] = args;
15337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15340 }
15341 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 resultobj = SWIG_From_int(static_cast< int >(result));
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15356 PyObject *resultobj = 0;
15357 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15358 int result;
15359 void *argp1 = 0 ;
15360 int res1 = 0 ;
15361 PyObject *swig_obj[1] ;
15362
15363 if (!args) SWIG_fail;
15364 swig_obj[0] = args;
15365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15366 if (!SWIG_IsOK(res1)) {
15367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15368 }
15369 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = SWIG_From_int(static_cast< int >(result));
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15386 int result;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15396 }
15397 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = SWIG_From_int(static_cast< int >(result));
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15412 PyObject *resultobj = 0;
15413 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15414 int arg2 ;
15415 void *argp1 = 0 ;
15416 int res1 = 0 ;
15417 int val2 ;
15418 int ecode2 = 0 ;
15419 PyObject * obj0 = 0 ;
15420 PyObject * obj1 = 0 ;
15421 char * kwnames[] = {
15422 (char *) "self",(char *) "stick", NULL
15423 };
15424
15425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15429 }
15430 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15431 ecode2 = SWIG_AsVal_int(obj1, &val2);
15432 if (!SWIG_IsOK(ecode2)) {
15433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15434 }
15435 arg2 = static_cast< int >(val2);
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 (arg1)->SetJoystick(arg2);
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 resultobj = SWIG_Py_Void();
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj = 0;
15451 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15452 int arg2 ;
15453 void *argp1 = 0 ;
15454 int res1 = 0 ;
15455 int val2 ;
15456 int ecode2 = 0 ;
15457 PyObject * obj0 = 0 ;
15458 PyObject * obj1 = 0 ;
15459 char * kwnames[] = {
15460 (char *) "self",(char *) "state", NULL
15461 };
15462
15463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15465 if (!SWIG_IsOK(res1)) {
15466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15467 }
15468 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15469 ecode2 = SWIG_AsVal_int(obj1, &val2);
15470 if (!SWIG_IsOK(ecode2)) {
15471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15472 }
15473 arg2 = static_cast< int >(val2);
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 (arg1)->SetButtonState(arg2);
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = SWIG_Py_Void();
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = 0;
15489 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15490 int arg2 ;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 int val2 ;
15494 int ecode2 = 0 ;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 char * kwnames[] = {
15498 (char *) "self",(char *) "change", NULL
15499 };
15500
15501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15503 if (!SWIG_IsOK(res1)) {
15504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15505 }
15506 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15507 ecode2 = SWIG_AsVal_int(obj1, &val2);
15508 if (!SWIG_IsOK(ecode2)) {
15509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15510 }
15511 arg2 = static_cast< int >(val2);
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 (arg1)->SetButtonChange(arg2);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_Py_Void();
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15526 PyObject *resultobj = 0;
15527 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15528 wxPoint *arg2 = 0 ;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 wxPoint temp2 ;
15532 PyObject * obj0 = 0 ;
15533 PyObject * obj1 = 0 ;
15534 char * kwnames[] = {
15535 (char *) "self",(char *) "pos", NULL
15536 };
15537
15538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15540 if (!SWIG_IsOK(res1)) {
15541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15542 }
15543 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15544 {
15545 arg2 = &temp2;
15546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15547 }
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 (arg1)->SetPosition((wxPoint const &)*arg2);
15551 wxPyEndAllowThreads(__tstate);
15552 if (PyErr_Occurred()) SWIG_fail;
15553 }
15554 resultobj = SWIG_Py_Void();
15555 return resultobj;
15556 fail:
15557 return NULL;
15558 }
15559
15560
15561 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15562 PyObject *resultobj = 0;
15563 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15564 int arg2 ;
15565 void *argp1 = 0 ;
15566 int res1 = 0 ;
15567 int val2 ;
15568 int ecode2 = 0 ;
15569 PyObject * obj0 = 0 ;
15570 PyObject * obj1 = 0 ;
15571 char * kwnames[] = {
15572 (char *) "self",(char *) "zPos", NULL
15573 };
15574
15575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15577 if (!SWIG_IsOK(res1)) {
15578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15579 }
15580 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15581 ecode2 = SWIG_AsVal_int(obj1, &val2);
15582 if (!SWIG_IsOK(ecode2)) {
15583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15584 }
15585 arg2 = static_cast< int >(val2);
15586 {
15587 PyThreadState* __tstate = wxPyBeginAllowThreads();
15588 (arg1)->SetZPosition(arg2);
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 resultobj = SWIG_Py_Void();
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15600 PyObject *resultobj = 0;
15601 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15602 bool result;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 PyObject *swig_obj[1] ;
15606
15607 if (!args) SWIG_fail;
15608 swig_obj[0] = args;
15609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15610 if (!SWIG_IsOK(res1)) {
15611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15612 }
15613 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15617 wxPyEndAllowThreads(__tstate);
15618 if (PyErr_Occurred()) SWIG_fail;
15619 }
15620 {
15621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15622 }
15623 return resultobj;
15624 fail:
15625 return NULL;
15626 }
15627
15628
15629 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15630 PyObject *resultobj = 0;
15631 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15632 bool result;
15633 void *argp1 = 0 ;
15634 int res1 = 0 ;
15635 PyObject *swig_obj[1] ;
15636
15637 if (!args) SWIG_fail;
15638 swig_obj[0] = args;
15639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15640 if (!SWIG_IsOK(res1)) {
15641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15642 }
15643 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15644 {
15645 PyThreadState* __tstate = wxPyBeginAllowThreads();
15646 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15647 wxPyEndAllowThreads(__tstate);
15648 if (PyErr_Occurred()) SWIG_fail;
15649 }
15650 {
15651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15652 }
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15660 PyObject *resultobj = 0;
15661 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15662 bool result;
15663 void *argp1 = 0 ;
15664 int res1 = 0 ;
15665 PyObject *swig_obj[1] ;
15666
15667 if (!args) SWIG_fail;
15668 swig_obj[0] = args;
15669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15670 if (!SWIG_IsOK(res1)) {
15671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15672 }
15673 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15674 {
15675 PyThreadState* __tstate = wxPyBeginAllowThreads();
15676 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15677 wxPyEndAllowThreads(__tstate);
15678 if (PyErr_Occurred()) SWIG_fail;
15679 }
15680 {
15681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15682 }
15683 return resultobj;
15684 fail:
15685 return NULL;
15686 }
15687
15688
15689 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15690 PyObject *resultobj = 0;
15691 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15692 int arg2 = (int) wxJOY_BUTTON_ANY ;
15693 bool result;
15694 void *argp1 = 0 ;
15695 int res1 = 0 ;
15696 int val2 ;
15697 int ecode2 = 0 ;
15698 PyObject * obj0 = 0 ;
15699 PyObject * obj1 = 0 ;
15700 char * kwnames[] = {
15701 (char *) "self",(char *) "but", NULL
15702 };
15703
15704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15706 if (!SWIG_IsOK(res1)) {
15707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15708 }
15709 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15710 if (obj1) {
15711 ecode2 = SWIG_AsVal_int(obj1, &val2);
15712 if (!SWIG_IsOK(ecode2)) {
15713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15714 }
15715 arg2 = static_cast< int >(val2);
15716 }
15717 {
15718 PyThreadState* __tstate = wxPyBeginAllowThreads();
15719 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15720 wxPyEndAllowThreads(__tstate);
15721 if (PyErr_Occurred()) SWIG_fail;
15722 }
15723 {
15724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15725 }
15726 return resultobj;
15727 fail:
15728 return NULL;
15729 }
15730
15731
15732 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15733 PyObject *resultobj = 0;
15734 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15735 int arg2 = (int) wxJOY_BUTTON_ANY ;
15736 bool result;
15737 void *argp1 = 0 ;
15738 int res1 = 0 ;
15739 int val2 ;
15740 int ecode2 = 0 ;
15741 PyObject * obj0 = 0 ;
15742 PyObject * obj1 = 0 ;
15743 char * kwnames[] = {
15744 (char *) "self",(char *) "but", NULL
15745 };
15746
15747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15751 }
15752 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15753 if (obj1) {
15754 ecode2 = SWIG_AsVal_int(obj1, &val2);
15755 if (!SWIG_IsOK(ecode2)) {
15756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15757 }
15758 arg2 = static_cast< int >(val2);
15759 }
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 {
15767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15768 }
15769 return resultobj;
15770 fail:
15771 return NULL;
15772 }
15773
15774
15775 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15776 PyObject *resultobj = 0;
15777 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15778 int arg2 = (int) wxJOY_BUTTON_ANY ;
15779 bool result;
15780 void *argp1 = 0 ;
15781 int res1 = 0 ;
15782 int val2 ;
15783 int ecode2 = 0 ;
15784 PyObject * obj0 = 0 ;
15785 PyObject * obj1 = 0 ;
15786 char * kwnames[] = {
15787 (char *) "self",(char *) "but", NULL
15788 };
15789
15790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15792 if (!SWIG_IsOK(res1)) {
15793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15794 }
15795 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15796 if (obj1) {
15797 ecode2 = SWIG_AsVal_int(obj1, &val2);
15798 if (!SWIG_IsOK(ecode2)) {
15799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15800 }
15801 arg2 = static_cast< int >(val2);
15802 }
15803 {
15804 PyThreadState* __tstate = wxPyBeginAllowThreads();
15805 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15806 wxPyEndAllowThreads(__tstate);
15807 if (PyErr_Occurred()) SWIG_fail;
15808 }
15809 {
15810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15811 }
15812 return resultobj;
15813 fail:
15814 return NULL;
15815 }
15816
15817
15818 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15819 PyObject *obj;
15820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15821 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15822 return SWIG_Py_Void();
15823 }
15824
15825 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15826 return SWIG_Python_InitShadowInstance(args);
15827 }
15828
15829 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15830 PyObject *resultobj = 0;
15831 wxString const &arg1_defvalue = wxPyEmptyString ;
15832 wxString *arg1 = (wxString *) &arg1_defvalue ;
15833 wxSound *result = 0 ;
15834 bool temp1 = false ;
15835 PyObject * obj0 = 0 ;
15836 char * kwnames[] = {
15837 (char *) "fileName", NULL
15838 };
15839
15840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15841 if (obj0) {
15842 {
15843 arg1 = wxString_in_helper(obj0);
15844 if (arg1 == NULL) SWIG_fail;
15845 temp1 = true;
15846 }
15847 }
15848 {
15849 if (!wxPyCheckForApp()) SWIG_fail;
15850 PyThreadState* __tstate = wxPyBeginAllowThreads();
15851 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15852 wxPyEndAllowThreads(__tstate);
15853 if (PyErr_Occurred()) SWIG_fail;
15854 }
15855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15856 {
15857 if (temp1)
15858 delete arg1;
15859 }
15860 return resultobj;
15861 fail:
15862 {
15863 if (temp1)
15864 delete arg1;
15865 }
15866 return NULL;
15867 }
15868
15869
15870 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15871 PyObject *resultobj = 0;
15872 PyObject *arg1 = (PyObject *) 0 ;
15873 wxSound *result = 0 ;
15874 PyObject * obj0 = 0 ;
15875 char * kwnames[] = {
15876 (char *) "data", NULL
15877 };
15878
15879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15880 arg1 = obj0;
15881 {
15882 if (!wxPyCheckForApp()) SWIG_fail;
15883 PyThreadState* __tstate = wxPyBeginAllowThreads();
15884 result = (wxSound *)new_wxSound(arg1);
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15889 return resultobj;
15890 fail:
15891 return NULL;
15892 }
15893
15894
15895 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15896 PyObject *resultobj = 0;
15897 wxSound *arg1 = (wxSound *) 0 ;
15898 void *argp1 = 0 ;
15899 int res1 = 0 ;
15900 PyObject *swig_obj[1] ;
15901
15902 if (!args) SWIG_fail;
15903 swig_obj[0] = args;
15904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15905 if (!SWIG_IsOK(res1)) {
15906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15907 }
15908 arg1 = reinterpret_cast< wxSound * >(argp1);
15909 {
15910 PyThreadState* __tstate = wxPyBeginAllowThreads();
15911 delete arg1;
15912
15913 wxPyEndAllowThreads(__tstate);
15914 if (PyErr_Occurred()) SWIG_fail;
15915 }
15916 resultobj = SWIG_Py_Void();
15917 return resultobj;
15918 fail:
15919 return NULL;
15920 }
15921
15922
15923 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15924 PyObject *resultobj = 0;
15925 wxSound *arg1 = (wxSound *) 0 ;
15926 wxString *arg2 = 0 ;
15927 bool result;
15928 void *argp1 = 0 ;
15929 int res1 = 0 ;
15930 bool temp2 = false ;
15931 PyObject * obj0 = 0 ;
15932 PyObject * obj1 = 0 ;
15933 char * kwnames[] = {
15934 (char *) "self",(char *) "fileName", NULL
15935 };
15936
15937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15939 if (!SWIG_IsOK(res1)) {
15940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15941 }
15942 arg1 = reinterpret_cast< wxSound * >(argp1);
15943 {
15944 arg2 = wxString_in_helper(obj1);
15945 if (arg2 == NULL) SWIG_fail;
15946 temp2 = true;
15947 }
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (bool)(arg1)->Create((wxString const &)*arg2);
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 {
15955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15956 }
15957 {
15958 if (temp2)
15959 delete arg2;
15960 }
15961 return resultobj;
15962 fail:
15963 {
15964 if (temp2)
15965 delete arg2;
15966 }
15967 return NULL;
15968 }
15969
15970
15971 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15972 PyObject *resultobj = 0;
15973 wxSound *arg1 = (wxSound *) 0 ;
15974 PyObject *arg2 = (PyObject *) 0 ;
15975 bool result;
15976 void *argp1 = 0 ;
15977 int res1 = 0 ;
15978 PyObject * obj0 = 0 ;
15979 PyObject * obj1 = 0 ;
15980 char * kwnames[] = {
15981 (char *) "self",(char *) "data", NULL
15982 };
15983
15984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15986 if (!SWIG_IsOK(res1)) {
15987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15988 }
15989 arg1 = reinterpret_cast< wxSound * >(argp1);
15990 arg2 = obj1;
15991 {
15992 PyThreadState* __tstate = wxPyBeginAllowThreads();
15993 result = (bool)wxSound_CreateFromData(arg1,arg2);
15994 wxPyEndAllowThreads(__tstate);
15995 if (PyErr_Occurred()) SWIG_fail;
15996 }
15997 {
15998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15999 }
16000 return resultobj;
16001 fail:
16002 return NULL;
16003 }
16004
16005
16006 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16007 PyObject *resultobj = 0;
16008 wxSound *arg1 = (wxSound *) 0 ;
16009 bool result;
16010 void *argp1 = 0 ;
16011 int res1 = 0 ;
16012 PyObject *swig_obj[1] ;
16013
16014 if (!args) SWIG_fail;
16015 swig_obj[0] = args;
16016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16017 if (!SWIG_IsOK(res1)) {
16018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16019 }
16020 arg1 = reinterpret_cast< wxSound * >(argp1);
16021 {
16022 PyThreadState* __tstate = wxPyBeginAllowThreads();
16023 result = (bool)(arg1)->IsOk();
16024 wxPyEndAllowThreads(__tstate);
16025 if (PyErr_Occurred()) SWIG_fail;
16026 }
16027 {
16028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16029 }
16030 return resultobj;
16031 fail:
16032 return NULL;
16033 }
16034
16035
16036 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16037 PyObject *resultobj = 0;
16038 wxSound *arg1 = (wxSound *) 0 ;
16039 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16040 bool result;
16041 void *argp1 = 0 ;
16042 int res1 = 0 ;
16043 unsigned int val2 ;
16044 int ecode2 = 0 ;
16045 PyObject * obj0 = 0 ;
16046 PyObject * obj1 = 0 ;
16047 char * kwnames[] = {
16048 (char *) "self",(char *) "flags", NULL
16049 };
16050
16051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16053 if (!SWIG_IsOK(res1)) {
16054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16055 }
16056 arg1 = reinterpret_cast< wxSound * >(argp1);
16057 if (obj1) {
16058 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16059 if (!SWIG_IsOK(ecode2)) {
16060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16061 }
16062 arg2 = static_cast< unsigned int >(val2);
16063 }
16064 {
16065 if (!wxPyCheckForApp()) SWIG_fail;
16066 PyThreadState* __tstate = wxPyBeginAllowThreads();
16067 result = (bool)((wxSound const *)arg1)->Play(arg2);
16068 wxPyEndAllowThreads(__tstate);
16069 if (PyErr_Occurred()) SWIG_fail;
16070 }
16071 {
16072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16073 }
16074 return resultobj;
16075 fail:
16076 return NULL;
16077 }
16078
16079
16080 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16081 PyObject *resultobj = 0;
16082 wxString *arg1 = 0 ;
16083 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16084 bool result;
16085 bool temp1 = false ;
16086 unsigned int val2 ;
16087 int ecode2 = 0 ;
16088 PyObject * obj0 = 0 ;
16089 PyObject * obj1 = 0 ;
16090 char * kwnames[] = {
16091 (char *) "filename",(char *) "flags", NULL
16092 };
16093
16094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16095 {
16096 arg1 = wxString_in_helper(obj0);
16097 if (arg1 == NULL) SWIG_fail;
16098 temp1 = true;
16099 }
16100 if (obj1) {
16101 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16102 if (!SWIG_IsOK(ecode2)) {
16103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16104 }
16105 arg2 = static_cast< unsigned int >(val2);
16106 }
16107 {
16108 if (!wxPyCheckForApp()) SWIG_fail;
16109 PyThreadState* __tstate = wxPyBeginAllowThreads();
16110 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 {
16115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16116 }
16117 {
16118 if (temp1)
16119 delete arg1;
16120 }
16121 return resultobj;
16122 fail:
16123 {
16124 if (temp1)
16125 delete arg1;
16126 }
16127 return NULL;
16128 }
16129
16130
16131 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16132 PyObject *resultobj = 0;
16133
16134 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16135 {
16136 if (!wxPyCheckForApp()) SWIG_fail;
16137 PyThreadState* __tstate = wxPyBeginAllowThreads();
16138 wxSound::Stop();
16139 wxPyEndAllowThreads(__tstate);
16140 if (PyErr_Occurred()) SWIG_fail;
16141 }
16142 resultobj = SWIG_Py_Void();
16143 return resultobj;
16144 fail:
16145 return NULL;
16146 }
16147
16148
16149 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16150 PyObject *obj;
16151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16152 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16153 return SWIG_Py_Void();
16154 }
16155
16156 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16157 return SWIG_Python_InitShadowInstance(args);
16158 }
16159
16160 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj = 0;
16162 wxString *arg1 = 0 ;
16163 wxString *arg2 = 0 ;
16164 wxString *arg3 = 0 ;
16165 wxString *arg4 = 0 ;
16166 wxFileTypeInfo *result = 0 ;
16167 bool temp1 = false ;
16168 bool temp2 = false ;
16169 bool temp3 = false ;
16170 bool temp4 = false ;
16171 PyObject * obj0 = 0 ;
16172 PyObject * obj1 = 0 ;
16173 PyObject * obj2 = 0 ;
16174 PyObject * obj3 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16180 {
16181 arg1 = wxString_in_helper(obj0);
16182 if (arg1 == NULL) SWIG_fail;
16183 temp1 = true;
16184 }
16185 {
16186 arg2 = wxString_in_helper(obj1);
16187 if (arg2 == NULL) SWIG_fail;
16188 temp2 = true;
16189 }
16190 {
16191 arg3 = wxString_in_helper(obj2);
16192 if (arg3 == NULL) SWIG_fail;
16193 temp3 = true;
16194 }
16195 {
16196 arg4 = wxString_in_helper(obj3);
16197 if (arg4 == NULL) SWIG_fail;
16198 temp4 = true;
16199 }
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16207 {
16208 if (temp1)
16209 delete arg1;
16210 }
16211 {
16212 if (temp2)
16213 delete arg2;
16214 }
16215 {
16216 if (temp3)
16217 delete arg3;
16218 }
16219 {
16220 if (temp4)
16221 delete arg4;
16222 }
16223 return resultobj;
16224 fail:
16225 {
16226 if (temp1)
16227 delete arg1;
16228 }
16229 {
16230 if (temp2)
16231 delete arg2;
16232 }
16233 {
16234 if (temp3)
16235 delete arg3;
16236 }
16237 {
16238 if (temp4)
16239 delete arg4;
16240 }
16241 return NULL;
16242 }
16243
16244
16245 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16246 PyObject *resultobj = 0;
16247 wxArrayString *arg1 = 0 ;
16248 wxFileTypeInfo *result = 0 ;
16249 bool temp1 = false ;
16250 PyObject * obj0 = 0 ;
16251 char * kwnames[] = {
16252 (char *) "sArray", NULL
16253 };
16254
16255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16256 {
16257 if (! PySequence_Check(obj0)) {
16258 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16259 SWIG_fail;
16260 }
16261 arg1 = new wxArrayString;
16262 temp1 = true;
16263 int i, len=PySequence_Length(obj0);
16264 for (i=0; i<len; i++) {
16265 PyObject* item = PySequence_GetItem(obj0, i);
16266 wxString* s = wxString_in_helper(item);
16267 if (PyErr_Occurred()) SWIG_fail;
16268 arg1->Add(*s);
16269 delete s;
16270 Py_DECREF(item);
16271 }
16272 }
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16280 {
16281 if (temp1) delete arg1;
16282 }
16283 return resultobj;
16284 fail:
16285 {
16286 if (temp1) delete arg1;
16287 }
16288 return NULL;
16289 }
16290
16291
16292 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16293 PyObject *resultobj = 0;
16294 wxFileTypeInfo *result = 0 ;
16295
16296 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16297 {
16298 PyThreadState* __tstate = wxPyBeginAllowThreads();
16299 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16300 wxPyEndAllowThreads(__tstate);
16301 if (PyErr_Occurred()) SWIG_fail;
16302 }
16303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16304 return resultobj;
16305 fail:
16306 return NULL;
16307 }
16308
16309
16310 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16311 PyObject *resultobj = 0;
16312 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16313 bool result;
16314 void *argp1 = 0 ;
16315 int res1 = 0 ;
16316 PyObject *swig_obj[1] ;
16317
16318 if (!args) SWIG_fail;
16319 swig_obj[0] = args;
16320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16321 if (!SWIG_IsOK(res1)) {
16322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16323 }
16324 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16325 {
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16328 wxPyEndAllowThreads(__tstate);
16329 if (PyErr_Occurred()) SWIG_fail;
16330 }
16331 {
16332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16333 }
16334 return resultobj;
16335 fail:
16336 return NULL;
16337 }
16338
16339
16340 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16341 PyObject *resultobj = 0;
16342 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16343 wxString *arg2 = 0 ;
16344 int arg3 = (int) 0 ;
16345 void *argp1 = 0 ;
16346 int res1 = 0 ;
16347 bool temp2 = false ;
16348 int val3 ;
16349 int ecode3 = 0 ;
16350 PyObject * obj0 = 0 ;
16351 PyObject * obj1 = 0 ;
16352 PyObject * obj2 = 0 ;
16353 char * kwnames[] = {
16354 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16355 };
16356
16357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16359 if (!SWIG_IsOK(res1)) {
16360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16361 }
16362 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16363 {
16364 arg2 = wxString_in_helper(obj1);
16365 if (arg2 == NULL) SWIG_fail;
16366 temp2 = true;
16367 }
16368 if (obj2) {
16369 ecode3 = SWIG_AsVal_int(obj2, &val3);
16370 if (!SWIG_IsOK(ecode3)) {
16371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16372 }
16373 arg3 = static_cast< int >(val3);
16374 }
16375 {
16376 PyThreadState* __tstate = wxPyBeginAllowThreads();
16377 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16378 wxPyEndAllowThreads(__tstate);
16379 if (PyErr_Occurred()) SWIG_fail;
16380 }
16381 resultobj = SWIG_Py_Void();
16382 {
16383 if (temp2)
16384 delete arg2;
16385 }
16386 return resultobj;
16387 fail:
16388 {
16389 if (temp2)
16390 delete arg2;
16391 }
16392 return NULL;
16393 }
16394
16395
16396 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16397 PyObject *resultobj = 0;
16398 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16399 wxString *arg2 = 0 ;
16400 void *argp1 = 0 ;
16401 int res1 = 0 ;
16402 bool temp2 = false ;
16403 PyObject * obj0 = 0 ;
16404 PyObject * obj1 = 0 ;
16405 char * kwnames[] = {
16406 (char *) "self",(char *) "shortDesc", NULL
16407 };
16408
16409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16411 if (!SWIG_IsOK(res1)) {
16412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16413 }
16414 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16415 {
16416 arg2 = wxString_in_helper(obj1);
16417 if (arg2 == NULL) SWIG_fail;
16418 temp2 = true;
16419 }
16420 {
16421 PyThreadState* __tstate = wxPyBeginAllowThreads();
16422 (arg1)->SetShortDesc((wxString const &)*arg2);
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 resultobj = SWIG_Py_Void();
16427 {
16428 if (temp2)
16429 delete arg2;
16430 }
16431 return resultobj;
16432 fail:
16433 {
16434 if (temp2)
16435 delete arg2;
16436 }
16437 return NULL;
16438 }
16439
16440
16441 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16442 PyObject *resultobj = 0;
16443 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16444 wxString *result = 0 ;
16445 void *argp1 = 0 ;
16446 int res1 = 0 ;
16447 PyObject *swig_obj[1] ;
16448
16449 if (!args) SWIG_fail;
16450 swig_obj[0] = args;
16451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16452 if (!SWIG_IsOK(res1)) {
16453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16454 }
16455 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16456 {
16457 PyThreadState* __tstate = wxPyBeginAllowThreads();
16458 {
16459 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16460 result = (wxString *) &_result_ref;
16461 }
16462 wxPyEndAllowThreads(__tstate);
16463 if (PyErr_Occurred()) SWIG_fail;
16464 }
16465 {
16466 #if wxUSE_UNICODE
16467 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16468 #else
16469 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16470 #endif
16471 }
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16479 PyObject *resultobj = 0;
16480 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16481 wxString *result = 0 ;
16482 void *argp1 = 0 ;
16483 int res1 = 0 ;
16484 PyObject *swig_obj[1] ;
16485
16486 if (!args) SWIG_fail;
16487 swig_obj[0] = args;
16488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16489 if (!SWIG_IsOK(res1)) {
16490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16491 }
16492 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 {
16496 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16497 result = (wxString *) &_result_ref;
16498 }
16499 wxPyEndAllowThreads(__tstate);
16500 if (PyErr_Occurred()) SWIG_fail;
16501 }
16502 {
16503 #if wxUSE_UNICODE
16504 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16505 #else
16506 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16507 #endif
16508 }
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16516 PyObject *resultobj = 0;
16517 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16518 wxString *result = 0 ;
16519 void *argp1 = 0 ;
16520 int res1 = 0 ;
16521 PyObject *swig_obj[1] ;
16522
16523 if (!args) SWIG_fail;
16524 swig_obj[0] = args;
16525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16526 if (!SWIG_IsOK(res1)) {
16527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16528 }
16529 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 {
16533 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16534 result = (wxString *) &_result_ref;
16535 }
16536 wxPyEndAllowThreads(__tstate);
16537 if (PyErr_Occurred()) SWIG_fail;
16538 }
16539 {
16540 #if wxUSE_UNICODE
16541 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16542 #else
16543 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16544 #endif
16545 }
16546 return resultobj;
16547 fail:
16548 return NULL;
16549 }
16550
16551
16552 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16553 PyObject *resultobj = 0;
16554 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16555 wxString *result = 0 ;
16556 void *argp1 = 0 ;
16557 int res1 = 0 ;
16558 PyObject *swig_obj[1] ;
16559
16560 if (!args) SWIG_fail;
16561 swig_obj[0] = args;
16562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16563 if (!SWIG_IsOK(res1)) {
16564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16565 }
16566 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 {
16570 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16571 result = (wxString *) &_result_ref;
16572 }
16573 wxPyEndAllowThreads(__tstate);
16574 if (PyErr_Occurred()) SWIG_fail;
16575 }
16576 {
16577 #if wxUSE_UNICODE
16578 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16579 #else
16580 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16581 #endif
16582 }
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16590 PyObject *resultobj = 0;
16591 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16592 wxString *result = 0 ;
16593 void *argp1 = 0 ;
16594 int res1 = 0 ;
16595 PyObject *swig_obj[1] ;
16596
16597 if (!args) SWIG_fail;
16598 swig_obj[0] = args;
16599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16600 if (!SWIG_IsOK(res1)) {
16601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16602 }
16603 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16604 {
16605 PyThreadState* __tstate = wxPyBeginAllowThreads();
16606 {
16607 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16608 result = (wxString *) &_result_ref;
16609 }
16610 wxPyEndAllowThreads(__tstate);
16611 if (PyErr_Occurred()) SWIG_fail;
16612 }
16613 {
16614 #if wxUSE_UNICODE
16615 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16616 #else
16617 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16618 #endif
16619 }
16620 return resultobj;
16621 fail:
16622 return NULL;
16623 }
16624
16625
16626 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16627 PyObject *resultobj = 0;
16628 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16629 wxArrayString *result = 0 ;
16630 void *argp1 = 0 ;
16631 int res1 = 0 ;
16632 PyObject *swig_obj[1] ;
16633
16634 if (!args) SWIG_fail;
16635 swig_obj[0] = args;
16636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16637 if (!SWIG_IsOK(res1)) {
16638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16639 }
16640 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16641 {
16642 PyThreadState* __tstate = wxPyBeginAllowThreads();
16643 {
16644 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16645 result = (wxArrayString *) &_result_ref;
16646 }
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 {
16651 resultobj = wxArrayString2PyList_helper(*result);
16652 }
16653 return resultobj;
16654 fail:
16655 return NULL;
16656 }
16657
16658
16659 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16660 PyObject *resultobj = 0;
16661 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16662 size_t result;
16663 void *argp1 = 0 ;
16664 int res1 = 0 ;
16665 PyObject *swig_obj[1] ;
16666
16667 if (!args) SWIG_fail;
16668 swig_obj[0] = args;
16669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16670 if (!SWIG_IsOK(res1)) {
16671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16672 }
16673 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16688 PyObject *resultobj = 0;
16689 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16690 wxString *result = 0 ;
16691 void *argp1 = 0 ;
16692 int res1 = 0 ;
16693 PyObject *swig_obj[1] ;
16694
16695 if (!args) SWIG_fail;
16696 swig_obj[0] = args;
16697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16698 if (!SWIG_IsOK(res1)) {
16699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16700 }
16701 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16702 {
16703 PyThreadState* __tstate = wxPyBeginAllowThreads();
16704 {
16705 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16706 result = (wxString *) &_result_ref;
16707 }
16708 wxPyEndAllowThreads(__tstate);
16709 if (PyErr_Occurred()) SWIG_fail;
16710 }
16711 {
16712 #if wxUSE_UNICODE
16713 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16714 #else
16715 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16716 #endif
16717 }
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16725 PyObject *resultobj = 0;
16726 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16727 int result;
16728 void *argp1 = 0 ;
16729 int res1 = 0 ;
16730 PyObject *swig_obj[1] ;
16731
16732 if (!args) SWIG_fail;
16733 swig_obj[0] = args;
16734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16735 if (!SWIG_IsOK(res1)) {
16736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16737 }
16738 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 resultobj = SWIG_From_int(static_cast< int >(result));
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16753 PyObject *obj;
16754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16755 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16756 return SWIG_Py_Void();
16757 }
16758
16759 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16760 return SWIG_Python_InitShadowInstance(args);
16761 }
16762
16763 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16764 PyObject *resultobj = 0;
16765 wxFileTypeInfo *arg1 = 0 ;
16766 wxFileType *result = 0 ;
16767 void *argp1 = 0 ;
16768 int res1 = 0 ;
16769 PyObject * obj0 = 0 ;
16770 char * kwnames[] = {
16771 (char *) "ftInfo", NULL
16772 };
16773
16774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16775 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16776 if (!SWIG_IsOK(res1)) {
16777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16778 }
16779 if (!argp1) {
16780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16781 }
16782 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16786 wxPyEndAllowThreads(__tstate);
16787 if (PyErr_Occurred()) SWIG_fail;
16788 }
16789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16797 PyObject *resultobj = 0;
16798 wxFileType *arg1 = (wxFileType *) 0 ;
16799 void *argp1 = 0 ;
16800 int res1 = 0 ;
16801 PyObject *swig_obj[1] ;
16802
16803 if (!args) SWIG_fail;
16804 swig_obj[0] = args;
16805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16806 if (!SWIG_IsOK(res1)) {
16807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16808 }
16809 arg1 = reinterpret_cast< wxFileType * >(argp1);
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 delete arg1;
16813
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 resultobj = SWIG_Py_Void();
16818 return resultobj;
16819 fail:
16820 return NULL;
16821 }
16822
16823
16824 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16825 PyObject *resultobj = 0;
16826 wxFileType *arg1 = (wxFileType *) 0 ;
16827 PyObject *result = 0 ;
16828 void *argp1 = 0 ;
16829 int res1 = 0 ;
16830 PyObject *swig_obj[1] ;
16831
16832 if (!args) SWIG_fail;
16833 swig_obj[0] = args;
16834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16835 if (!SWIG_IsOK(res1)) {
16836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16837 }
16838 arg1 = reinterpret_cast< wxFileType * >(argp1);
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 result = (PyObject *)wxFileType_GetMimeType(arg1);
16842 wxPyEndAllowThreads(__tstate);
16843 if (PyErr_Occurred()) SWIG_fail;
16844 }
16845 resultobj = result;
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16853 PyObject *resultobj = 0;
16854 wxFileType *arg1 = (wxFileType *) 0 ;
16855 PyObject *result = 0 ;
16856 void *argp1 = 0 ;
16857 int res1 = 0 ;
16858 PyObject *swig_obj[1] ;
16859
16860 if (!args) SWIG_fail;
16861 swig_obj[0] = args;
16862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16863 if (!SWIG_IsOK(res1)) {
16864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16865 }
16866 arg1 = reinterpret_cast< wxFileType * >(argp1);
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 resultobj = result;
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16881 PyObject *resultobj = 0;
16882 wxFileType *arg1 = (wxFileType *) 0 ;
16883 PyObject *result = 0 ;
16884 void *argp1 = 0 ;
16885 int res1 = 0 ;
16886 PyObject *swig_obj[1] ;
16887
16888 if (!args) SWIG_fail;
16889 swig_obj[0] = args;
16890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16893 }
16894 arg1 = reinterpret_cast< wxFileType * >(argp1);
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 result = (PyObject *)wxFileType_GetExtensions(arg1);
16898 wxPyEndAllowThreads(__tstate);
16899 if (PyErr_Occurred()) SWIG_fail;
16900 }
16901 resultobj = result;
16902 return resultobj;
16903 fail:
16904 return NULL;
16905 }
16906
16907
16908 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16909 PyObject *resultobj = 0;
16910 wxFileType *arg1 = (wxFileType *) 0 ;
16911 wxIcon *result = 0 ;
16912 void *argp1 = 0 ;
16913 int res1 = 0 ;
16914 PyObject *swig_obj[1] ;
16915
16916 if (!args) SWIG_fail;
16917 swig_obj[0] = args;
16918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16919 if (!SWIG_IsOK(res1)) {
16920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16921 }
16922 arg1 = reinterpret_cast< wxFileType * >(argp1);
16923 {
16924 PyThreadState* __tstate = wxPyBeginAllowThreads();
16925 result = (wxIcon *)wxFileType_GetIcon(arg1);
16926 wxPyEndAllowThreads(__tstate);
16927 if (PyErr_Occurred()) SWIG_fail;
16928 }
16929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16930 return resultobj;
16931 fail:
16932 return NULL;
16933 }
16934
16935
16936 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16937 PyObject *resultobj = 0;
16938 wxFileType *arg1 = (wxFileType *) 0 ;
16939 PyObject *result = 0 ;
16940 void *argp1 = 0 ;
16941 int res1 = 0 ;
16942 PyObject *swig_obj[1] ;
16943
16944 if (!args) SWIG_fail;
16945 swig_obj[0] = args;
16946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16947 if (!SWIG_IsOK(res1)) {
16948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16949 }
16950 arg1 = reinterpret_cast< wxFileType * >(argp1);
16951 {
16952 PyThreadState* __tstate = wxPyBeginAllowThreads();
16953 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16954 wxPyEndAllowThreads(__tstate);
16955 if (PyErr_Occurred()) SWIG_fail;
16956 }
16957 resultobj = result;
16958 return resultobj;
16959 fail:
16960 return NULL;
16961 }
16962
16963
16964 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16965 PyObject *resultobj = 0;
16966 wxFileType *arg1 = (wxFileType *) 0 ;
16967 PyObject *result = 0 ;
16968 void *argp1 = 0 ;
16969 int res1 = 0 ;
16970 PyObject *swig_obj[1] ;
16971
16972 if (!args) SWIG_fail;
16973 swig_obj[0] = args;
16974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16975 if (!SWIG_IsOK(res1)) {
16976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16977 }
16978 arg1 = reinterpret_cast< wxFileType * >(argp1);
16979 {
16980 PyThreadState* __tstate = wxPyBeginAllowThreads();
16981 result = (PyObject *)wxFileType_GetDescription(arg1);
16982 wxPyEndAllowThreads(__tstate);
16983 if (PyErr_Occurred()) SWIG_fail;
16984 }
16985 resultobj = result;
16986 return resultobj;
16987 fail:
16988 return NULL;
16989 }
16990
16991
16992 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16993 PyObject *resultobj = 0;
16994 wxFileType *arg1 = (wxFileType *) 0 ;
16995 wxString *arg2 = 0 ;
16996 wxString const &arg3_defvalue = wxPyEmptyString ;
16997 wxString *arg3 = (wxString *) &arg3_defvalue ;
16998 PyObject *result = 0 ;
16999 void *argp1 = 0 ;
17000 int res1 = 0 ;
17001 bool temp2 = false ;
17002 bool temp3 = false ;
17003 PyObject * obj0 = 0 ;
17004 PyObject * obj1 = 0 ;
17005 PyObject * obj2 = 0 ;
17006 char * kwnames[] = {
17007 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17008 };
17009
17010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17012 if (!SWIG_IsOK(res1)) {
17013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17014 }
17015 arg1 = reinterpret_cast< wxFileType * >(argp1);
17016 {
17017 arg2 = wxString_in_helper(obj1);
17018 if (arg2 == NULL) SWIG_fail;
17019 temp2 = true;
17020 }
17021 if (obj2) {
17022 {
17023 arg3 = wxString_in_helper(obj2);
17024 if (arg3 == NULL) SWIG_fail;
17025 temp3 = true;
17026 }
17027 }
17028 {
17029 PyThreadState* __tstate = wxPyBeginAllowThreads();
17030 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17031 wxPyEndAllowThreads(__tstate);
17032 if (PyErr_Occurred()) SWIG_fail;
17033 }
17034 resultobj = result;
17035 {
17036 if (temp2)
17037 delete arg2;
17038 }
17039 {
17040 if (temp3)
17041 delete arg3;
17042 }
17043 return resultobj;
17044 fail:
17045 {
17046 if (temp2)
17047 delete arg2;
17048 }
17049 {
17050 if (temp3)
17051 delete arg3;
17052 }
17053 return NULL;
17054 }
17055
17056
17057 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj = 0;
17059 wxFileType *arg1 = (wxFileType *) 0 ;
17060 wxString *arg2 = 0 ;
17061 wxString const &arg3_defvalue = wxPyEmptyString ;
17062 wxString *arg3 = (wxString *) &arg3_defvalue ;
17063 PyObject *result = 0 ;
17064 void *argp1 = 0 ;
17065 int res1 = 0 ;
17066 bool temp2 = false ;
17067 bool temp3 = false ;
17068 PyObject * obj0 = 0 ;
17069 PyObject * obj1 = 0 ;
17070 PyObject * obj2 = 0 ;
17071 char * kwnames[] = {
17072 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17073 };
17074
17075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17077 if (!SWIG_IsOK(res1)) {
17078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17079 }
17080 arg1 = reinterpret_cast< wxFileType * >(argp1);
17081 {
17082 arg2 = wxString_in_helper(obj1);
17083 if (arg2 == NULL) SWIG_fail;
17084 temp2 = true;
17085 }
17086 if (obj2) {
17087 {
17088 arg3 = wxString_in_helper(obj2);
17089 if (arg3 == NULL) SWIG_fail;
17090 temp3 = true;
17091 }
17092 }
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 resultobj = result;
17100 {
17101 if (temp2)
17102 delete arg2;
17103 }
17104 {
17105 if (temp3)
17106 delete arg3;
17107 }
17108 return resultobj;
17109 fail:
17110 {
17111 if (temp2)
17112 delete arg2;
17113 }
17114 {
17115 if (temp3)
17116 delete arg3;
17117 }
17118 return NULL;
17119 }
17120
17121
17122 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17123 PyObject *resultobj = 0;
17124 wxFileType *arg1 = (wxFileType *) 0 ;
17125 wxString *arg2 = 0 ;
17126 wxString const &arg3_defvalue = wxPyEmptyString ;
17127 wxString *arg3 = (wxString *) &arg3_defvalue ;
17128 PyObject *result = 0 ;
17129 void *argp1 = 0 ;
17130 int res1 = 0 ;
17131 bool temp2 = false ;
17132 bool temp3 = false ;
17133 PyObject * obj0 = 0 ;
17134 PyObject * obj1 = 0 ;
17135 PyObject * obj2 = 0 ;
17136 char * kwnames[] = {
17137 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17138 };
17139
17140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17142 if (!SWIG_IsOK(res1)) {
17143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17144 }
17145 arg1 = reinterpret_cast< wxFileType * >(argp1);
17146 {
17147 arg2 = wxString_in_helper(obj1);
17148 if (arg2 == NULL) SWIG_fail;
17149 temp2 = true;
17150 }
17151 if (obj2) {
17152 {
17153 arg3 = wxString_in_helper(obj2);
17154 if (arg3 == NULL) SWIG_fail;
17155 temp3 = true;
17156 }
17157 }
17158 {
17159 PyThreadState* __tstate = wxPyBeginAllowThreads();
17160 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17161 wxPyEndAllowThreads(__tstate);
17162 if (PyErr_Occurred()) SWIG_fail;
17163 }
17164 resultobj = result;
17165 {
17166 if (temp2)
17167 delete arg2;
17168 }
17169 {
17170 if (temp3)
17171 delete arg3;
17172 }
17173 return resultobj;
17174 fail:
17175 {
17176 if (temp2)
17177 delete arg2;
17178 }
17179 {
17180 if (temp3)
17181 delete arg3;
17182 }
17183 return NULL;
17184 }
17185
17186
17187 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17188 PyObject *resultobj = 0;
17189 wxFileType *arg1 = (wxFileType *) 0 ;
17190 wxString *arg2 = 0 ;
17191 wxString *arg3 = 0 ;
17192 bool arg4 = (bool) true ;
17193 bool result;
17194 void *argp1 = 0 ;
17195 int res1 = 0 ;
17196 bool temp2 = false ;
17197 bool temp3 = false ;
17198 bool val4 ;
17199 int ecode4 = 0 ;
17200 PyObject * obj0 = 0 ;
17201 PyObject * obj1 = 0 ;
17202 PyObject * obj2 = 0 ;
17203 PyObject * obj3 = 0 ;
17204 char * kwnames[] = {
17205 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17206 };
17207
17208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17210 if (!SWIG_IsOK(res1)) {
17211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17212 }
17213 arg1 = reinterpret_cast< wxFileType * >(argp1);
17214 {
17215 arg2 = wxString_in_helper(obj1);
17216 if (arg2 == NULL) SWIG_fail;
17217 temp2 = true;
17218 }
17219 {
17220 arg3 = wxString_in_helper(obj2);
17221 if (arg3 == NULL) SWIG_fail;
17222 temp3 = true;
17223 }
17224 if (obj3) {
17225 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17226 if (!SWIG_IsOK(ecode4)) {
17227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17228 }
17229 arg4 = static_cast< bool >(val4);
17230 }
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 {
17238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17239 }
17240 {
17241 if (temp2)
17242 delete arg2;
17243 }
17244 {
17245 if (temp3)
17246 delete arg3;
17247 }
17248 return resultobj;
17249 fail:
17250 {
17251 if (temp2)
17252 delete arg2;
17253 }
17254 {
17255 if (temp3)
17256 delete arg3;
17257 }
17258 return NULL;
17259 }
17260
17261
17262 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17263 PyObject *resultobj = 0;
17264 wxFileType *arg1 = (wxFileType *) 0 ;
17265 wxString const &arg2_defvalue = wxPyEmptyString ;
17266 wxString *arg2 = (wxString *) &arg2_defvalue ;
17267 int arg3 = (int) 0 ;
17268 bool result;
17269 void *argp1 = 0 ;
17270 int res1 = 0 ;
17271 bool temp2 = false ;
17272 int val3 ;
17273 int ecode3 = 0 ;
17274 PyObject * obj0 = 0 ;
17275 PyObject * obj1 = 0 ;
17276 PyObject * obj2 = 0 ;
17277 char * kwnames[] = {
17278 (char *) "self",(char *) "cmd",(char *) "index", NULL
17279 };
17280
17281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17283 if (!SWIG_IsOK(res1)) {
17284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17285 }
17286 arg1 = reinterpret_cast< wxFileType * >(argp1);
17287 if (obj1) {
17288 {
17289 arg2 = wxString_in_helper(obj1);
17290 if (arg2 == NULL) SWIG_fail;
17291 temp2 = true;
17292 }
17293 }
17294 if (obj2) {
17295 ecode3 = SWIG_AsVal_int(obj2, &val3);
17296 if (!SWIG_IsOK(ecode3)) {
17297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17298 }
17299 arg3 = static_cast< int >(val3);
17300 }
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17304 wxPyEndAllowThreads(__tstate);
17305 if (PyErr_Occurred()) SWIG_fail;
17306 }
17307 {
17308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17309 }
17310 {
17311 if (temp2)
17312 delete arg2;
17313 }
17314 return resultobj;
17315 fail:
17316 {
17317 if (temp2)
17318 delete arg2;
17319 }
17320 return NULL;
17321 }
17322
17323
17324 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17325 PyObject *resultobj = 0;
17326 wxFileType *arg1 = (wxFileType *) 0 ;
17327 bool result;
17328 void *argp1 = 0 ;
17329 int res1 = 0 ;
17330 PyObject *swig_obj[1] ;
17331
17332 if (!args) SWIG_fail;
17333 swig_obj[0] = args;
17334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17335 if (!SWIG_IsOK(res1)) {
17336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17337 }
17338 arg1 = reinterpret_cast< wxFileType * >(argp1);
17339 {
17340 PyThreadState* __tstate = wxPyBeginAllowThreads();
17341 result = (bool)(arg1)->Unassociate();
17342 wxPyEndAllowThreads(__tstate);
17343 if (PyErr_Occurred()) SWIG_fail;
17344 }
17345 {
17346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17347 }
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17355 PyObject *resultobj = 0;
17356 wxString *arg1 = 0 ;
17357 wxString *arg2 = 0 ;
17358 wxString const &arg3_defvalue = wxPyEmptyString ;
17359 wxString *arg3 = (wxString *) &arg3_defvalue ;
17360 wxString result;
17361 bool temp1 = false ;
17362 bool temp2 = false ;
17363 bool temp3 = false ;
17364 PyObject * obj0 = 0 ;
17365 PyObject * obj1 = 0 ;
17366 PyObject * obj2 = 0 ;
17367 char * kwnames[] = {
17368 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17369 };
17370
17371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17372 {
17373 arg1 = wxString_in_helper(obj0);
17374 if (arg1 == NULL) SWIG_fail;
17375 temp1 = true;
17376 }
17377 {
17378 arg2 = wxString_in_helper(obj1);
17379 if (arg2 == NULL) SWIG_fail;
17380 temp2 = true;
17381 }
17382 if (obj2) {
17383 {
17384 arg3 = wxString_in_helper(obj2);
17385 if (arg3 == NULL) SWIG_fail;
17386 temp3 = true;
17387 }
17388 }
17389 {
17390 PyThreadState* __tstate = wxPyBeginAllowThreads();
17391 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17392 wxPyEndAllowThreads(__tstate);
17393 if (PyErr_Occurred()) SWIG_fail;
17394 }
17395 {
17396 #if wxUSE_UNICODE
17397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17398 #else
17399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17400 #endif
17401 }
17402 {
17403 if (temp1)
17404 delete arg1;
17405 }
17406 {
17407 if (temp2)
17408 delete arg2;
17409 }
17410 {
17411 if (temp3)
17412 delete arg3;
17413 }
17414 return resultobj;
17415 fail:
17416 {
17417 if (temp1)
17418 delete arg1;
17419 }
17420 {
17421 if (temp2)
17422 delete arg2;
17423 }
17424 {
17425 if (temp3)
17426 delete arg3;
17427 }
17428 return NULL;
17429 }
17430
17431
17432 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17433 PyObject *obj;
17434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17435 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17436 return SWIG_Py_Void();
17437 }
17438
17439 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 return SWIG_Python_InitShadowInstance(args);
17441 }
17442
17443 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17444 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17445 return 1;
17446 }
17447
17448
17449 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17450 PyObject *pyobj = 0;
17451
17452 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17453 return pyobj;
17454 }
17455
17456
17457 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj = 0;
17459 wxString *arg1 = 0 ;
17460 wxString *arg2 = 0 ;
17461 bool result;
17462 bool temp1 = false ;
17463 bool temp2 = false ;
17464 PyObject * obj0 = 0 ;
17465 PyObject * obj1 = 0 ;
17466 char * kwnames[] = {
17467 (char *) "mimeType",(char *) "wildcard", NULL
17468 };
17469
17470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17471 {
17472 arg1 = wxString_in_helper(obj0);
17473 if (arg1 == NULL) SWIG_fail;
17474 temp1 = true;
17475 }
17476 {
17477 arg2 = wxString_in_helper(obj1);
17478 if (arg2 == NULL) SWIG_fail;
17479 temp2 = true;
17480 }
17481 {
17482 PyThreadState* __tstate = wxPyBeginAllowThreads();
17483 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 {
17488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17489 }
17490 {
17491 if (temp1)
17492 delete arg1;
17493 }
17494 {
17495 if (temp2)
17496 delete arg2;
17497 }
17498 return resultobj;
17499 fail:
17500 {
17501 if (temp1)
17502 delete arg1;
17503 }
17504 {
17505 if (temp2)
17506 delete arg2;
17507 }
17508 return NULL;
17509 }
17510
17511
17512 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17513 PyObject *resultobj = 0;
17514 wxMimeTypesManager *result = 0 ;
17515
17516 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17517 {
17518 PyThreadState* __tstate = wxPyBeginAllowThreads();
17519 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17520 wxPyEndAllowThreads(__tstate);
17521 if (PyErr_Occurred()) SWIG_fail;
17522 }
17523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17524 return resultobj;
17525 fail:
17526 return NULL;
17527 }
17528
17529
17530 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17531 PyObject *resultobj = 0;
17532 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17533 int arg2 = (int) wxMAILCAP_ALL ;
17534 wxString const &arg3_defvalue = wxPyEmptyString ;
17535 wxString *arg3 = (wxString *) &arg3_defvalue ;
17536 void *argp1 = 0 ;
17537 int res1 = 0 ;
17538 int val2 ;
17539 int ecode2 = 0 ;
17540 bool temp3 = false ;
17541 PyObject * obj0 = 0 ;
17542 PyObject * obj1 = 0 ;
17543 PyObject * obj2 = 0 ;
17544 char * kwnames[] = {
17545 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17546 };
17547
17548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17550 if (!SWIG_IsOK(res1)) {
17551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17552 }
17553 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17554 if (obj1) {
17555 ecode2 = SWIG_AsVal_int(obj1, &val2);
17556 if (!SWIG_IsOK(ecode2)) {
17557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17558 }
17559 arg2 = static_cast< int >(val2);
17560 }
17561 if (obj2) {
17562 {
17563 arg3 = wxString_in_helper(obj2);
17564 if (arg3 == NULL) SWIG_fail;
17565 temp3 = true;
17566 }
17567 }
17568 {
17569 PyThreadState* __tstate = wxPyBeginAllowThreads();
17570 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17571 wxPyEndAllowThreads(__tstate);
17572 if (PyErr_Occurred()) SWIG_fail;
17573 }
17574 resultobj = SWIG_Py_Void();
17575 {
17576 if (temp3)
17577 delete arg3;
17578 }
17579 return resultobj;
17580 fail:
17581 {
17582 if (temp3)
17583 delete arg3;
17584 }
17585 return NULL;
17586 }
17587
17588
17589 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17590 PyObject *resultobj = 0;
17591 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17592 void *argp1 = 0 ;
17593 int res1 = 0 ;
17594 PyObject *swig_obj[1] ;
17595
17596 if (!args) SWIG_fail;
17597 swig_obj[0] = args;
17598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17599 if (!SWIG_IsOK(res1)) {
17600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17601 }
17602 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 (arg1)->ClearData();
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 resultobj = SWIG_Py_Void();
17610 return resultobj;
17611 fail:
17612 return NULL;
17613 }
17614
17615
17616 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17617 PyObject *resultobj = 0;
17618 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17619 wxString *arg2 = 0 ;
17620 wxFileType *result = 0 ;
17621 void *argp1 = 0 ;
17622 int res1 = 0 ;
17623 bool temp2 = false ;
17624 PyObject * obj0 = 0 ;
17625 PyObject * obj1 = 0 ;
17626 char * kwnames[] = {
17627 (char *) "self",(char *) "ext", NULL
17628 };
17629
17630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17632 if (!SWIG_IsOK(res1)) {
17633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17634 }
17635 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17636 {
17637 arg2 = wxString_in_helper(obj1);
17638 if (arg2 == NULL) SWIG_fail;
17639 temp2 = true;
17640 }
17641 {
17642 PyThreadState* __tstate = wxPyBeginAllowThreads();
17643 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17644 wxPyEndAllowThreads(__tstate);
17645 if (PyErr_Occurred()) SWIG_fail;
17646 }
17647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17648 {
17649 if (temp2)
17650 delete arg2;
17651 }
17652 return resultobj;
17653 fail:
17654 {
17655 if (temp2)
17656 delete arg2;
17657 }
17658 return NULL;
17659 }
17660
17661
17662 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17663 PyObject *resultobj = 0;
17664 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17665 wxString *arg2 = 0 ;
17666 wxFileType *result = 0 ;
17667 void *argp1 = 0 ;
17668 int res1 = 0 ;
17669 bool temp2 = false ;
17670 PyObject * obj0 = 0 ;
17671 PyObject * obj1 = 0 ;
17672 char * kwnames[] = {
17673 (char *) "self",(char *) "mimeType", NULL
17674 };
17675
17676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17678 if (!SWIG_IsOK(res1)) {
17679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17680 }
17681 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17682 {
17683 arg2 = wxString_in_helper(obj1);
17684 if (arg2 == NULL) SWIG_fail;
17685 temp2 = true;
17686 }
17687 {
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17690 wxPyEndAllowThreads(__tstate);
17691 if (PyErr_Occurred()) SWIG_fail;
17692 }
17693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17694 {
17695 if (temp2)
17696 delete arg2;
17697 }
17698 return resultobj;
17699 fail:
17700 {
17701 if (temp2)
17702 delete arg2;
17703 }
17704 return NULL;
17705 }
17706
17707
17708 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17709 PyObject *resultobj = 0;
17710 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17711 wxString *arg2 = 0 ;
17712 bool arg3 = (bool) false ;
17713 bool result;
17714 void *argp1 = 0 ;
17715 int res1 = 0 ;
17716 bool temp2 = false ;
17717 bool val3 ;
17718 int ecode3 = 0 ;
17719 PyObject * obj0 = 0 ;
17720 PyObject * obj1 = 0 ;
17721 PyObject * obj2 = 0 ;
17722 char * kwnames[] = {
17723 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17724 };
17725
17726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17728 if (!SWIG_IsOK(res1)) {
17729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17730 }
17731 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17732 {
17733 arg2 = wxString_in_helper(obj1);
17734 if (arg2 == NULL) SWIG_fail;
17735 temp2 = true;
17736 }
17737 if (obj2) {
17738 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17739 if (!SWIG_IsOK(ecode3)) {
17740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17741 }
17742 arg3 = static_cast< bool >(val3);
17743 }
17744 {
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 {
17751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17752 }
17753 {
17754 if (temp2)
17755 delete arg2;
17756 }
17757 return resultobj;
17758 fail:
17759 {
17760 if (temp2)
17761 delete arg2;
17762 }
17763 return NULL;
17764 }
17765
17766
17767 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj = 0;
17769 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17770 wxString *arg2 = 0 ;
17771 bool result;
17772 void *argp1 = 0 ;
17773 int res1 = 0 ;
17774 bool temp2 = false ;
17775 PyObject * obj0 = 0 ;
17776 PyObject * obj1 = 0 ;
17777 char * kwnames[] = {
17778 (char *) "self",(char *) "filename", NULL
17779 };
17780
17781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17783 if (!SWIG_IsOK(res1)) {
17784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17785 }
17786 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17787 {
17788 arg2 = wxString_in_helper(obj1);
17789 if (arg2 == NULL) SWIG_fail;
17790 temp2 = true;
17791 }
17792 {
17793 PyThreadState* __tstate = wxPyBeginAllowThreads();
17794 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 {
17799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17800 }
17801 {
17802 if (temp2)
17803 delete arg2;
17804 }
17805 return resultobj;
17806 fail:
17807 {
17808 if (temp2)
17809 delete arg2;
17810 }
17811 return NULL;
17812 }
17813
17814
17815 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17816 PyObject *resultobj = 0;
17817 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17818 PyObject *result = 0 ;
17819 void *argp1 = 0 ;
17820 int res1 = 0 ;
17821 PyObject *swig_obj[1] ;
17822
17823 if (!args) SWIG_fail;
17824 swig_obj[0] = args;
17825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17826 if (!SWIG_IsOK(res1)) {
17827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17828 }
17829 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17830 {
17831 PyThreadState* __tstate = wxPyBeginAllowThreads();
17832 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 resultobj = result;
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj = 0;
17845 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17846 wxFileTypeInfo *arg2 = 0 ;
17847 void *argp1 = 0 ;
17848 int res1 = 0 ;
17849 void *argp2 = 0 ;
17850 int res2 = 0 ;
17851 PyObject * obj0 = 0 ;
17852 PyObject * obj1 = 0 ;
17853 char * kwnames[] = {
17854 (char *) "self",(char *) "ft", NULL
17855 };
17856
17857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17859 if (!SWIG_IsOK(res1)) {
17860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17861 }
17862 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17864 if (!SWIG_IsOK(res2)) {
17865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17866 }
17867 if (!argp2) {
17868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17869 }
17870 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17871 {
17872 PyThreadState* __tstate = wxPyBeginAllowThreads();
17873 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17874 wxPyEndAllowThreads(__tstate);
17875 if (PyErr_Occurred()) SWIG_fail;
17876 }
17877 resultobj = SWIG_Py_Void();
17878 return resultobj;
17879 fail:
17880 return NULL;
17881 }
17882
17883
17884 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17885 PyObject *resultobj = 0;
17886 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17887 wxFileTypeInfo *arg2 = 0 ;
17888 wxFileType *result = 0 ;
17889 void *argp1 = 0 ;
17890 int res1 = 0 ;
17891 void *argp2 = 0 ;
17892 int res2 = 0 ;
17893 PyObject * obj0 = 0 ;
17894 PyObject * obj1 = 0 ;
17895 char * kwnames[] = {
17896 (char *) "self",(char *) "ftInfo", NULL
17897 };
17898
17899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17901 if (!SWIG_IsOK(res1)) {
17902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17903 }
17904 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17905 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17906 if (!SWIG_IsOK(res2)) {
17907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17908 }
17909 if (!argp2) {
17910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17911 }
17912 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17913 {
17914 PyThreadState* __tstate = wxPyBeginAllowThreads();
17915 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17916 wxPyEndAllowThreads(__tstate);
17917 if (PyErr_Occurred()) SWIG_fail;
17918 }
17919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17920 return resultobj;
17921 fail:
17922 return NULL;
17923 }
17924
17925
17926 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17927 PyObject *resultobj = 0;
17928 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17929 wxFileType *arg2 = (wxFileType *) 0 ;
17930 bool result;
17931 void *argp1 = 0 ;
17932 int res1 = 0 ;
17933 void *argp2 = 0 ;
17934 int res2 = 0 ;
17935 PyObject * obj0 = 0 ;
17936 PyObject * obj1 = 0 ;
17937 char * kwnames[] = {
17938 (char *) "self",(char *) "ft", NULL
17939 };
17940
17941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17945 }
17946 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17948 if (!SWIG_IsOK(res2)) {
17949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17950 }
17951 arg2 = reinterpret_cast< wxFileType * >(argp2);
17952 {
17953 PyThreadState* __tstate = wxPyBeginAllowThreads();
17954 result = (bool)(arg1)->Unassociate(arg2);
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 {
17959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17960 }
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17968 PyObject *resultobj = 0;
17969 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17970 void *argp1 = 0 ;
17971 int res1 = 0 ;
17972 PyObject *swig_obj[1] ;
17973
17974 if (!args) SWIG_fail;
17975 swig_obj[0] = args;
17976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17979 }
17980 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 delete arg1;
17984
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 resultobj = SWIG_Py_Void();
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17996 PyObject *obj;
17997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17998 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
17999 return SWIG_Py_Void();
18000 }
18001
18002 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18003 return SWIG_Python_InitShadowInstance(args);
18004 }
18005
18006 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18007 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18008 return 1;
18009 }
18010
18011
18012 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18013 PyObject *pyobj = 0;
18014
18015 {
18016 #if wxUSE_UNICODE
18017 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18018 #else
18019 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18020 #endif
18021 }
18022 return pyobj;
18023 }
18024
18025
18026 SWIGINTERN int ART_MENU_set(PyObject *) {
18027 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18028 return 1;
18029 }
18030
18031
18032 SWIGINTERN PyObject *ART_MENU_get(void) {
18033 PyObject *pyobj = 0;
18034
18035 {
18036 #if wxUSE_UNICODE
18037 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18038 #else
18039 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18040 #endif
18041 }
18042 return pyobj;
18043 }
18044
18045
18046 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18047 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18048 return 1;
18049 }
18050
18051
18052 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18053 PyObject *pyobj = 0;
18054
18055 {
18056 #if wxUSE_UNICODE
18057 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18058 #else
18059 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18060 #endif
18061 }
18062 return pyobj;
18063 }
18064
18065
18066 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18067 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18068 return 1;
18069 }
18070
18071
18072 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18073 PyObject *pyobj = 0;
18074
18075 {
18076 #if wxUSE_UNICODE
18077 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18078 #else
18079 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18080 #endif
18081 }
18082 return pyobj;
18083 }
18084
18085
18086 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18087 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18088 return 1;
18089 }
18090
18091
18092 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18093 PyObject *pyobj = 0;
18094
18095 {
18096 #if wxUSE_UNICODE
18097 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18098 #else
18099 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18100 #endif
18101 }
18102 return pyobj;
18103 }
18104
18105
18106 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18107 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18108 return 1;
18109 }
18110
18111
18112 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18113 PyObject *pyobj = 0;
18114
18115 {
18116 #if wxUSE_UNICODE
18117 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18118 #else
18119 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18120 #endif
18121 }
18122 return pyobj;
18123 }
18124
18125
18126 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18127 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18128 return 1;
18129 }
18130
18131
18132 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18133 PyObject *pyobj = 0;
18134
18135 {
18136 #if wxUSE_UNICODE
18137 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18138 #else
18139 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18140 #endif
18141 }
18142 return pyobj;
18143 }
18144
18145
18146 SWIGINTERN int ART_OTHER_set(PyObject *) {
18147 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18148 return 1;
18149 }
18150
18151
18152 SWIGINTERN PyObject *ART_OTHER_get(void) {
18153 PyObject *pyobj = 0;
18154
18155 {
18156 #if wxUSE_UNICODE
18157 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18158 #else
18159 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18160 #endif
18161 }
18162 return pyobj;
18163 }
18164
18165
18166 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18167 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18168 return 1;
18169 }
18170
18171
18172 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18173 PyObject *pyobj = 0;
18174
18175 {
18176 #if wxUSE_UNICODE
18177 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18178 #else
18179 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18180 #endif
18181 }
18182 return pyobj;
18183 }
18184
18185
18186 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18187 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18188 return 1;
18189 }
18190
18191
18192 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18193 PyObject *pyobj = 0;
18194
18195 {
18196 #if wxUSE_UNICODE
18197 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18198 #else
18199 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18200 #endif
18201 }
18202 return pyobj;
18203 }
18204
18205
18206 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18207 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18208 return 1;
18209 }
18210
18211
18212 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18213 PyObject *pyobj = 0;
18214
18215 {
18216 #if wxUSE_UNICODE
18217 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18218 #else
18219 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18220 #endif
18221 }
18222 return pyobj;
18223 }
18224
18225
18226 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18227 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18228 return 1;
18229 }
18230
18231
18232 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18233 PyObject *pyobj = 0;
18234
18235 {
18236 #if wxUSE_UNICODE
18237 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18238 #else
18239 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18240 #endif
18241 }
18242 return pyobj;
18243 }
18244
18245
18246 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18247 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18248 return 1;
18249 }
18250
18251
18252 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18253 PyObject *pyobj = 0;
18254
18255 {
18256 #if wxUSE_UNICODE
18257 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18258 #else
18259 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18260 #endif
18261 }
18262 return pyobj;
18263 }
18264
18265
18266 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18267 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18268 return 1;
18269 }
18270
18271
18272 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18273 PyObject *pyobj = 0;
18274
18275 {
18276 #if wxUSE_UNICODE
18277 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18278 #else
18279 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18280 #endif
18281 }
18282 return pyobj;
18283 }
18284
18285
18286 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18287 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18288 return 1;
18289 }
18290
18291
18292 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18293 PyObject *pyobj = 0;
18294
18295 {
18296 #if wxUSE_UNICODE
18297 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18298 #else
18299 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18300 #endif
18301 }
18302 return pyobj;
18303 }
18304
18305
18306 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18307 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18308 return 1;
18309 }
18310
18311
18312 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18313 PyObject *pyobj = 0;
18314
18315 {
18316 #if wxUSE_UNICODE
18317 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18318 #else
18319 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18320 #endif
18321 }
18322 return pyobj;
18323 }
18324
18325
18326 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18327 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18328 return 1;
18329 }
18330
18331
18332 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18333 PyObject *pyobj = 0;
18334
18335 {
18336 #if wxUSE_UNICODE
18337 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18338 #else
18339 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18340 #endif
18341 }
18342 return pyobj;
18343 }
18344
18345
18346 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18347 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18348 return 1;
18349 }
18350
18351
18352 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18353 PyObject *pyobj = 0;
18354
18355 {
18356 #if wxUSE_UNICODE
18357 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18358 #else
18359 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18360 #endif
18361 }
18362 return pyobj;
18363 }
18364
18365
18366 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18367 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18368 return 1;
18369 }
18370
18371
18372 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18373 PyObject *pyobj = 0;
18374
18375 {
18376 #if wxUSE_UNICODE
18377 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18378 #else
18379 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18380 #endif
18381 }
18382 return pyobj;
18383 }
18384
18385
18386 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18387 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18388 return 1;
18389 }
18390
18391
18392 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18393 PyObject *pyobj = 0;
18394
18395 {
18396 #if wxUSE_UNICODE
18397 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18398 #else
18399 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18400 #endif
18401 }
18402 return pyobj;
18403 }
18404
18405
18406 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18407 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18408 return 1;
18409 }
18410
18411
18412 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18413 PyObject *pyobj = 0;
18414
18415 {
18416 #if wxUSE_UNICODE
18417 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18418 #else
18419 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18420 #endif
18421 }
18422 return pyobj;
18423 }
18424
18425
18426 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18427 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18428 return 1;
18429 }
18430
18431
18432 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18433 PyObject *pyobj = 0;
18434
18435 {
18436 #if wxUSE_UNICODE
18437 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18438 #else
18439 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18440 #endif
18441 }
18442 return pyobj;
18443 }
18444
18445
18446 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18447 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18448 return 1;
18449 }
18450
18451
18452 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18453 PyObject *pyobj = 0;
18454
18455 {
18456 #if wxUSE_UNICODE
18457 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18458 #else
18459 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18460 #endif
18461 }
18462 return pyobj;
18463 }
18464
18465
18466 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18467 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18468 return 1;
18469 }
18470
18471
18472 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18473 PyObject *pyobj = 0;
18474
18475 {
18476 #if wxUSE_UNICODE
18477 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18478 #else
18479 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18480 #endif
18481 }
18482 return pyobj;
18483 }
18484
18485
18486 SWIGINTERN int ART_PRINT_set(PyObject *) {
18487 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18488 return 1;
18489 }
18490
18491
18492 SWIGINTERN PyObject *ART_PRINT_get(void) {
18493 PyObject *pyobj = 0;
18494
18495 {
18496 #if wxUSE_UNICODE
18497 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18498 #else
18499 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18500 #endif
18501 }
18502 return pyobj;
18503 }
18504
18505
18506 SWIGINTERN int ART_HELP_set(PyObject *) {
18507 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18508 return 1;
18509 }
18510
18511
18512 SWIGINTERN PyObject *ART_HELP_get(void) {
18513 PyObject *pyobj = 0;
18514
18515 {
18516 #if wxUSE_UNICODE
18517 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18518 #else
18519 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18520 #endif
18521 }
18522 return pyobj;
18523 }
18524
18525
18526 SWIGINTERN int ART_TIP_set(PyObject *) {
18527 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18528 return 1;
18529 }
18530
18531
18532 SWIGINTERN PyObject *ART_TIP_get(void) {
18533 PyObject *pyobj = 0;
18534
18535 {
18536 #if wxUSE_UNICODE
18537 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18538 #else
18539 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18540 #endif
18541 }
18542 return pyobj;
18543 }
18544
18545
18546 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18547 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18548 return 1;
18549 }
18550
18551
18552 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18553 PyObject *pyobj = 0;
18554
18555 {
18556 #if wxUSE_UNICODE
18557 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18558 #else
18559 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18560 #endif
18561 }
18562 return pyobj;
18563 }
18564
18565
18566 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18567 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18568 return 1;
18569 }
18570
18571
18572 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18573 PyObject *pyobj = 0;
18574
18575 {
18576 #if wxUSE_UNICODE
18577 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18578 #else
18579 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18580 #endif
18581 }
18582 return pyobj;
18583 }
18584
18585
18586 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18587 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18588 return 1;
18589 }
18590
18591
18592 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18593 PyObject *pyobj = 0;
18594
18595 {
18596 #if wxUSE_UNICODE
18597 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18598 #else
18599 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18600 #endif
18601 }
18602 return pyobj;
18603 }
18604
18605
18606 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18607 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18608 return 1;
18609 }
18610
18611
18612 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18613 PyObject *pyobj = 0;
18614
18615 {
18616 #if wxUSE_UNICODE
18617 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18618 #else
18619 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18620 #endif
18621 }
18622 return pyobj;
18623 }
18624
18625
18626 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18627 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18628 return 1;
18629 }
18630
18631
18632 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18633 PyObject *pyobj = 0;
18634
18635 {
18636 #if wxUSE_UNICODE
18637 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18638 #else
18639 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18640 #endif
18641 }
18642 return pyobj;
18643 }
18644
18645
18646 SWIGINTERN int ART_CDROM_set(PyObject *) {
18647 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18648 return 1;
18649 }
18650
18651
18652 SWIGINTERN PyObject *ART_CDROM_get(void) {
18653 PyObject *pyobj = 0;
18654
18655 {
18656 #if wxUSE_UNICODE
18657 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18658 #else
18659 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18660 #endif
18661 }
18662 return pyobj;
18663 }
18664
18665
18666 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18667 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18668 return 1;
18669 }
18670
18671
18672 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18673 PyObject *pyobj = 0;
18674
18675 {
18676 #if wxUSE_UNICODE
18677 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18678 #else
18679 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18680 #endif
18681 }
18682 return pyobj;
18683 }
18684
18685
18686 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18687 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18688 return 1;
18689 }
18690
18691
18692 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18693 PyObject *pyobj = 0;
18694
18695 {
18696 #if wxUSE_UNICODE
18697 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18698 #else
18699 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18700 #endif
18701 }
18702 return pyobj;
18703 }
18704
18705
18706 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18707 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18708 return 1;
18709 }
18710
18711
18712 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18713 PyObject *pyobj = 0;
18714
18715 {
18716 #if wxUSE_UNICODE
18717 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18718 #else
18719 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18720 #endif
18721 }
18722 return pyobj;
18723 }
18724
18725
18726 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18727 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18728 return 1;
18729 }
18730
18731
18732 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18733 PyObject *pyobj = 0;
18734
18735 {
18736 #if wxUSE_UNICODE
18737 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18738 #else
18739 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18740 #endif
18741 }
18742 return pyobj;
18743 }
18744
18745
18746 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18747 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18748 return 1;
18749 }
18750
18751
18752 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18753 PyObject *pyobj = 0;
18754
18755 {
18756 #if wxUSE_UNICODE
18757 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18758 #else
18759 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18760 #endif
18761 }
18762 return pyobj;
18763 }
18764
18765
18766 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18767 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18768 return 1;
18769 }
18770
18771
18772 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18773 PyObject *pyobj = 0;
18774
18775 {
18776 #if wxUSE_UNICODE
18777 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18778 #else
18779 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18780 #endif
18781 }
18782 return pyobj;
18783 }
18784
18785
18786 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18787 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18788 return 1;
18789 }
18790
18791
18792 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18793 PyObject *pyobj = 0;
18794
18795 {
18796 #if wxUSE_UNICODE
18797 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18798 #else
18799 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18800 #endif
18801 }
18802 return pyobj;
18803 }
18804
18805
18806 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18807 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18808 return 1;
18809 }
18810
18811
18812 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18813 PyObject *pyobj = 0;
18814
18815 {
18816 #if wxUSE_UNICODE
18817 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18818 #else
18819 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18820 #endif
18821 }
18822 return pyobj;
18823 }
18824
18825
18826 SWIGINTERN int ART_ERROR_set(PyObject *) {
18827 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18828 return 1;
18829 }
18830
18831
18832 SWIGINTERN PyObject *ART_ERROR_get(void) {
18833 PyObject *pyobj = 0;
18834
18835 {
18836 #if wxUSE_UNICODE
18837 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18838 #else
18839 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18840 #endif
18841 }
18842 return pyobj;
18843 }
18844
18845
18846 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18847 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18848 return 1;
18849 }
18850
18851
18852 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18853 PyObject *pyobj = 0;
18854
18855 {
18856 #if wxUSE_UNICODE
18857 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18858 #else
18859 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18860 #endif
18861 }
18862 return pyobj;
18863 }
18864
18865
18866 SWIGINTERN int ART_WARNING_set(PyObject *) {
18867 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18868 return 1;
18869 }
18870
18871
18872 SWIGINTERN PyObject *ART_WARNING_get(void) {
18873 PyObject *pyobj = 0;
18874
18875 {
18876 #if wxUSE_UNICODE
18877 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18878 #else
18879 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18880 #endif
18881 }
18882 return pyobj;
18883 }
18884
18885
18886 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18887 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18888 return 1;
18889 }
18890
18891
18892 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18893 PyObject *pyobj = 0;
18894
18895 {
18896 #if wxUSE_UNICODE
18897 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18898 #else
18899 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18900 #endif
18901 }
18902 return pyobj;
18903 }
18904
18905
18906 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18907 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18908 return 1;
18909 }
18910
18911
18912 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18913 PyObject *pyobj = 0;
18914
18915 {
18916 #if wxUSE_UNICODE
18917 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18918 #else
18919 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18920 #endif
18921 }
18922 return pyobj;
18923 }
18924
18925
18926 SWIGINTERN int ART_COPY_set(PyObject *) {
18927 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18928 return 1;
18929 }
18930
18931
18932 SWIGINTERN PyObject *ART_COPY_get(void) {
18933 PyObject *pyobj = 0;
18934
18935 {
18936 #if wxUSE_UNICODE
18937 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18938 #else
18939 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18940 #endif
18941 }
18942 return pyobj;
18943 }
18944
18945
18946 SWIGINTERN int ART_CUT_set(PyObject *) {
18947 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18948 return 1;
18949 }
18950
18951
18952 SWIGINTERN PyObject *ART_CUT_get(void) {
18953 PyObject *pyobj = 0;
18954
18955 {
18956 #if wxUSE_UNICODE
18957 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18958 #else
18959 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18960 #endif
18961 }
18962 return pyobj;
18963 }
18964
18965
18966 SWIGINTERN int ART_PASTE_set(PyObject *) {
18967 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18968 return 1;
18969 }
18970
18971
18972 SWIGINTERN PyObject *ART_PASTE_get(void) {
18973 PyObject *pyobj = 0;
18974
18975 {
18976 #if wxUSE_UNICODE
18977 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18978 #else
18979 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18980 #endif
18981 }
18982 return pyobj;
18983 }
18984
18985
18986 SWIGINTERN int ART_DELETE_set(PyObject *) {
18987 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18988 return 1;
18989 }
18990
18991
18992 SWIGINTERN PyObject *ART_DELETE_get(void) {
18993 PyObject *pyobj = 0;
18994
18995 {
18996 #if wxUSE_UNICODE
18997 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18998 #else
18999 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19000 #endif
19001 }
19002 return pyobj;
19003 }
19004
19005
19006 SWIGINTERN int ART_NEW_set(PyObject *) {
19007 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19008 return 1;
19009 }
19010
19011
19012 SWIGINTERN PyObject *ART_NEW_get(void) {
19013 PyObject *pyobj = 0;
19014
19015 {
19016 #if wxUSE_UNICODE
19017 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19018 #else
19019 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19020 #endif
19021 }
19022 return pyobj;
19023 }
19024
19025
19026 SWIGINTERN int ART_UNDO_set(PyObject *) {
19027 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19028 return 1;
19029 }
19030
19031
19032 SWIGINTERN PyObject *ART_UNDO_get(void) {
19033 PyObject *pyobj = 0;
19034
19035 {
19036 #if wxUSE_UNICODE
19037 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19038 #else
19039 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19040 #endif
19041 }
19042 return pyobj;
19043 }
19044
19045
19046 SWIGINTERN int ART_REDO_set(PyObject *) {
19047 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19048 return 1;
19049 }
19050
19051
19052 SWIGINTERN PyObject *ART_REDO_get(void) {
19053 PyObject *pyobj = 0;
19054
19055 {
19056 #if wxUSE_UNICODE
19057 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19058 #else
19059 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19060 #endif
19061 }
19062 return pyobj;
19063 }
19064
19065
19066 SWIGINTERN int ART_QUIT_set(PyObject *) {
19067 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19068 return 1;
19069 }
19070
19071
19072 SWIGINTERN PyObject *ART_QUIT_get(void) {
19073 PyObject *pyobj = 0;
19074
19075 {
19076 #if wxUSE_UNICODE
19077 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19078 #else
19079 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19080 #endif
19081 }
19082 return pyobj;
19083 }
19084
19085
19086 SWIGINTERN int ART_FIND_set(PyObject *) {
19087 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19088 return 1;
19089 }
19090
19091
19092 SWIGINTERN PyObject *ART_FIND_get(void) {
19093 PyObject *pyobj = 0;
19094
19095 {
19096 #if wxUSE_UNICODE
19097 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19098 #else
19099 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19100 #endif
19101 }
19102 return pyobj;
19103 }
19104
19105
19106 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19107 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19108 return 1;
19109 }
19110
19111
19112 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19113 PyObject *pyobj = 0;
19114
19115 {
19116 #if wxUSE_UNICODE
19117 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19118 #else
19119 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19120 #endif
19121 }
19122 return pyobj;
19123 }
19124
19125
19126 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19127 PyObject *resultobj = 0;
19128 wxPyArtProvider *result = 0 ;
19129
19130 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19131 {
19132 if (!wxPyCheckForApp()) SWIG_fail;
19133 PyThreadState* __tstate = wxPyBeginAllowThreads();
19134 result = (wxPyArtProvider *)new wxPyArtProvider();
19135 wxPyEndAllowThreads(__tstate);
19136 if (PyErr_Occurred()) SWIG_fail;
19137 }
19138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19139 return resultobj;
19140 fail:
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19146 PyObject *resultobj = 0;
19147 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19148 void *argp1 = 0 ;
19149 int res1 = 0 ;
19150 PyObject *swig_obj[1] ;
19151
19152 if (!args) SWIG_fail;
19153 swig_obj[0] = args;
19154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19155 if (!SWIG_IsOK(res1)) {
19156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19157 }
19158 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19159 {
19160 PyThreadState* __tstate = wxPyBeginAllowThreads();
19161 delete arg1;
19162
19163 wxPyEndAllowThreads(__tstate);
19164 if (PyErr_Occurred()) SWIG_fail;
19165 }
19166 resultobj = SWIG_Py_Void();
19167 return resultobj;
19168 fail:
19169 return NULL;
19170 }
19171
19172
19173 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19174 PyObject *resultobj = 0;
19175 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19176 PyObject *arg2 = (PyObject *) 0 ;
19177 PyObject *arg3 = (PyObject *) 0 ;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 PyObject * obj0 = 0 ;
19181 PyObject * obj1 = 0 ;
19182 PyObject * obj2 = 0 ;
19183 char * kwnames[] = {
19184 (char *) "self",(char *) "self",(char *) "_class", NULL
19185 };
19186
19187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19189 if (!SWIG_IsOK(res1)) {
19190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19191 }
19192 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19193 arg2 = obj1;
19194 arg3 = obj2;
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 (arg1)->_setCallbackInfo(arg2,arg3);
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 resultobj = SWIG_Py_Void();
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj = 0;
19210 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19211 int res1 = 0 ;
19212 PyObject * obj0 = 0 ;
19213 char * kwnames[] = {
19214 (char *) "provider", NULL
19215 };
19216
19217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19218 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19219 if (!SWIG_IsOK(res1)) {
19220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 wxPyArtProvider::PushProvider(arg1);
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 resultobj = SWIG_Py_Void();
19229 return resultobj;
19230 fail:
19231 return NULL;
19232 }
19233
19234
19235 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19236 PyObject *resultobj = 0;
19237 bool result;
19238
19239 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19240 {
19241 PyThreadState* __tstate = wxPyBeginAllowThreads();
19242 result = (bool)wxPyArtProvider::PopProvider();
19243 wxPyEndAllowThreads(__tstate);
19244 if (PyErr_Occurred()) SWIG_fail;
19245 }
19246 {
19247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19248 }
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19256 PyObject *resultobj = 0;
19257 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19258 bool result;
19259 void *argp1 = 0 ;
19260 int res1 = 0 ;
19261 PyObject * obj0 = 0 ;
19262 char * kwnames[] = {
19263 (char *) "provider", NULL
19264 };
19265
19266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19268 if (!SWIG_IsOK(res1)) {
19269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19270 }
19271 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19272 {
19273 PyThreadState* __tstate = wxPyBeginAllowThreads();
19274 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 {
19279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19280 }
19281 return resultobj;
19282 fail:
19283 return NULL;
19284 }
19285
19286
19287 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19288 PyObject *resultobj = 0;
19289 wxString *arg1 = 0 ;
19290 wxString const &arg2_defvalue = wxPyART_OTHER ;
19291 wxString *arg2 = (wxString *) &arg2_defvalue ;
19292 wxSize const &arg3_defvalue = wxDefaultSize ;
19293 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19294 wxBitmap result;
19295 bool temp1 = false ;
19296 bool temp2 = false ;
19297 wxSize temp3 ;
19298 PyObject * obj0 = 0 ;
19299 PyObject * obj1 = 0 ;
19300 PyObject * obj2 = 0 ;
19301 char * kwnames[] = {
19302 (char *) "id",(char *) "client",(char *) "size", NULL
19303 };
19304
19305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19306 {
19307 arg1 = wxString_in_helper(obj0);
19308 if (arg1 == NULL) SWIG_fail;
19309 temp1 = true;
19310 }
19311 if (obj1) {
19312 {
19313 arg2 = wxString_in_helper(obj1);
19314 if (arg2 == NULL) SWIG_fail;
19315 temp2 = true;
19316 }
19317 }
19318 if (obj2) {
19319 {
19320 arg3 = &temp3;
19321 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19322 }
19323 }
19324 {
19325 if (!wxPyCheckForApp()) SWIG_fail;
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19328 wxPyEndAllowThreads(__tstate);
19329 if (PyErr_Occurred()) SWIG_fail;
19330 }
19331 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19332 {
19333 if (temp1)
19334 delete arg1;
19335 }
19336 {
19337 if (temp2)
19338 delete arg2;
19339 }
19340 return resultobj;
19341 fail:
19342 {
19343 if (temp1)
19344 delete arg1;
19345 }
19346 {
19347 if (temp2)
19348 delete arg2;
19349 }
19350 return NULL;
19351 }
19352
19353
19354 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19355 PyObject *resultobj = 0;
19356 wxString *arg1 = 0 ;
19357 wxString const &arg2_defvalue = wxPyART_OTHER ;
19358 wxString *arg2 = (wxString *) &arg2_defvalue ;
19359 wxSize const &arg3_defvalue = wxDefaultSize ;
19360 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19361 wxIcon result;
19362 bool temp1 = false ;
19363 bool temp2 = false ;
19364 wxSize temp3 ;
19365 PyObject * obj0 = 0 ;
19366 PyObject * obj1 = 0 ;
19367 PyObject * obj2 = 0 ;
19368 char * kwnames[] = {
19369 (char *) "id",(char *) "client",(char *) "size", NULL
19370 };
19371
19372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19373 {
19374 arg1 = wxString_in_helper(obj0);
19375 if (arg1 == NULL) SWIG_fail;
19376 temp1 = true;
19377 }
19378 if (obj1) {
19379 {
19380 arg2 = wxString_in_helper(obj1);
19381 if (arg2 == NULL) SWIG_fail;
19382 temp2 = true;
19383 }
19384 }
19385 if (obj2) {
19386 {
19387 arg3 = &temp3;
19388 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19389 }
19390 }
19391 {
19392 if (!wxPyCheckForApp()) SWIG_fail;
19393 PyThreadState* __tstate = wxPyBeginAllowThreads();
19394 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19395 wxPyEndAllowThreads(__tstate);
19396 if (PyErr_Occurred()) SWIG_fail;
19397 }
19398 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19399 {
19400 if (temp1)
19401 delete arg1;
19402 }
19403 {
19404 if (temp2)
19405 delete arg2;
19406 }
19407 return resultobj;
19408 fail:
19409 {
19410 if (temp1)
19411 delete arg1;
19412 }
19413 {
19414 if (temp2)
19415 delete arg2;
19416 }
19417 return NULL;
19418 }
19419
19420
19421 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19422 PyObject *resultobj = 0;
19423 wxString *arg1 = 0 ;
19424 bool arg2 = (bool) false ;
19425 wxSize result;
19426 bool temp1 = false ;
19427 bool val2 ;
19428 int ecode2 = 0 ;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 char * kwnames[] = {
19432 (char *) "client",(char *) "platform_dependent", NULL
19433 };
19434
19435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19436 {
19437 arg1 = wxString_in_helper(obj0);
19438 if (arg1 == NULL) SWIG_fail;
19439 temp1 = true;
19440 }
19441 if (obj1) {
19442 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19443 if (!SWIG_IsOK(ecode2)) {
19444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19445 }
19446 arg2 = static_cast< bool >(val2);
19447 }
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19455 {
19456 if (temp1)
19457 delete arg1;
19458 }
19459 return resultobj;
19460 fail:
19461 {
19462 if (temp1)
19463 delete arg1;
19464 }
19465 return NULL;
19466 }
19467
19468
19469 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19470 PyObject *resultobj = 0;
19471 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19472 void *argp1 = 0 ;
19473 int res1 = 0 ;
19474 PyObject *swig_obj[1] ;
19475
19476 if (!args) SWIG_fail;
19477 swig_obj[0] = args;
19478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19479 if (!SWIG_IsOK(res1)) {
19480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19481 }
19482 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 wxPyArtProvider_Destroy(arg1);
19486 wxPyEndAllowThreads(__tstate);
19487 if (PyErr_Occurred()) SWIG_fail;
19488 }
19489 resultobj = SWIG_Py_Void();
19490 return resultobj;
19491 fail:
19492 return NULL;
19493 }
19494
19495
19496 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19497 PyObject *obj;
19498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19499 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19500 return SWIG_Py_Void();
19501 }
19502
19503 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19504 return SWIG_Python_InitShadowInstance(args);
19505 }
19506
19507 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19508 PyObject *resultobj = 0;
19509 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19510 void *argp1 = 0 ;
19511 int res1 = 0 ;
19512 PyObject *swig_obj[1] ;
19513
19514 if (!args) SWIG_fail;
19515 swig_obj[0] = args;
19516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19517 if (!SWIG_IsOK(res1)) {
19518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19519 }
19520 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19521 {
19522 PyThreadState* __tstate = wxPyBeginAllowThreads();
19523 delete arg1;
19524
19525 wxPyEndAllowThreads(__tstate);
19526 if (PyErr_Occurred()) SWIG_fail;
19527 }
19528 resultobj = SWIG_Py_Void();
19529 return resultobj;
19530 fail:
19531 return NULL;
19532 }
19533
19534
19535 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19536 PyObject *resultobj = 0;
19537 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19538 wxConfigBase *result = 0 ;
19539 int res1 = 0 ;
19540 PyObject * obj0 = 0 ;
19541 char * kwnames[] = {
19542 (char *) "config", NULL
19543 };
19544
19545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19546 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19547 if (!SWIG_IsOK(res1)) {
19548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19549 }
19550 {
19551 PyThreadState* __tstate = wxPyBeginAllowThreads();
19552 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19553 wxPyEndAllowThreads(__tstate);
19554 if (PyErr_Occurred()) SWIG_fail;
19555 }
19556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19557 return resultobj;
19558 fail:
19559 return NULL;
19560 }
19561
19562
19563 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj = 0;
19565 bool arg1 = (bool) true ;
19566 wxConfigBase *result = 0 ;
19567 bool val1 ;
19568 int ecode1 = 0 ;
19569 PyObject * obj0 = 0 ;
19570 char * kwnames[] = {
19571 (char *) "createOnDemand", NULL
19572 };
19573
19574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19575 if (obj0) {
19576 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19577 if (!SWIG_IsOK(ecode1)) {
19578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19579 }
19580 arg1 = static_cast< bool >(val1);
19581 }
19582 {
19583 PyThreadState* __tstate = wxPyBeginAllowThreads();
19584 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19596 PyObject *resultobj = 0;
19597 wxConfigBase *result = 0 ;
19598
19599 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19600 {
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = (wxConfigBase *)wxConfigBase::Create();
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19614 PyObject *resultobj = 0;
19615
19616 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19617 {
19618 PyThreadState* __tstate = wxPyBeginAllowThreads();
19619 wxConfigBase::DontCreateOnDemand();
19620 wxPyEndAllowThreads(__tstate);
19621 if (PyErr_Occurred()) SWIG_fail;
19622 }
19623 resultobj = SWIG_Py_Void();
19624 return resultobj;
19625 fail:
19626 return NULL;
19627 }
19628
19629
19630 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19631 PyObject *resultobj = 0;
19632 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19633 wxString *arg2 = 0 ;
19634 void *argp1 = 0 ;
19635 int res1 = 0 ;
19636 bool temp2 = false ;
19637 PyObject * obj0 = 0 ;
19638 PyObject * obj1 = 0 ;
19639 char * kwnames[] = {
19640 (char *) "self",(char *) "path", NULL
19641 };
19642
19643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19645 if (!SWIG_IsOK(res1)) {
19646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19647 }
19648 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19649 {
19650 arg2 = wxString_in_helper(obj1);
19651 if (arg2 == NULL) SWIG_fail;
19652 temp2 = true;
19653 }
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 (arg1)->SetPath((wxString const &)*arg2);
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 resultobj = SWIG_Py_Void();
19661 {
19662 if (temp2)
19663 delete arg2;
19664 }
19665 return resultobj;
19666 fail:
19667 {
19668 if (temp2)
19669 delete arg2;
19670 }
19671 return NULL;
19672 }
19673
19674
19675 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19676 PyObject *resultobj = 0;
19677 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19678 wxString *result = 0 ;
19679 void *argp1 = 0 ;
19680 int res1 = 0 ;
19681 PyObject *swig_obj[1] ;
19682
19683 if (!args) SWIG_fail;
19684 swig_obj[0] = args;
19685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19686 if (!SWIG_IsOK(res1)) {
19687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19688 }
19689 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19690 {
19691 PyThreadState* __tstate = wxPyBeginAllowThreads();
19692 {
19693 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19694 result = (wxString *) &_result_ref;
19695 }
19696 wxPyEndAllowThreads(__tstate);
19697 if (PyErr_Occurred()) SWIG_fail;
19698 }
19699 {
19700 #if wxUSE_UNICODE
19701 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19702 #else
19703 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19704 #endif
19705 }
19706 return resultobj;
19707 fail:
19708 return NULL;
19709 }
19710
19711
19712 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19713 PyObject *resultobj = 0;
19714 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19715 PyObject *result = 0 ;
19716 void *argp1 = 0 ;
19717 int res1 = 0 ;
19718 PyObject *swig_obj[1] ;
19719
19720 if (!args) SWIG_fail;
19721 swig_obj[0] = args;
19722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19723 if (!SWIG_IsOK(res1)) {
19724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19725 }
19726 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 resultobj = result;
19734 return resultobj;
19735 fail:
19736 return NULL;
19737 }
19738
19739
19740 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19741 PyObject *resultobj = 0;
19742 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19743 long arg2 ;
19744 PyObject *result = 0 ;
19745 void *argp1 = 0 ;
19746 int res1 = 0 ;
19747 long val2 ;
19748 int ecode2 = 0 ;
19749 PyObject * obj0 = 0 ;
19750 PyObject * obj1 = 0 ;
19751 char * kwnames[] = {
19752 (char *) "self",(char *) "index", NULL
19753 };
19754
19755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19757 if (!SWIG_IsOK(res1)) {
19758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19759 }
19760 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19761 ecode2 = SWIG_AsVal_long(obj1, &val2);
19762 if (!SWIG_IsOK(ecode2)) {
19763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19764 }
19765 arg2 = static_cast< long >(val2);
19766 {
19767 PyThreadState* __tstate = wxPyBeginAllowThreads();
19768 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19769 wxPyEndAllowThreads(__tstate);
19770 if (PyErr_Occurred()) SWIG_fail;
19771 }
19772 resultobj = result;
19773 return resultobj;
19774 fail:
19775 return NULL;
19776 }
19777
19778
19779 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19780 PyObject *resultobj = 0;
19781 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19782 PyObject *result = 0 ;
19783 void *argp1 = 0 ;
19784 int res1 = 0 ;
19785 PyObject *swig_obj[1] ;
19786
19787 if (!args) SWIG_fail;
19788 swig_obj[0] = args;
19789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19792 }
19793 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 resultobj = result;
19801 return resultobj;
19802 fail:
19803 return NULL;
19804 }
19805
19806
19807 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj = 0;
19809 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19810 long arg2 ;
19811 PyObject *result = 0 ;
19812 void *argp1 = 0 ;
19813 int res1 = 0 ;
19814 long val2 ;
19815 int ecode2 = 0 ;
19816 PyObject * obj0 = 0 ;
19817 PyObject * obj1 = 0 ;
19818 char * kwnames[] = {
19819 (char *) "self",(char *) "index", NULL
19820 };
19821
19822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19824 if (!SWIG_IsOK(res1)) {
19825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19826 }
19827 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19828 ecode2 = SWIG_AsVal_long(obj1, &val2);
19829 if (!SWIG_IsOK(ecode2)) {
19830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19831 }
19832 arg2 = static_cast< long >(val2);
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19836 wxPyEndAllowThreads(__tstate);
19837 if (PyErr_Occurred()) SWIG_fail;
19838 }
19839 resultobj = result;
19840 return resultobj;
19841 fail:
19842 return NULL;
19843 }
19844
19845
19846 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19847 PyObject *resultobj = 0;
19848 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19849 bool arg2 = (bool) false ;
19850 size_t result;
19851 void *argp1 = 0 ;
19852 int res1 = 0 ;
19853 bool val2 ;
19854 int ecode2 = 0 ;
19855 PyObject * obj0 = 0 ;
19856 PyObject * obj1 = 0 ;
19857 char * kwnames[] = {
19858 (char *) "self",(char *) "recursive", NULL
19859 };
19860
19861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19863 if (!SWIG_IsOK(res1)) {
19864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19865 }
19866 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19867 if (obj1) {
19868 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19869 if (!SWIG_IsOK(ecode2)) {
19870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19871 }
19872 arg2 = static_cast< bool >(val2);
19873 }
19874 {
19875 PyThreadState* __tstate = wxPyBeginAllowThreads();
19876 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj = 0;
19889 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19890 bool arg2 = (bool) false ;
19891 size_t result;
19892 void *argp1 = 0 ;
19893 int res1 = 0 ;
19894 bool val2 ;
19895 int ecode2 = 0 ;
19896 PyObject * obj0 = 0 ;
19897 PyObject * obj1 = 0 ;
19898 char * kwnames[] = {
19899 (char *) "self",(char *) "recursive", NULL
19900 };
19901
19902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19904 if (!SWIG_IsOK(res1)) {
19905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19906 }
19907 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19908 if (obj1) {
19909 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19910 if (!SWIG_IsOK(ecode2)) {
19911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19912 }
19913 arg2 = static_cast< bool >(val2);
19914 }
19915 {
19916 PyThreadState* __tstate = wxPyBeginAllowThreads();
19917 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19918 wxPyEndAllowThreads(__tstate);
19919 if (PyErr_Occurred()) SWIG_fail;
19920 }
19921 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19922 return resultobj;
19923 fail:
19924 return NULL;
19925 }
19926
19927
19928 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19929 PyObject *resultobj = 0;
19930 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19931 wxString *arg2 = 0 ;
19932 bool result;
19933 void *argp1 = 0 ;
19934 int res1 = 0 ;
19935 bool temp2 = false ;
19936 PyObject * obj0 = 0 ;
19937 PyObject * obj1 = 0 ;
19938 char * kwnames[] = {
19939 (char *) "self",(char *) "name", NULL
19940 };
19941
19942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19944 if (!SWIG_IsOK(res1)) {
19945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19946 }
19947 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19948 {
19949 arg2 = wxString_in_helper(obj1);
19950 if (arg2 == NULL) SWIG_fail;
19951 temp2 = true;
19952 }
19953 {
19954 PyThreadState* __tstate = wxPyBeginAllowThreads();
19955 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19956 wxPyEndAllowThreads(__tstate);
19957 if (PyErr_Occurred()) SWIG_fail;
19958 }
19959 {
19960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19961 }
19962 {
19963 if (temp2)
19964 delete arg2;
19965 }
19966 return resultobj;
19967 fail:
19968 {
19969 if (temp2)
19970 delete arg2;
19971 }
19972 return NULL;
19973 }
19974
19975
19976 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19977 PyObject *resultobj = 0;
19978 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19979 wxString *arg2 = 0 ;
19980 bool result;
19981 void *argp1 = 0 ;
19982 int res1 = 0 ;
19983 bool temp2 = false ;
19984 PyObject * obj0 = 0 ;
19985 PyObject * obj1 = 0 ;
19986 char * kwnames[] = {
19987 (char *) "self",(char *) "name", NULL
19988 };
19989
19990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19992 if (!SWIG_IsOK(res1)) {
19993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19994 }
19995 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19996 {
19997 arg2 = wxString_in_helper(obj1);
19998 if (arg2 == NULL) SWIG_fail;
19999 temp2 = true;
20000 }
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20004 wxPyEndAllowThreads(__tstate);
20005 if (PyErr_Occurred()) SWIG_fail;
20006 }
20007 {
20008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20009 }
20010 {
20011 if (temp2)
20012 delete arg2;
20013 }
20014 return resultobj;
20015 fail:
20016 {
20017 if (temp2)
20018 delete arg2;
20019 }
20020 return NULL;
20021 }
20022
20023
20024 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20025 PyObject *resultobj = 0;
20026 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20027 wxString *arg2 = 0 ;
20028 bool result;
20029 void *argp1 = 0 ;
20030 int res1 = 0 ;
20031 bool temp2 = false ;
20032 PyObject * obj0 = 0 ;
20033 PyObject * obj1 = 0 ;
20034 char * kwnames[] = {
20035 (char *) "self",(char *) "name", NULL
20036 };
20037
20038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20040 if (!SWIG_IsOK(res1)) {
20041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20042 }
20043 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20044 {
20045 arg2 = wxString_in_helper(obj1);
20046 if (arg2 == NULL) SWIG_fail;
20047 temp2 = true;
20048 }
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 {
20056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20057 }
20058 {
20059 if (temp2)
20060 delete arg2;
20061 }
20062 return resultobj;
20063 fail:
20064 {
20065 if (temp2)
20066 delete arg2;
20067 }
20068 return NULL;
20069 }
20070
20071
20072 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20073 PyObject *resultobj = 0;
20074 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20075 wxString *arg2 = 0 ;
20076 wxConfigBase::EntryType result;
20077 void *argp1 = 0 ;
20078 int res1 = 0 ;
20079 bool temp2 = false ;
20080 PyObject * obj0 = 0 ;
20081 PyObject * obj1 = 0 ;
20082 char * kwnames[] = {
20083 (char *) "self",(char *) "name", NULL
20084 };
20085
20086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20088 if (!SWIG_IsOK(res1)) {
20089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20090 }
20091 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20092 {
20093 arg2 = wxString_in_helper(obj1);
20094 if (arg2 == NULL) SWIG_fail;
20095 temp2 = true;
20096 }
20097 {
20098 PyThreadState* __tstate = wxPyBeginAllowThreads();
20099 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20100 wxPyEndAllowThreads(__tstate);
20101 if (PyErr_Occurred()) SWIG_fail;
20102 }
20103 resultobj = SWIG_From_int(static_cast< int >(result));
20104 {
20105 if (temp2)
20106 delete arg2;
20107 }
20108 return resultobj;
20109 fail:
20110 {
20111 if (temp2)
20112 delete arg2;
20113 }
20114 return NULL;
20115 }
20116
20117
20118 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20119 PyObject *resultobj = 0;
20120 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20121 wxString *arg2 = 0 ;
20122 wxString const &arg3_defvalue = wxPyEmptyString ;
20123 wxString *arg3 = (wxString *) &arg3_defvalue ;
20124 wxString result;
20125 void *argp1 = 0 ;
20126 int res1 = 0 ;
20127 bool temp2 = false ;
20128 bool temp3 = false ;
20129 PyObject * obj0 = 0 ;
20130 PyObject * obj1 = 0 ;
20131 PyObject * obj2 = 0 ;
20132 char * kwnames[] = {
20133 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20134 };
20135
20136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20138 if (!SWIG_IsOK(res1)) {
20139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20140 }
20141 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20142 {
20143 arg2 = wxString_in_helper(obj1);
20144 if (arg2 == NULL) SWIG_fail;
20145 temp2 = true;
20146 }
20147 if (obj2) {
20148 {
20149 arg3 = wxString_in_helper(obj2);
20150 if (arg3 == NULL) SWIG_fail;
20151 temp3 = true;
20152 }
20153 }
20154 {
20155 PyThreadState* __tstate = wxPyBeginAllowThreads();
20156 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20157 wxPyEndAllowThreads(__tstate);
20158 if (PyErr_Occurred()) SWIG_fail;
20159 }
20160 {
20161 #if wxUSE_UNICODE
20162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20163 #else
20164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20165 #endif
20166 }
20167 {
20168 if (temp2)
20169 delete arg2;
20170 }
20171 {
20172 if (temp3)
20173 delete arg3;
20174 }
20175 return resultobj;
20176 fail:
20177 {
20178 if (temp2)
20179 delete arg2;
20180 }
20181 {
20182 if (temp3)
20183 delete arg3;
20184 }
20185 return NULL;
20186 }
20187
20188
20189 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20190 PyObject *resultobj = 0;
20191 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20192 wxString *arg2 = 0 ;
20193 long arg3 = (long) 0 ;
20194 long result;
20195 void *argp1 = 0 ;
20196 int res1 = 0 ;
20197 bool temp2 = false ;
20198 long val3 ;
20199 int ecode3 = 0 ;
20200 PyObject * obj0 = 0 ;
20201 PyObject * obj1 = 0 ;
20202 PyObject * obj2 = 0 ;
20203 char * kwnames[] = {
20204 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20205 };
20206
20207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20209 if (!SWIG_IsOK(res1)) {
20210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20211 }
20212 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20213 {
20214 arg2 = wxString_in_helper(obj1);
20215 if (arg2 == NULL) SWIG_fail;
20216 temp2 = true;
20217 }
20218 if (obj2) {
20219 ecode3 = SWIG_AsVal_long(obj2, &val3);
20220 if (!SWIG_IsOK(ecode3)) {
20221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20222 }
20223 arg3 = static_cast< long >(val3);
20224 }
20225 {
20226 PyThreadState* __tstate = wxPyBeginAllowThreads();
20227 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20228 wxPyEndAllowThreads(__tstate);
20229 if (PyErr_Occurred()) SWIG_fail;
20230 }
20231 resultobj = SWIG_From_long(static_cast< long >(result));
20232 {
20233 if (temp2)
20234 delete arg2;
20235 }
20236 return resultobj;
20237 fail:
20238 {
20239 if (temp2)
20240 delete arg2;
20241 }
20242 return NULL;
20243 }
20244
20245
20246 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20247 PyObject *resultobj = 0;
20248 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20249 wxString *arg2 = 0 ;
20250 double arg3 = (double) 0.0 ;
20251 double result;
20252 void *argp1 = 0 ;
20253 int res1 = 0 ;
20254 bool temp2 = false ;
20255 double val3 ;
20256 int ecode3 = 0 ;
20257 PyObject * obj0 = 0 ;
20258 PyObject * obj1 = 0 ;
20259 PyObject * obj2 = 0 ;
20260 char * kwnames[] = {
20261 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20262 };
20263
20264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20266 if (!SWIG_IsOK(res1)) {
20267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20268 }
20269 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20270 {
20271 arg2 = wxString_in_helper(obj1);
20272 if (arg2 == NULL) SWIG_fail;
20273 temp2 = true;
20274 }
20275 if (obj2) {
20276 ecode3 = SWIG_AsVal_double(obj2, &val3);
20277 if (!SWIG_IsOK(ecode3)) {
20278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20279 }
20280 arg3 = static_cast< double >(val3);
20281 }
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20285 wxPyEndAllowThreads(__tstate);
20286 if (PyErr_Occurred()) SWIG_fail;
20287 }
20288 resultobj = SWIG_From_double(static_cast< double >(result));
20289 {
20290 if (temp2)
20291 delete arg2;
20292 }
20293 return resultobj;
20294 fail:
20295 {
20296 if (temp2)
20297 delete arg2;
20298 }
20299 return NULL;
20300 }
20301
20302
20303 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20304 PyObject *resultobj = 0;
20305 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20306 wxString *arg2 = 0 ;
20307 bool arg3 = (bool) false ;
20308 bool result;
20309 void *argp1 = 0 ;
20310 int res1 = 0 ;
20311 bool temp2 = false ;
20312 bool val3 ;
20313 int ecode3 = 0 ;
20314 PyObject * obj0 = 0 ;
20315 PyObject * obj1 = 0 ;
20316 PyObject * obj2 = 0 ;
20317 char * kwnames[] = {
20318 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20319 };
20320
20321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20323 if (!SWIG_IsOK(res1)) {
20324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20325 }
20326 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20327 {
20328 arg2 = wxString_in_helper(obj1);
20329 if (arg2 == NULL) SWIG_fail;
20330 temp2 = true;
20331 }
20332 if (obj2) {
20333 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20334 if (!SWIG_IsOK(ecode3)) {
20335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20336 }
20337 arg3 = static_cast< bool >(val3);
20338 }
20339 {
20340 PyThreadState* __tstate = wxPyBeginAllowThreads();
20341 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20342 wxPyEndAllowThreads(__tstate);
20343 if (PyErr_Occurred()) SWIG_fail;
20344 }
20345 {
20346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20347 }
20348 {
20349 if (temp2)
20350 delete arg2;
20351 }
20352 return resultobj;
20353 fail:
20354 {
20355 if (temp2)
20356 delete arg2;
20357 }
20358 return NULL;
20359 }
20360
20361
20362 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20363 PyObject *resultobj = 0;
20364 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20365 wxString *arg2 = 0 ;
20366 wxString *arg3 = 0 ;
20367 bool result;
20368 void *argp1 = 0 ;
20369 int res1 = 0 ;
20370 bool temp2 = false ;
20371 bool temp3 = false ;
20372 PyObject * obj0 = 0 ;
20373 PyObject * obj1 = 0 ;
20374 PyObject * obj2 = 0 ;
20375 char * kwnames[] = {
20376 (char *) "self",(char *) "key",(char *) "value", NULL
20377 };
20378
20379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20381 if (!SWIG_IsOK(res1)) {
20382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20383 }
20384 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20385 {
20386 arg2 = wxString_in_helper(obj1);
20387 if (arg2 == NULL) SWIG_fail;
20388 temp2 = true;
20389 }
20390 {
20391 arg3 = wxString_in_helper(obj2);
20392 if (arg3 == NULL) SWIG_fail;
20393 temp3 = true;
20394 }
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 {
20402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20403 }
20404 {
20405 if (temp2)
20406 delete arg2;
20407 }
20408 {
20409 if (temp3)
20410 delete arg3;
20411 }
20412 return resultobj;
20413 fail:
20414 {
20415 if (temp2)
20416 delete arg2;
20417 }
20418 {
20419 if (temp3)
20420 delete arg3;
20421 }
20422 return NULL;
20423 }
20424
20425
20426 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20427 PyObject *resultobj = 0;
20428 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20429 wxString *arg2 = 0 ;
20430 long arg3 ;
20431 bool result;
20432 void *argp1 = 0 ;
20433 int res1 = 0 ;
20434 bool temp2 = false ;
20435 long val3 ;
20436 int ecode3 = 0 ;
20437 PyObject * obj0 = 0 ;
20438 PyObject * obj1 = 0 ;
20439 PyObject * obj2 = 0 ;
20440 char * kwnames[] = {
20441 (char *) "self",(char *) "key",(char *) "value", NULL
20442 };
20443
20444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20446 if (!SWIG_IsOK(res1)) {
20447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20448 }
20449 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20450 {
20451 arg2 = wxString_in_helper(obj1);
20452 if (arg2 == NULL) SWIG_fail;
20453 temp2 = true;
20454 }
20455 ecode3 = SWIG_AsVal_long(obj2, &val3);
20456 if (!SWIG_IsOK(ecode3)) {
20457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20458 }
20459 arg3 = static_cast< long >(val3);
20460 {
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 {
20470 if (temp2)
20471 delete arg2;
20472 }
20473 return resultobj;
20474 fail:
20475 {
20476 if (temp2)
20477 delete arg2;
20478 }
20479 return NULL;
20480 }
20481
20482
20483 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20484 PyObject *resultobj = 0;
20485 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20486 wxString *arg2 = 0 ;
20487 double arg3 ;
20488 bool result;
20489 void *argp1 = 0 ;
20490 int res1 = 0 ;
20491 bool temp2 = false ;
20492 double val3 ;
20493 int ecode3 = 0 ;
20494 PyObject * obj0 = 0 ;
20495 PyObject * obj1 = 0 ;
20496 PyObject * obj2 = 0 ;
20497 char * kwnames[] = {
20498 (char *) "self",(char *) "key",(char *) "value", NULL
20499 };
20500
20501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20503 if (!SWIG_IsOK(res1)) {
20504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20505 }
20506 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20507 {
20508 arg2 = wxString_in_helper(obj1);
20509 if (arg2 == NULL) SWIG_fail;
20510 temp2 = true;
20511 }
20512 ecode3 = SWIG_AsVal_double(obj2, &val3);
20513 if (!SWIG_IsOK(ecode3)) {
20514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20515 }
20516 arg3 = static_cast< double >(val3);
20517 {
20518 PyThreadState* __tstate = wxPyBeginAllowThreads();
20519 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20520 wxPyEndAllowThreads(__tstate);
20521 if (PyErr_Occurred()) SWIG_fail;
20522 }
20523 {
20524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20525 }
20526 {
20527 if (temp2)
20528 delete arg2;
20529 }
20530 return resultobj;
20531 fail:
20532 {
20533 if (temp2)
20534 delete arg2;
20535 }
20536 return NULL;
20537 }
20538
20539
20540 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20541 PyObject *resultobj = 0;
20542 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20543 wxString *arg2 = 0 ;
20544 bool arg3 ;
20545 bool result;
20546 void *argp1 = 0 ;
20547 int res1 = 0 ;
20548 bool temp2 = false ;
20549 bool val3 ;
20550 int ecode3 = 0 ;
20551 PyObject * obj0 = 0 ;
20552 PyObject * obj1 = 0 ;
20553 PyObject * obj2 = 0 ;
20554 char * kwnames[] = {
20555 (char *) "self",(char *) "key",(char *) "value", NULL
20556 };
20557
20558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20560 if (!SWIG_IsOK(res1)) {
20561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20562 }
20563 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20564 {
20565 arg2 = wxString_in_helper(obj1);
20566 if (arg2 == NULL) SWIG_fail;
20567 temp2 = true;
20568 }
20569 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20570 if (!SWIG_IsOK(ecode3)) {
20571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20572 }
20573 arg3 = static_cast< bool >(val3);
20574 {
20575 PyThreadState* __tstate = wxPyBeginAllowThreads();
20576 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20577 wxPyEndAllowThreads(__tstate);
20578 if (PyErr_Occurred()) SWIG_fail;
20579 }
20580 {
20581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20582 }
20583 {
20584 if (temp2)
20585 delete arg2;
20586 }
20587 return resultobj;
20588 fail:
20589 {
20590 if (temp2)
20591 delete arg2;
20592 }
20593 return NULL;
20594 }
20595
20596
20597 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20598 PyObject *resultobj = 0;
20599 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20600 bool arg2 = (bool) false ;
20601 bool result;
20602 void *argp1 = 0 ;
20603 int res1 = 0 ;
20604 bool val2 ;
20605 int ecode2 = 0 ;
20606 PyObject * obj0 = 0 ;
20607 PyObject * obj1 = 0 ;
20608 char * kwnames[] = {
20609 (char *) "self",(char *) "currentOnly", NULL
20610 };
20611
20612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20614 if (!SWIG_IsOK(res1)) {
20615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20616 }
20617 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20618 if (obj1) {
20619 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20620 if (!SWIG_IsOK(ecode2)) {
20621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20622 }
20623 arg2 = static_cast< bool >(val2);
20624 }
20625 {
20626 PyThreadState* __tstate = wxPyBeginAllowThreads();
20627 result = (bool)(arg1)->Flush(arg2);
20628 wxPyEndAllowThreads(__tstate);
20629 if (PyErr_Occurred()) SWIG_fail;
20630 }
20631 {
20632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20633 }
20634 return resultobj;
20635 fail:
20636 return NULL;
20637 }
20638
20639
20640 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20641 PyObject *resultobj = 0;
20642 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20643 wxString *arg2 = 0 ;
20644 wxString *arg3 = 0 ;
20645 bool result;
20646 void *argp1 = 0 ;
20647 int res1 = 0 ;
20648 bool temp2 = false ;
20649 bool temp3 = false ;
20650 PyObject * obj0 = 0 ;
20651 PyObject * obj1 = 0 ;
20652 PyObject * obj2 = 0 ;
20653 char * kwnames[] = {
20654 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20655 };
20656
20657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20659 if (!SWIG_IsOK(res1)) {
20660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20661 }
20662 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20663 {
20664 arg2 = wxString_in_helper(obj1);
20665 if (arg2 == NULL) SWIG_fail;
20666 temp2 = true;
20667 }
20668 {
20669 arg3 = wxString_in_helper(obj2);
20670 if (arg3 == NULL) SWIG_fail;
20671 temp3 = true;
20672 }
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 {
20680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20681 }
20682 {
20683 if (temp2)
20684 delete arg2;
20685 }
20686 {
20687 if (temp3)
20688 delete arg3;
20689 }
20690 return resultobj;
20691 fail:
20692 {
20693 if (temp2)
20694 delete arg2;
20695 }
20696 {
20697 if (temp3)
20698 delete arg3;
20699 }
20700 return NULL;
20701 }
20702
20703
20704 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20705 PyObject *resultobj = 0;
20706 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20707 wxString *arg2 = 0 ;
20708 wxString *arg3 = 0 ;
20709 bool result;
20710 void *argp1 = 0 ;
20711 int res1 = 0 ;
20712 bool temp2 = false ;
20713 bool temp3 = false ;
20714 PyObject * obj0 = 0 ;
20715 PyObject * obj1 = 0 ;
20716 PyObject * obj2 = 0 ;
20717 char * kwnames[] = {
20718 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20719 };
20720
20721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20723 if (!SWIG_IsOK(res1)) {
20724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20725 }
20726 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20727 {
20728 arg2 = wxString_in_helper(obj1);
20729 if (arg2 == NULL) SWIG_fail;
20730 temp2 = true;
20731 }
20732 {
20733 arg3 = wxString_in_helper(obj2);
20734 if (arg3 == NULL) SWIG_fail;
20735 temp3 = true;
20736 }
20737 {
20738 PyThreadState* __tstate = wxPyBeginAllowThreads();
20739 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20740 wxPyEndAllowThreads(__tstate);
20741 if (PyErr_Occurred()) SWIG_fail;
20742 }
20743 {
20744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20745 }
20746 {
20747 if (temp2)
20748 delete arg2;
20749 }
20750 {
20751 if (temp3)
20752 delete arg3;
20753 }
20754 return resultobj;
20755 fail:
20756 {
20757 if (temp2)
20758 delete arg2;
20759 }
20760 {
20761 if (temp3)
20762 delete arg3;
20763 }
20764 return NULL;
20765 }
20766
20767
20768 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20769 PyObject *resultobj = 0;
20770 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20771 wxString *arg2 = 0 ;
20772 bool arg3 = (bool) true ;
20773 bool result;
20774 void *argp1 = 0 ;
20775 int res1 = 0 ;
20776 bool temp2 = false ;
20777 bool val3 ;
20778 int ecode3 = 0 ;
20779 PyObject * obj0 = 0 ;
20780 PyObject * obj1 = 0 ;
20781 PyObject * obj2 = 0 ;
20782 char * kwnames[] = {
20783 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20784 };
20785
20786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20788 if (!SWIG_IsOK(res1)) {
20789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20790 }
20791 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20792 {
20793 arg2 = wxString_in_helper(obj1);
20794 if (arg2 == NULL) SWIG_fail;
20795 temp2 = true;
20796 }
20797 if (obj2) {
20798 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20799 if (!SWIG_IsOK(ecode3)) {
20800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20801 }
20802 arg3 = static_cast< bool >(val3);
20803 }
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 {
20811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20812 }
20813 {
20814 if (temp2)
20815 delete arg2;
20816 }
20817 return resultobj;
20818 fail:
20819 {
20820 if (temp2)
20821 delete arg2;
20822 }
20823 return NULL;
20824 }
20825
20826
20827 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20828 PyObject *resultobj = 0;
20829 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20830 wxString *arg2 = 0 ;
20831 bool result;
20832 void *argp1 = 0 ;
20833 int res1 = 0 ;
20834 bool temp2 = false ;
20835 PyObject * obj0 = 0 ;
20836 PyObject * obj1 = 0 ;
20837 char * kwnames[] = {
20838 (char *) "self",(char *) "key", NULL
20839 };
20840
20841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20843 if (!SWIG_IsOK(res1)) {
20844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20845 }
20846 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20847 {
20848 arg2 = wxString_in_helper(obj1);
20849 if (arg2 == NULL) SWIG_fail;
20850 temp2 = true;
20851 }
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20855 wxPyEndAllowThreads(__tstate);
20856 if (PyErr_Occurred()) SWIG_fail;
20857 }
20858 {
20859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20860 }
20861 {
20862 if (temp2)
20863 delete arg2;
20864 }
20865 return resultobj;
20866 fail:
20867 {
20868 if (temp2)
20869 delete arg2;
20870 }
20871 return NULL;
20872 }
20873
20874
20875 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20876 PyObject *resultobj = 0;
20877 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20878 bool result;
20879 void *argp1 = 0 ;
20880 int res1 = 0 ;
20881 PyObject *swig_obj[1] ;
20882
20883 if (!args) SWIG_fail;
20884 swig_obj[0] = args;
20885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20886 if (!SWIG_IsOK(res1)) {
20887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20888 }
20889 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20890 {
20891 PyThreadState* __tstate = wxPyBeginAllowThreads();
20892 result = (bool)(arg1)->DeleteAll();
20893 wxPyEndAllowThreads(__tstate);
20894 if (PyErr_Occurred()) SWIG_fail;
20895 }
20896 {
20897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20898 }
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20906 PyObject *resultobj = 0;
20907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20908 bool arg2 = (bool) true ;
20909 void *argp1 = 0 ;
20910 int res1 = 0 ;
20911 bool val2 ;
20912 int ecode2 = 0 ;
20913 PyObject * obj0 = 0 ;
20914 PyObject * obj1 = 0 ;
20915 char * kwnames[] = {
20916 (char *) "self",(char *) "doIt", NULL
20917 };
20918
20919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20921 if (!SWIG_IsOK(res1)) {
20922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20923 }
20924 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20925 if (obj1) {
20926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20927 if (!SWIG_IsOK(ecode2)) {
20928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20929 }
20930 arg2 = static_cast< bool >(val2);
20931 }
20932 {
20933 PyThreadState* __tstate = wxPyBeginAllowThreads();
20934 (arg1)->SetExpandEnvVars(arg2);
20935 wxPyEndAllowThreads(__tstate);
20936 if (PyErr_Occurred()) SWIG_fail;
20937 }
20938 resultobj = SWIG_Py_Void();
20939 return resultobj;
20940 fail:
20941 return NULL;
20942 }
20943
20944
20945 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20946 PyObject *resultobj = 0;
20947 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20948 bool result;
20949 void *argp1 = 0 ;
20950 int res1 = 0 ;
20951 PyObject *swig_obj[1] ;
20952
20953 if (!args) SWIG_fail;
20954 swig_obj[0] = args;
20955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20956 if (!SWIG_IsOK(res1)) {
20957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20958 }
20959 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20960 {
20961 PyThreadState* __tstate = wxPyBeginAllowThreads();
20962 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20963 wxPyEndAllowThreads(__tstate);
20964 if (PyErr_Occurred()) SWIG_fail;
20965 }
20966 {
20967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20968 }
20969 return resultobj;
20970 fail:
20971 return NULL;
20972 }
20973
20974
20975 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20976 PyObject *resultobj = 0;
20977 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20978 bool arg2 = (bool) true ;
20979 void *argp1 = 0 ;
20980 int res1 = 0 ;
20981 bool val2 ;
20982 int ecode2 = 0 ;
20983 PyObject * obj0 = 0 ;
20984 PyObject * obj1 = 0 ;
20985 char * kwnames[] = {
20986 (char *) "self",(char *) "doIt", NULL
20987 };
20988
20989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
20990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20991 if (!SWIG_IsOK(res1)) {
20992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20993 }
20994 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20995 if (obj1) {
20996 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20997 if (!SWIG_IsOK(ecode2)) {
20998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
20999 }
21000 arg2 = static_cast< bool >(val2);
21001 }
21002 {
21003 PyThreadState* __tstate = wxPyBeginAllowThreads();
21004 (arg1)->SetRecordDefaults(arg2);
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 resultobj = SWIG_Py_Void();
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21016 PyObject *resultobj = 0;
21017 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21018 bool result;
21019 void *argp1 = 0 ;
21020 int res1 = 0 ;
21021 PyObject *swig_obj[1] ;
21022
21023 if (!args) SWIG_fail;
21024 swig_obj[0] = args;
21025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21026 if (!SWIG_IsOK(res1)) {
21027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21028 }
21029 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21030 {
21031 PyThreadState* __tstate = wxPyBeginAllowThreads();
21032 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 {
21037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21038 }
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21046 PyObject *resultobj = 0;
21047 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21048 wxString *arg2 = 0 ;
21049 wxString result;
21050 void *argp1 = 0 ;
21051 int res1 = 0 ;
21052 bool temp2 = false ;
21053 PyObject * obj0 = 0 ;
21054 PyObject * obj1 = 0 ;
21055 char * kwnames[] = {
21056 (char *) "self",(char *) "str", NULL
21057 };
21058
21059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21061 if (!SWIG_IsOK(res1)) {
21062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21063 }
21064 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21065 {
21066 arg2 = wxString_in_helper(obj1);
21067 if (arg2 == NULL) SWIG_fail;
21068 temp2 = true;
21069 }
21070 {
21071 PyThreadState* __tstate = wxPyBeginAllowThreads();
21072 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21073 wxPyEndAllowThreads(__tstate);
21074 if (PyErr_Occurred()) SWIG_fail;
21075 }
21076 {
21077 #if wxUSE_UNICODE
21078 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21079 #else
21080 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21081 #endif
21082 }
21083 {
21084 if (temp2)
21085 delete arg2;
21086 }
21087 return resultobj;
21088 fail:
21089 {
21090 if (temp2)
21091 delete arg2;
21092 }
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21098 PyObject *resultobj = 0;
21099 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21100 wxString result;
21101 void *argp1 = 0 ;
21102 int res1 = 0 ;
21103 PyObject *swig_obj[1] ;
21104
21105 if (!args) SWIG_fail;
21106 swig_obj[0] = args;
21107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21108 if (!SWIG_IsOK(res1)) {
21109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21110 }
21111 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21112 {
21113 PyThreadState* __tstate = wxPyBeginAllowThreads();
21114 result = ((wxConfigBase const *)arg1)->GetAppName();
21115 wxPyEndAllowThreads(__tstate);
21116 if (PyErr_Occurred()) SWIG_fail;
21117 }
21118 {
21119 #if wxUSE_UNICODE
21120 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21121 #else
21122 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21123 #endif
21124 }
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21132 PyObject *resultobj = 0;
21133 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21134 wxString result;
21135 void *argp1 = 0 ;
21136 int res1 = 0 ;
21137 PyObject *swig_obj[1] ;
21138
21139 if (!args) SWIG_fail;
21140 swig_obj[0] = args;
21141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21144 }
21145 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = ((wxConfigBase const *)arg1)->GetVendorName();
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 {
21153 #if wxUSE_UNICODE
21154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21155 #else
21156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21157 #endif
21158 }
21159 return resultobj;
21160 fail:
21161 return NULL;
21162 }
21163
21164
21165 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21166 PyObject *resultobj = 0;
21167 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21168 wxString *arg2 = 0 ;
21169 void *argp1 = 0 ;
21170 int res1 = 0 ;
21171 bool temp2 = false ;
21172 PyObject * obj0 = 0 ;
21173 PyObject * obj1 = 0 ;
21174 char * kwnames[] = {
21175 (char *) "self",(char *) "appName", NULL
21176 };
21177
21178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21180 if (!SWIG_IsOK(res1)) {
21181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21182 }
21183 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21184 {
21185 arg2 = wxString_in_helper(obj1);
21186 if (arg2 == NULL) SWIG_fail;
21187 temp2 = true;
21188 }
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 (arg1)->SetAppName((wxString const &)*arg2);
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 resultobj = SWIG_Py_Void();
21196 {
21197 if (temp2)
21198 delete arg2;
21199 }
21200 return resultobj;
21201 fail:
21202 {
21203 if (temp2)
21204 delete arg2;
21205 }
21206 return NULL;
21207 }
21208
21209
21210 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21211 PyObject *resultobj = 0;
21212 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21213 wxString *arg2 = 0 ;
21214 void *argp1 = 0 ;
21215 int res1 = 0 ;
21216 bool temp2 = false ;
21217 PyObject * obj0 = 0 ;
21218 PyObject * obj1 = 0 ;
21219 char * kwnames[] = {
21220 (char *) "self",(char *) "vendorName", NULL
21221 };
21222
21223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21225 if (!SWIG_IsOK(res1)) {
21226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21227 }
21228 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21229 {
21230 arg2 = wxString_in_helper(obj1);
21231 if (arg2 == NULL) SWIG_fail;
21232 temp2 = true;
21233 }
21234 {
21235 PyThreadState* __tstate = wxPyBeginAllowThreads();
21236 (arg1)->SetVendorName((wxString const &)*arg2);
21237 wxPyEndAllowThreads(__tstate);
21238 if (PyErr_Occurred()) SWIG_fail;
21239 }
21240 resultobj = SWIG_Py_Void();
21241 {
21242 if (temp2)
21243 delete arg2;
21244 }
21245 return resultobj;
21246 fail:
21247 {
21248 if (temp2)
21249 delete arg2;
21250 }
21251 return NULL;
21252 }
21253
21254
21255 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21256 PyObject *resultobj = 0;
21257 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21258 long arg2 ;
21259 void *argp1 = 0 ;
21260 int res1 = 0 ;
21261 long val2 ;
21262 int ecode2 = 0 ;
21263 PyObject * obj0 = 0 ;
21264 PyObject * obj1 = 0 ;
21265 char * kwnames[] = {
21266 (char *) "self",(char *) "style", NULL
21267 };
21268
21269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21271 if (!SWIG_IsOK(res1)) {
21272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21273 }
21274 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21275 ecode2 = SWIG_AsVal_long(obj1, &val2);
21276 if (!SWIG_IsOK(ecode2)) {
21277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21278 }
21279 arg2 = static_cast< long >(val2);
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 (arg1)->SetStyle(arg2);
21283 wxPyEndAllowThreads(__tstate);
21284 if (PyErr_Occurred()) SWIG_fail;
21285 }
21286 resultobj = SWIG_Py_Void();
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21294 PyObject *resultobj = 0;
21295 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21296 long result;
21297 void *argp1 = 0 ;
21298 int res1 = 0 ;
21299 PyObject *swig_obj[1] ;
21300
21301 if (!args) SWIG_fail;
21302 swig_obj[0] = args;
21303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21304 if (!SWIG_IsOK(res1)) {
21305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21306 }
21307 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21311 wxPyEndAllowThreads(__tstate);
21312 if (PyErr_Occurred()) SWIG_fail;
21313 }
21314 resultobj = SWIG_From_long(static_cast< long >(result));
21315 return resultobj;
21316 fail:
21317 return NULL;
21318 }
21319
21320
21321 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21322 PyObject *obj;
21323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21324 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21325 return SWIG_Py_Void();
21326 }
21327
21328 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21329 PyObject *resultobj = 0;
21330 wxString const &arg1_defvalue = wxPyEmptyString ;
21331 wxString *arg1 = (wxString *) &arg1_defvalue ;
21332 wxString const &arg2_defvalue = wxPyEmptyString ;
21333 wxString *arg2 = (wxString *) &arg2_defvalue ;
21334 wxString const &arg3_defvalue = wxPyEmptyString ;
21335 wxString *arg3 = (wxString *) &arg3_defvalue ;
21336 wxString const &arg4_defvalue = wxPyEmptyString ;
21337 wxString *arg4 = (wxString *) &arg4_defvalue ;
21338 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21339 wxConfig *result = 0 ;
21340 bool temp1 = false ;
21341 bool temp2 = false ;
21342 bool temp3 = false ;
21343 bool temp4 = false ;
21344 long val5 ;
21345 int ecode5 = 0 ;
21346 PyObject * obj0 = 0 ;
21347 PyObject * obj1 = 0 ;
21348 PyObject * obj2 = 0 ;
21349 PyObject * obj3 = 0 ;
21350 PyObject * obj4 = 0 ;
21351 char * kwnames[] = {
21352 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21353 };
21354
21355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21356 if (obj0) {
21357 {
21358 arg1 = wxString_in_helper(obj0);
21359 if (arg1 == NULL) SWIG_fail;
21360 temp1 = true;
21361 }
21362 }
21363 if (obj1) {
21364 {
21365 arg2 = wxString_in_helper(obj1);
21366 if (arg2 == NULL) SWIG_fail;
21367 temp2 = true;
21368 }
21369 }
21370 if (obj2) {
21371 {
21372 arg3 = wxString_in_helper(obj2);
21373 if (arg3 == NULL) SWIG_fail;
21374 temp3 = true;
21375 }
21376 }
21377 if (obj3) {
21378 {
21379 arg4 = wxString_in_helper(obj3);
21380 if (arg4 == NULL) SWIG_fail;
21381 temp4 = true;
21382 }
21383 }
21384 if (obj4) {
21385 ecode5 = SWIG_AsVal_long(obj4, &val5);
21386 if (!SWIG_IsOK(ecode5)) {
21387 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21388 }
21389 arg5 = static_cast< long >(val5);
21390 }
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21394 wxPyEndAllowThreads(__tstate);
21395 if (PyErr_Occurred()) SWIG_fail;
21396 }
21397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21398 {
21399 if (temp1)
21400 delete arg1;
21401 }
21402 {
21403 if (temp2)
21404 delete arg2;
21405 }
21406 {
21407 if (temp3)
21408 delete arg3;
21409 }
21410 {
21411 if (temp4)
21412 delete arg4;
21413 }
21414 return resultobj;
21415 fail:
21416 {
21417 if (temp1)
21418 delete arg1;
21419 }
21420 {
21421 if (temp2)
21422 delete arg2;
21423 }
21424 {
21425 if (temp3)
21426 delete arg3;
21427 }
21428 {
21429 if (temp4)
21430 delete arg4;
21431 }
21432 return NULL;
21433 }
21434
21435
21436 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21437 PyObject *resultobj = 0;
21438 wxConfig *arg1 = (wxConfig *) 0 ;
21439 void *argp1 = 0 ;
21440 int res1 = 0 ;
21441 PyObject *swig_obj[1] ;
21442
21443 if (!args) SWIG_fail;
21444 swig_obj[0] = args;
21445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21446 if (!SWIG_IsOK(res1)) {
21447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21448 }
21449 arg1 = reinterpret_cast< wxConfig * >(argp1);
21450 {
21451 PyThreadState* __tstate = wxPyBeginAllowThreads();
21452 delete arg1;
21453
21454 wxPyEndAllowThreads(__tstate);
21455 if (PyErr_Occurred()) SWIG_fail;
21456 }
21457 resultobj = SWIG_Py_Void();
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21465 PyObject *obj;
21466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21467 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21468 return SWIG_Py_Void();
21469 }
21470
21471 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21472 return SWIG_Python_InitShadowInstance(args);
21473 }
21474
21475 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21476 PyObject *resultobj = 0;
21477 wxString const &arg1_defvalue = wxPyEmptyString ;
21478 wxString *arg1 = (wxString *) &arg1_defvalue ;
21479 wxString const &arg2_defvalue = wxPyEmptyString ;
21480 wxString *arg2 = (wxString *) &arg2_defvalue ;
21481 wxString const &arg3_defvalue = wxPyEmptyString ;
21482 wxString *arg3 = (wxString *) &arg3_defvalue ;
21483 wxString const &arg4_defvalue = wxPyEmptyString ;
21484 wxString *arg4 = (wxString *) &arg4_defvalue ;
21485 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21486 wxFileConfig *result = 0 ;
21487 bool temp1 = false ;
21488 bool temp2 = false ;
21489 bool temp3 = false ;
21490 bool temp4 = false ;
21491 long val5 ;
21492 int ecode5 = 0 ;
21493 PyObject * obj0 = 0 ;
21494 PyObject * obj1 = 0 ;
21495 PyObject * obj2 = 0 ;
21496 PyObject * obj3 = 0 ;
21497 PyObject * obj4 = 0 ;
21498 char * kwnames[] = {
21499 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21500 };
21501
21502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21503 if (obj0) {
21504 {
21505 arg1 = wxString_in_helper(obj0);
21506 if (arg1 == NULL) SWIG_fail;
21507 temp1 = true;
21508 }
21509 }
21510 if (obj1) {
21511 {
21512 arg2 = wxString_in_helper(obj1);
21513 if (arg2 == NULL) SWIG_fail;
21514 temp2 = true;
21515 }
21516 }
21517 if (obj2) {
21518 {
21519 arg3 = wxString_in_helper(obj2);
21520 if (arg3 == NULL) SWIG_fail;
21521 temp3 = true;
21522 }
21523 }
21524 if (obj3) {
21525 {
21526 arg4 = wxString_in_helper(obj3);
21527 if (arg4 == NULL) SWIG_fail;
21528 temp4 = true;
21529 }
21530 }
21531 if (obj4) {
21532 ecode5 = SWIG_AsVal_long(obj4, &val5);
21533 if (!SWIG_IsOK(ecode5)) {
21534 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21535 }
21536 arg5 = static_cast< long >(val5);
21537 }
21538 {
21539 PyThreadState* __tstate = wxPyBeginAllowThreads();
21540 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21541 wxPyEndAllowThreads(__tstate);
21542 if (PyErr_Occurred()) SWIG_fail;
21543 }
21544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21545 {
21546 if (temp1)
21547 delete arg1;
21548 }
21549 {
21550 if (temp2)
21551 delete arg2;
21552 }
21553 {
21554 if (temp3)
21555 delete arg3;
21556 }
21557 {
21558 if (temp4)
21559 delete arg4;
21560 }
21561 return resultobj;
21562 fail:
21563 {
21564 if (temp1)
21565 delete arg1;
21566 }
21567 {
21568 if (temp2)
21569 delete arg2;
21570 }
21571 {
21572 if (temp3)
21573 delete arg3;
21574 }
21575 {
21576 if (temp4)
21577 delete arg4;
21578 }
21579 return NULL;
21580 }
21581
21582
21583 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21584 PyObject *resultobj = 0;
21585 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21586 void *argp1 = 0 ;
21587 int res1 = 0 ;
21588 PyObject *swig_obj[1] ;
21589
21590 if (!args) SWIG_fail;
21591 swig_obj[0] = args;
21592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21593 if (!SWIG_IsOK(res1)) {
21594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21595 }
21596 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 delete arg1;
21600
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 resultobj = SWIG_Py_Void();
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21612 PyObject *obj;
21613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21614 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21615 return SWIG_Py_Void();
21616 }
21617
21618 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21619 return SWIG_Python_InitShadowInstance(args);
21620 }
21621
21622 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21623 PyObject *resultobj = 0;
21624 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21625 wxString *arg2 = 0 ;
21626 wxConfigPathChanger *result = 0 ;
21627 void *argp1 = 0 ;
21628 int res1 = 0 ;
21629 bool temp2 = false ;
21630 PyObject * obj0 = 0 ;
21631 PyObject * obj1 = 0 ;
21632 char * kwnames[] = {
21633 (char *) "config",(char *) "entry", NULL
21634 };
21635
21636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21638 if (!SWIG_IsOK(res1)) {
21639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21640 }
21641 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21642 {
21643 arg2 = wxString_in_helper(obj1);
21644 if (arg2 == NULL) SWIG_fail;
21645 temp2 = true;
21646 }
21647 {
21648 PyThreadState* __tstate = wxPyBeginAllowThreads();
21649 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21650 wxPyEndAllowThreads(__tstate);
21651 if (PyErr_Occurred()) SWIG_fail;
21652 }
21653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21654 {
21655 if (temp2)
21656 delete arg2;
21657 }
21658 return resultobj;
21659 fail:
21660 {
21661 if (temp2)
21662 delete arg2;
21663 }
21664 return NULL;
21665 }
21666
21667
21668 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21669 PyObject *resultobj = 0;
21670 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21671 void *argp1 = 0 ;
21672 int res1 = 0 ;
21673 PyObject *swig_obj[1] ;
21674
21675 if (!args) SWIG_fail;
21676 swig_obj[0] = args;
21677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21678 if (!SWIG_IsOK(res1)) {
21679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21680 }
21681 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21682 {
21683 PyThreadState* __tstate = wxPyBeginAllowThreads();
21684 delete arg1;
21685
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 resultobj = SWIG_Py_Void();
21690 return resultobj;
21691 fail:
21692 return NULL;
21693 }
21694
21695
21696 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21697 PyObject *resultobj = 0;
21698 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21699 wxString *result = 0 ;
21700 void *argp1 = 0 ;
21701 int res1 = 0 ;
21702 PyObject *swig_obj[1] ;
21703
21704 if (!args) SWIG_fail;
21705 swig_obj[0] = args;
21706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21707 if (!SWIG_IsOK(res1)) {
21708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21709 }
21710 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 {
21714 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21715 result = (wxString *) &_result_ref;
21716 }
21717 wxPyEndAllowThreads(__tstate);
21718 if (PyErr_Occurred()) SWIG_fail;
21719 }
21720 {
21721 #if wxUSE_UNICODE
21722 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21723 #else
21724 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21725 #endif
21726 }
21727 return resultobj;
21728 fail:
21729 return NULL;
21730 }
21731
21732
21733 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21734 PyObject *obj;
21735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21736 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21737 return SWIG_Py_Void();
21738 }
21739
21740 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21741 return SWIG_Python_InitShadowInstance(args);
21742 }
21743
21744 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj = 0;
21746 wxString *arg1 = 0 ;
21747 wxString result;
21748 bool temp1 = false ;
21749 PyObject * obj0 = 0 ;
21750 char * kwnames[] = {
21751 (char *) "sz", NULL
21752 };
21753
21754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21755 {
21756 arg1 = wxString_in_helper(obj0);
21757 if (arg1 == NULL) SWIG_fail;
21758 temp1 = true;
21759 }
21760 {
21761 PyThreadState* __tstate = wxPyBeginAllowThreads();
21762 result = wxExpandEnvVars((wxString const &)*arg1);
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 {
21767 #if wxUSE_UNICODE
21768 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21769 #else
21770 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21771 #endif
21772 }
21773 {
21774 if (temp1)
21775 delete arg1;
21776 }
21777 return resultobj;
21778 fail:
21779 {
21780 if (temp1)
21781 delete arg1;
21782 }
21783 return NULL;
21784 }
21785
21786
21787 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21788 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21789 return 1;
21790 }
21791
21792
21793 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21794 PyObject *pyobj = 0;
21795
21796 {
21797 #if wxUSE_UNICODE
21798 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21799 #else
21800 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21801 #endif
21802 }
21803 return pyobj;
21804 }
21805
21806
21807 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21808 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21809 return 1;
21810 }
21811
21812
21813 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21814 PyObject *pyobj = 0;
21815
21816 {
21817 #if wxUSE_UNICODE
21818 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21819 #else
21820 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21821 #endif
21822 }
21823 return pyobj;
21824 }
21825
21826
21827 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21828 PyObject *resultobj = 0;
21829 wxDateTime::Country arg1 ;
21830 int val1 ;
21831 int ecode1 = 0 ;
21832 PyObject * obj0 = 0 ;
21833 char * kwnames[] = {
21834 (char *) "country", NULL
21835 };
21836
21837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21838 ecode1 = SWIG_AsVal_int(obj0, &val1);
21839 if (!SWIG_IsOK(ecode1)) {
21840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21841 }
21842 arg1 = static_cast< wxDateTime::Country >(val1);
21843 {
21844 PyThreadState* __tstate = wxPyBeginAllowThreads();
21845 wxDateTime::SetCountry(arg1);
21846 wxPyEndAllowThreads(__tstate);
21847 if (PyErr_Occurred()) SWIG_fail;
21848 }
21849 resultobj = SWIG_Py_Void();
21850 return resultobj;
21851 fail:
21852 return NULL;
21853 }
21854
21855
21856 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21857 PyObject *resultobj = 0;
21858 wxDateTime::Country result;
21859
21860 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21861 {
21862 PyThreadState* __tstate = wxPyBeginAllowThreads();
21863 result = (wxDateTime::Country)wxDateTime::GetCountry();
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 resultobj = SWIG_From_int(static_cast< int >(result));
21868 return resultobj;
21869 fail:
21870 return NULL;
21871 }
21872
21873
21874 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21875 PyObject *resultobj = 0;
21876 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21877 bool result;
21878 int val1 ;
21879 int ecode1 = 0 ;
21880 PyObject * obj0 = 0 ;
21881 char * kwnames[] = {
21882 (char *) "country", NULL
21883 };
21884
21885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21886 if (obj0) {
21887 ecode1 = SWIG_AsVal_int(obj0, &val1);
21888 if (!SWIG_IsOK(ecode1)) {
21889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21890 }
21891 arg1 = static_cast< wxDateTime::Country >(val1);
21892 }
21893 {
21894 PyThreadState* __tstate = wxPyBeginAllowThreads();
21895 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21896 wxPyEndAllowThreads(__tstate);
21897 if (PyErr_Occurred()) SWIG_fail;
21898 }
21899 {
21900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21901 }
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21909 PyObject *resultobj = 0;
21910 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21911 int result;
21912 int val1 ;
21913 int ecode1 = 0 ;
21914 PyObject * obj0 = 0 ;
21915 char * kwnames[] = {
21916 (char *) "cal", NULL
21917 };
21918
21919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21920 if (obj0) {
21921 ecode1 = SWIG_AsVal_int(obj0, &val1);
21922 if (!SWIG_IsOK(ecode1)) {
21923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21924 }
21925 arg1 = static_cast< wxDateTime::Calendar >(val1);
21926 }
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 result = (int)wxDateTime::GetCurrentYear(arg1);
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 resultobj = SWIG_From_int(static_cast< int >(result));
21934 return resultobj;
21935 fail:
21936 return NULL;
21937 }
21938
21939
21940 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21941 PyObject *resultobj = 0;
21942 int arg1 ;
21943 int result;
21944 int val1 ;
21945 int ecode1 = 0 ;
21946 PyObject * obj0 = 0 ;
21947 char * kwnames[] = {
21948 (char *) "year", NULL
21949 };
21950
21951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21952 ecode1 = SWIG_AsVal_int(obj0, &val1);
21953 if (!SWIG_IsOK(ecode1)) {
21954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21955 }
21956 arg1 = static_cast< int >(val1);
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (int)wxDateTime::ConvertYearToBC(arg1);
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 resultobj = SWIG_From_int(static_cast< int >(result));
21964 return resultobj;
21965 fail:
21966 return NULL;
21967 }
21968
21969
21970 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21971 PyObject *resultobj = 0;
21972 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21973 wxDateTime::Month result;
21974 int val1 ;
21975 int ecode1 = 0 ;
21976 PyObject * obj0 = 0 ;
21977 char * kwnames[] = {
21978 (char *) "cal", NULL
21979 };
21980
21981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21982 if (obj0) {
21983 ecode1 = SWIG_AsVal_int(obj0, &val1);
21984 if (!SWIG_IsOK(ecode1)) {
21985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21986 }
21987 arg1 = static_cast< wxDateTime::Calendar >(val1);
21988 }
21989 {
21990 PyThreadState* __tstate = wxPyBeginAllowThreads();
21991 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
21992 wxPyEndAllowThreads(__tstate);
21993 if (PyErr_Occurred()) SWIG_fail;
21994 }
21995 resultobj = SWIG_From_int(static_cast< int >(result));
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22003 PyObject *resultobj = 0;
22004 int arg1 = (int) wxDateTime::Inv_Year ;
22005 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22006 bool result;
22007 int val1 ;
22008 int ecode1 = 0 ;
22009 int val2 ;
22010 int ecode2 = 0 ;
22011 PyObject * obj0 = 0 ;
22012 PyObject * obj1 = 0 ;
22013 char * kwnames[] = {
22014 (char *) "year",(char *) "cal", NULL
22015 };
22016
22017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22018 if (obj0) {
22019 ecode1 = SWIG_AsVal_int(obj0, &val1);
22020 if (!SWIG_IsOK(ecode1)) {
22021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22022 }
22023 arg1 = static_cast< int >(val1);
22024 }
22025 if (obj1) {
22026 ecode2 = SWIG_AsVal_int(obj1, &val2);
22027 if (!SWIG_IsOK(ecode2)) {
22028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22029 }
22030 arg2 = static_cast< wxDateTime::Calendar >(val2);
22031 }
22032 {
22033 PyThreadState* __tstate = wxPyBeginAllowThreads();
22034 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22035 wxPyEndAllowThreads(__tstate);
22036 if (PyErr_Occurred()) SWIG_fail;
22037 }
22038 {
22039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22040 }
22041 return resultobj;
22042 fail:
22043 return NULL;
22044 }
22045
22046
22047 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22048 PyObject *resultobj = 0;
22049 int arg1 = (int) wxDateTime::Inv_Year ;
22050 int result;
22051 int val1 ;
22052 int ecode1 = 0 ;
22053 PyObject * obj0 = 0 ;
22054 char * kwnames[] = {
22055 (char *) "year", NULL
22056 };
22057
22058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22059 if (obj0) {
22060 ecode1 = SWIG_AsVal_int(obj0, &val1);
22061 if (!SWIG_IsOK(ecode1)) {
22062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22063 }
22064 arg1 = static_cast< int >(val1);
22065 }
22066 {
22067 PyThreadState* __tstate = wxPyBeginAllowThreads();
22068 result = (int)wxDateTime::GetCentury(arg1);
22069 wxPyEndAllowThreads(__tstate);
22070 if (PyErr_Occurred()) SWIG_fail;
22071 }
22072 resultobj = SWIG_From_int(static_cast< int >(result));
22073 return resultobj;
22074 fail:
22075 return NULL;
22076 }
22077
22078
22079 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22080 PyObject *resultobj = 0;
22081 int arg1 ;
22082 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22083 int result;
22084 int val1 ;
22085 int ecode1 = 0 ;
22086 int val2 ;
22087 int ecode2 = 0 ;
22088 PyObject * obj0 = 0 ;
22089 PyObject * obj1 = 0 ;
22090 char * kwnames[] = {
22091 (char *) "year",(char *) "cal", NULL
22092 };
22093
22094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22095 ecode1 = SWIG_AsVal_int(obj0, &val1);
22096 if (!SWIG_IsOK(ecode1)) {
22097 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22098 }
22099 arg1 = static_cast< int >(val1);
22100 if (obj1) {
22101 ecode2 = SWIG_AsVal_int(obj1, &val2);
22102 if (!SWIG_IsOK(ecode2)) {
22103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22104 }
22105 arg2 = static_cast< wxDateTime::Calendar >(val2);
22106 }
22107 {
22108 PyThreadState* __tstate = wxPyBeginAllowThreads();
22109 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 resultobj = SWIG_From_int(static_cast< int >(result));
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22121 PyObject *resultobj = 0;
22122 wxDateTime::Month arg1 ;
22123 int arg2 = (int) wxDateTime::Inv_Year ;
22124 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22125 int result;
22126 int val1 ;
22127 int ecode1 = 0 ;
22128 int val2 ;
22129 int ecode2 = 0 ;
22130 int val3 ;
22131 int ecode3 = 0 ;
22132 PyObject * obj0 = 0 ;
22133 PyObject * obj1 = 0 ;
22134 PyObject * obj2 = 0 ;
22135 char * kwnames[] = {
22136 (char *) "month",(char *) "year",(char *) "cal", NULL
22137 };
22138
22139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22140 ecode1 = SWIG_AsVal_int(obj0, &val1);
22141 if (!SWIG_IsOK(ecode1)) {
22142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22143 }
22144 arg1 = static_cast< wxDateTime::Month >(val1);
22145 if (obj1) {
22146 ecode2 = SWIG_AsVal_int(obj1, &val2);
22147 if (!SWIG_IsOK(ecode2)) {
22148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22149 }
22150 arg2 = static_cast< int >(val2);
22151 }
22152 if (obj2) {
22153 ecode3 = SWIG_AsVal_int(obj2, &val3);
22154 if (!SWIG_IsOK(ecode3)) {
22155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22156 }
22157 arg3 = static_cast< wxDateTime::Calendar >(val3);
22158 }
22159 {
22160 PyThreadState* __tstate = wxPyBeginAllowThreads();
22161 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22162 wxPyEndAllowThreads(__tstate);
22163 if (PyErr_Occurred()) SWIG_fail;
22164 }
22165 resultobj = SWIG_From_int(static_cast< int >(result));
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22173 PyObject *resultobj = 0;
22174 wxDateTime::Month arg1 ;
22175 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22176 wxString result;
22177 int val1 ;
22178 int ecode1 = 0 ;
22179 int val2 ;
22180 int ecode2 = 0 ;
22181 PyObject * obj0 = 0 ;
22182 PyObject * obj1 = 0 ;
22183 char * kwnames[] = {
22184 (char *) "month",(char *) "flags", NULL
22185 };
22186
22187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22188 ecode1 = SWIG_AsVal_int(obj0, &val1);
22189 if (!SWIG_IsOK(ecode1)) {
22190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22191 }
22192 arg1 = static_cast< wxDateTime::Month >(val1);
22193 if (obj1) {
22194 ecode2 = SWIG_AsVal_int(obj1, &val2);
22195 if (!SWIG_IsOK(ecode2)) {
22196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22197 }
22198 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22199 }
22200 {
22201 PyThreadState* __tstate = wxPyBeginAllowThreads();
22202 result = wxDateTime::GetMonthName(arg1,arg2);
22203 wxPyEndAllowThreads(__tstate);
22204 if (PyErr_Occurred()) SWIG_fail;
22205 }
22206 {
22207 #if wxUSE_UNICODE
22208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22209 #else
22210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22211 #endif
22212 }
22213 return resultobj;
22214 fail:
22215 return NULL;
22216 }
22217
22218
22219 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22220 PyObject *resultobj = 0;
22221 wxDateTime::WeekDay arg1 ;
22222 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22223 wxString result;
22224 int val1 ;
22225 int ecode1 = 0 ;
22226 int val2 ;
22227 int ecode2 = 0 ;
22228 PyObject * obj0 = 0 ;
22229 PyObject * obj1 = 0 ;
22230 char * kwnames[] = {
22231 (char *) "weekday",(char *) "flags", NULL
22232 };
22233
22234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22235 ecode1 = SWIG_AsVal_int(obj0, &val1);
22236 if (!SWIG_IsOK(ecode1)) {
22237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22238 }
22239 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22240 if (obj1) {
22241 ecode2 = SWIG_AsVal_int(obj1, &val2);
22242 if (!SWIG_IsOK(ecode2)) {
22243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22244 }
22245 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22246 }
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 result = wxDateTime::GetWeekDayName(arg1,arg2);
22250 wxPyEndAllowThreads(__tstate);
22251 if (PyErr_Occurred()) SWIG_fail;
22252 }
22253 {
22254 #if wxUSE_UNICODE
22255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22256 #else
22257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22258 #endif
22259 }
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22267 PyObject *resultobj = 0;
22268 PyObject *result = 0 ;
22269
22270 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22271 {
22272 PyThreadState* __tstate = wxPyBeginAllowThreads();
22273 result = (PyObject *)wxDateTime_GetAmPmStrings();
22274 wxPyEndAllowThreads(__tstate);
22275 if (PyErr_Occurred()) SWIG_fail;
22276 }
22277 resultobj = result;
22278 return resultobj;
22279 fail:
22280 return NULL;
22281 }
22282
22283
22284 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22285 PyObject *resultobj = 0;
22286 int arg1 = (int) wxDateTime::Inv_Year ;
22287 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22288 bool result;
22289 int val1 ;
22290 int ecode1 = 0 ;
22291 int val2 ;
22292 int ecode2 = 0 ;
22293 PyObject * obj0 = 0 ;
22294 PyObject * obj1 = 0 ;
22295 char * kwnames[] = {
22296 (char *) "year",(char *) "country", NULL
22297 };
22298
22299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22300 if (obj0) {
22301 ecode1 = SWIG_AsVal_int(obj0, &val1);
22302 if (!SWIG_IsOK(ecode1)) {
22303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22304 }
22305 arg1 = static_cast< int >(val1);
22306 }
22307 if (obj1) {
22308 ecode2 = SWIG_AsVal_int(obj1, &val2);
22309 if (!SWIG_IsOK(ecode2)) {
22310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22311 }
22312 arg2 = static_cast< wxDateTime::Country >(val2);
22313 }
22314 {
22315 PyThreadState* __tstate = wxPyBeginAllowThreads();
22316 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22317 wxPyEndAllowThreads(__tstate);
22318 if (PyErr_Occurred()) SWIG_fail;
22319 }
22320 {
22321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22322 }
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22330 PyObject *resultobj = 0;
22331 int arg1 = (int) wxDateTime::Inv_Year ;
22332 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22333 wxDateTime result;
22334 int val1 ;
22335 int ecode1 = 0 ;
22336 int val2 ;
22337 int ecode2 = 0 ;
22338 PyObject * obj0 = 0 ;
22339 PyObject * obj1 = 0 ;
22340 char * kwnames[] = {
22341 (char *) "year",(char *) "country", NULL
22342 };
22343
22344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22345 if (obj0) {
22346 ecode1 = SWIG_AsVal_int(obj0, &val1);
22347 if (!SWIG_IsOK(ecode1)) {
22348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22349 }
22350 arg1 = static_cast< int >(val1);
22351 }
22352 if (obj1) {
22353 ecode2 = SWIG_AsVal_int(obj1, &val2);
22354 if (!SWIG_IsOK(ecode2)) {
22355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22356 }
22357 arg2 = static_cast< wxDateTime::Country >(val2);
22358 }
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 result = wxDateTime::GetBeginDST(arg1,arg2);
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22373 PyObject *resultobj = 0;
22374 int arg1 = (int) wxDateTime::Inv_Year ;
22375 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22376 wxDateTime result;
22377 int val1 ;
22378 int ecode1 = 0 ;
22379 int val2 ;
22380 int ecode2 = 0 ;
22381 PyObject * obj0 = 0 ;
22382 PyObject * obj1 = 0 ;
22383 char * kwnames[] = {
22384 (char *) "year",(char *) "country", NULL
22385 };
22386
22387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22388 if (obj0) {
22389 ecode1 = SWIG_AsVal_int(obj0, &val1);
22390 if (!SWIG_IsOK(ecode1)) {
22391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22392 }
22393 arg1 = static_cast< int >(val1);
22394 }
22395 if (obj1) {
22396 ecode2 = SWIG_AsVal_int(obj1, &val2);
22397 if (!SWIG_IsOK(ecode2)) {
22398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22399 }
22400 arg2 = static_cast< wxDateTime::Country >(val2);
22401 }
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 result = wxDateTime::GetEndDST(arg1,arg2);
22405 wxPyEndAllowThreads(__tstate);
22406 if (PyErr_Occurred()) SWIG_fail;
22407 }
22408 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22409 return resultobj;
22410 fail:
22411 return NULL;
22412 }
22413
22414
22415 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22416 PyObject *resultobj = 0;
22417 wxDateTime result;
22418
22419 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22420 {
22421 PyThreadState* __tstate = wxPyBeginAllowThreads();
22422 result = wxDateTime::Now();
22423 wxPyEndAllowThreads(__tstate);
22424 if (PyErr_Occurred()) SWIG_fail;
22425 }
22426 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxDateTime result;
22436
22437 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 result = wxDateTime::UNow();
22441 wxPyEndAllowThreads(__tstate);
22442 if (PyErr_Occurred()) SWIG_fail;
22443 }
22444 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22452 PyObject *resultobj = 0;
22453 wxDateTime result;
22454
22455 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22456 {
22457 PyThreadState* __tstate = wxPyBeginAllowThreads();
22458 result = wxDateTime::Today();
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22463 return resultobj;
22464 fail:
22465 return NULL;
22466 }
22467
22468
22469 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22470 PyObject *resultobj = 0;
22471 wxDateTime *result = 0 ;
22472
22473 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22474 {
22475 PyThreadState* __tstate = wxPyBeginAllowThreads();
22476 result = (wxDateTime *)new wxDateTime();
22477 wxPyEndAllowThreads(__tstate);
22478 if (PyErr_Occurred()) SWIG_fail;
22479 }
22480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22488 PyObject *resultobj = 0;
22489 time_t arg1 ;
22490 wxDateTime *result = 0 ;
22491 unsigned int val1 ;
22492 int ecode1 = 0 ;
22493 PyObject * obj0 = 0 ;
22494 char * kwnames[] = {
22495 (char *) "timet", NULL
22496 };
22497
22498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22499 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22500 if (!SWIG_IsOK(ecode1)) {
22501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22502 }
22503 arg1 = static_cast< time_t >(val1);
22504 {
22505 PyThreadState* __tstate = wxPyBeginAllowThreads();
22506 result = (wxDateTime *)new wxDateTime(arg1);
22507 wxPyEndAllowThreads(__tstate);
22508 if (PyErr_Occurred()) SWIG_fail;
22509 }
22510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22511 return resultobj;
22512 fail:
22513 return NULL;
22514 }
22515
22516
22517 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22518 PyObject *resultobj = 0;
22519 double arg1 ;
22520 wxDateTime *result = 0 ;
22521 double val1 ;
22522 int ecode1 = 0 ;
22523 PyObject * obj0 = 0 ;
22524 char * kwnames[] = {
22525 (char *) "jdn", NULL
22526 };
22527
22528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22529 ecode1 = SWIG_AsVal_double(obj0, &val1);
22530 if (!SWIG_IsOK(ecode1)) {
22531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22532 }
22533 arg1 = static_cast< double >(val1);
22534 {
22535 PyThreadState* __tstate = wxPyBeginAllowThreads();
22536 result = (wxDateTime *)new wxDateTime(arg1);
22537 wxPyEndAllowThreads(__tstate);
22538 if (PyErr_Occurred()) SWIG_fail;
22539 }
22540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22541 return resultobj;
22542 fail:
22543 return NULL;
22544 }
22545
22546
22547 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22548 PyObject *resultobj = 0;
22549 int arg1 ;
22550 int arg2 = (int) 0 ;
22551 int arg3 = (int) 0 ;
22552 int arg4 = (int) 0 ;
22553 wxDateTime *result = 0 ;
22554 int val1 ;
22555 int ecode1 = 0 ;
22556 int val2 ;
22557 int ecode2 = 0 ;
22558 int val3 ;
22559 int ecode3 = 0 ;
22560 int val4 ;
22561 int ecode4 = 0 ;
22562 PyObject * obj0 = 0 ;
22563 PyObject * obj1 = 0 ;
22564 PyObject * obj2 = 0 ;
22565 PyObject * obj3 = 0 ;
22566 char * kwnames[] = {
22567 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22568 };
22569
22570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22571 ecode1 = SWIG_AsVal_int(obj0, &val1);
22572 if (!SWIG_IsOK(ecode1)) {
22573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22574 }
22575 arg1 = static_cast< int >(val1);
22576 if (obj1) {
22577 ecode2 = SWIG_AsVal_int(obj1, &val2);
22578 if (!SWIG_IsOK(ecode2)) {
22579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22580 }
22581 arg2 = static_cast< int >(val2);
22582 }
22583 if (obj2) {
22584 ecode3 = SWIG_AsVal_int(obj2, &val3);
22585 if (!SWIG_IsOK(ecode3)) {
22586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22587 }
22588 arg3 = static_cast< int >(val3);
22589 }
22590 if (obj3) {
22591 ecode4 = SWIG_AsVal_int(obj3, &val4);
22592 if (!SWIG_IsOK(ecode4)) {
22593 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22594 }
22595 arg4 = static_cast< int >(val4);
22596 }
22597 {
22598 PyThreadState* __tstate = wxPyBeginAllowThreads();
22599 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22600 wxPyEndAllowThreads(__tstate);
22601 if (PyErr_Occurred()) SWIG_fail;
22602 }
22603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22611 PyObject *resultobj = 0;
22612 int arg1 ;
22613 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22614 int arg3 = (int) wxDateTime::Inv_Year ;
22615 int arg4 = (int) 0 ;
22616 int arg5 = (int) 0 ;
22617 int arg6 = (int) 0 ;
22618 int arg7 = (int) 0 ;
22619 wxDateTime *result = 0 ;
22620 int val1 ;
22621 int ecode1 = 0 ;
22622 int val2 ;
22623 int ecode2 = 0 ;
22624 int val3 ;
22625 int ecode3 = 0 ;
22626 int val4 ;
22627 int ecode4 = 0 ;
22628 int val5 ;
22629 int ecode5 = 0 ;
22630 int val6 ;
22631 int ecode6 = 0 ;
22632 int val7 ;
22633 int ecode7 = 0 ;
22634 PyObject * obj0 = 0 ;
22635 PyObject * obj1 = 0 ;
22636 PyObject * obj2 = 0 ;
22637 PyObject * obj3 = 0 ;
22638 PyObject * obj4 = 0 ;
22639 PyObject * obj5 = 0 ;
22640 PyObject * obj6 = 0 ;
22641 char * kwnames[] = {
22642 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22643 };
22644
22645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22646 ecode1 = SWIG_AsVal_int(obj0, &val1);
22647 if (!SWIG_IsOK(ecode1)) {
22648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22649 }
22650 arg1 = static_cast< int >(val1);
22651 if (obj1) {
22652 ecode2 = SWIG_AsVal_int(obj1, &val2);
22653 if (!SWIG_IsOK(ecode2)) {
22654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22655 }
22656 arg2 = static_cast< wxDateTime::Month >(val2);
22657 }
22658 if (obj2) {
22659 ecode3 = SWIG_AsVal_int(obj2, &val3);
22660 if (!SWIG_IsOK(ecode3)) {
22661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22662 }
22663 arg3 = static_cast< int >(val3);
22664 }
22665 if (obj3) {
22666 ecode4 = SWIG_AsVal_int(obj3, &val4);
22667 if (!SWIG_IsOK(ecode4)) {
22668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22669 }
22670 arg4 = static_cast< int >(val4);
22671 }
22672 if (obj4) {
22673 ecode5 = SWIG_AsVal_int(obj4, &val5);
22674 if (!SWIG_IsOK(ecode5)) {
22675 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22676 }
22677 arg5 = static_cast< int >(val5);
22678 }
22679 if (obj5) {
22680 ecode6 = SWIG_AsVal_int(obj5, &val6);
22681 if (!SWIG_IsOK(ecode6)) {
22682 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22683 }
22684 arg6 = static_cast< int >(val6);
22685 }
22686 if (obj6) {
22687 ecode7 = SWIG_AsVal_int(obj6, &val7);
22688 if (!SWIG_IsOK(ecode7)) {
22689 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22690 }
22691 arg7 = static_cast< int >(val7);
22692 }
22693 {
22694 PyThreadState* __tstate = wxPyBeginAllowThreads();
22695 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22696 wxPyEndAllowThreads(__tstate);
22697 if (PyErr_Occurred()) SWIG_fail;
22698 }
22699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22700 return resultobj;
22701 fail:
22702 return NULL;
22703 }
22704
22705
22706 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22707 PyObject *resultobj = 0;
22708 wxDateTime *arg1 = 0 ;
22709 wxDateTime *result = 0 ;
22710 void *argp1 = 0 ;
22711 int res1 = 0 ;
22712 PyObject * obj0 = 0 ;
22713 char * kwnames[] = {
22714 (char *) "date", NULL
22715 };
22716
22717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22718 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22719 if (!SWIG_IsOK(res1)) {
22720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22721 }
22722 if (!argp1) {
22723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22724 }
22725 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22726 {
22727 PyThreadState* __tstate = wxPyBeginAllowThreads();
22728 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22729 wxPyEndAllowThreads(__tstate);
22730 if (PyErr_Occurred()) SWIG_fail;
22731 }
22732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22740 PyObject *resultobj = 0;
22741 wxDateTime *arg1 = (wxDateTime *) 0 ;
22742 void *argp1 = 0 ;
22743 int res1 = 0 ;
22744 PyObject *swig_obj[1] ;
22745
22746 if (!args) SWIG_fail;
22747 swig_obj[0] = args;
22748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22749 if (!SWIG_IsOK(res1)) {
22750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22751 }
22752 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22753 {
22754 PyThreadState* __tstate = wxPyBeginAllowThreads();
22755 delete arg1;
22756
22757 wxPyEndAllowThreads(__tstate);
22758 if (PyErr_Occurred()) SWIG_fail;
22759 }
22760 resultobj = SWIG_Py_Void();
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22768 PyObject *resultobj = 0;
22769 wxDateTime *arg1 = (wxDateTime *) 0 ;
22770 wxDateTime *result = 0 ;
22771 void *argp1 = 0 ;
22772 int res1 = 0 ;
22773 PyObject *swig_obj[1] ;
22774
22775 if (!args) SWIG_fail;
22776 swig_obj[0] = args;
22777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22778 if (!SWIG_IsOK(res1)) {
22779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22780 }
22781 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 {
22785 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22786 result = (wxDateTime *) &_result_ref;
22787 }
22788 wxPyEndAllowThreads(__tstate);
22789 if (PyErr_Occurred()) SWIG_fail;
22790 }
22791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj = 0;
22800 wxDateTime *arg1 = (wxDateTime *) 0 ;
22801 time_t arg2 ;
22802 wxDateTime *result = 0 ;
22803 void *argp1 = 0 ;
22804 int res1 = 0 ;
22805 unsigned int val2 ;
22806 int ecode2 = 0 ;
22807 PyObject * obj0 = 0 ;
22808 PyObject * obj1 = 0 ;
22809 char * kwnames[] = {
22810 (char *) "self",(char *) "timet", NULL
22811 };
22812
22813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22815 if (!SWIG_IsOK(res1)) {
22816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22817 }
22818 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22819 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22820 if (!SWIG_IsOK(ecode2)) {
22821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22822 }
22823 arg2 = static_cast< time_t >(val2);
22824 {
22825 PyThreadState* __tstate = wxPyBeginAllowThreads();
22826 {
22827 wxDateTime &_result_ref = (arg1)->Set(arg2);
22828 result = (wxDateTime *) &_result_ref;
22829 }
22830 wxPyEndAllowThreads(__tstate);
22831 if (PyErr_Occurred()) SWIG_fail;
22832 }
22833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22834 return resultobj;
22835 fail:
22836 return NULL;
22837 }
22838
22839
22840 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22841 PyObject *resultobj = 0;
22842 wxDateTime *arg1 = (wxDateTime *) 0 ;
22843 double arg2 ;
22844 wxDateTime *result = 0 ;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 double val2 ;
22848 int ecode2 = 0 ;
22849 PyObject * obj0 = 0 ;
22850 PyObject * obj1 = 0 ;
22851 char * kwnames[] = {
22852 (char *) "self",(char *) "jdn", NULL
22853 };
22854
22855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22857 if (!SWIG_IsOK(res1)) {
22858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22859 }
22860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22861 ecode2 = SWIG_AsVal_double(obj1, &val2);
22862 if (!SWIG_IsOK(ecode2)) {
22863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22864 }
22865 arg2 = static_cast< double >(val2);
22866 {
22867 PyThreadState* __tstate = wxPyBeginAllowThreads();
22868 {
22869 wxDateTime &_result_ref = (arg1)->Set(arg2);
22870 result = (wxDateTime *) &_result_ref;
22871 }
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22883 PyObject *resultobj = 0;
22884 wxDateTime *arg1 = (wxDateTime *) 0 ;
22885 int arg2 ;
22886 int arg3 = (int) 0 ;
22887 int arg4 = (int) 0 ;
22888 int arg5 = (int) 0 ;
22889 wxDateTime *result = 0 ;
22890 void *argp1 = 0 ;
22891 int res1 = 0 ;
22892 int val2 ;
22893 int ecode2 = 0 ;
22894 int val3 ;
22895 int ecode3 = 0 ;
22896 int val4 ;
22897 int ecode4 = 0 ;
22898 int val5 ;
22899 int ecode5 = 0 ;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902 PyObject * obj2 = 0 ;
22903 PyObject * obj3 = 0 ;
22904 PyObject * obj4 = 0 ;
22905 char * kwnames[] = {
22906 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22907 };
22908
22909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22911 if (!SWIG_IsOK(res1)) {
22912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22913 }
22914 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22915 ecode2 = SWIG_AsVal_int(obj1, &val2);
22916 if (!SWIG_IsOK(ecode2)) {
22917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22918 }
22919 arg2 = static_cast< int >(val2);
22920 if (obj2) {
22921 ecode3 = SWIG_AsVal_int(obj2, &val3);
22922 if (!SWIG_IsOK(ecode3)) {
22923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22924 }
22925 arg3 = static_cast< int >(val3);
22926 }
22927 if (obj3) {
22928 ecode4 = SWIG_AsVal_int(obj3, &val4);
22929 if (!SWIG_IsOK(ecode4)) {
22930 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22931 }
22932 arg4 = static_cast< int >(val4);
22933 }
22934 if (obj4) {
22935 ecode5 = SWIG_AsVal_int(obj4, &val5);
22936 if (!SWIG_IsOK(ecode5)) {
22937 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22938 }
22939 arg5 = static_cast< int >(val5);
22940 }
22941 {
22942 PyThreadState* __tstate = wxPyBeginAllowThreads();
22943 {
22944 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22945 result = (wxDateTime *) &_result_ref;
22946 }
22947 wxPyEndAllowThreads(__tstate);
22948 if (PyErr_Occurred()) SWIG_fail;
22949 }
22950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22958 PyObject *resultobj = 0;
22959 wxDateTime *arg1 = (wxDateTime *) 0 ;
22960 int arg2 ;
22961 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22962 int arg4 = (int) wxDateTime::Inv_Year ;
22963 int arg5 = (int) 0 ;
22964 int arg6 = (int) 0 ;
22965 int arg7 = (int) 0 ;
22966 int arg8 = (int) 0 ;
22967 wxDateTime *result = 0 ;
22968 void *argp1 = 0 ;
22969 int res1 = 0 ;
22970 int val2 ;
22971 int ecode2 = 0 ;
22972 int val3 ;
22973 int ecode3 = 0 ;
22974 int val4 ;
22975 int ecode4 = 0 ;
22976 int val5 ;
22977 int ecode5 = 0 ;
22978 int val6 ;
22979 int ecode6 = 0 ;
22980 int val7 ;
22981 int ecode7 = 0 ;
22982 int val8 ;
22983 int ecode8 = 0 ;
22984 PyObject * obj0 = 0 ;
22985 PyObject * obj1 = 0 ;
22986 PyObject * obj2 = 0 ;
22987 PyObject * obj3 = 0 ;
22988 PyObject * obj4 = 0 ;
22989 PyObject * obj5 = 0 ;
22990 PyObject * obj6 = 0 ;
22991 PyObject * obj7 = 0 ;
22992 char * kwnames[] = {
22993 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22994 };
22995
22996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22998 if (!SWIG_IsOK(res1)) {
22999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23000 }
23001 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23002 ecode2 = SWIG_AsVal_int(obj1, &val2);
23003 if (!SWIG_IsOK(ecode2)) {
23004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23005 }
23006 arg2 = static_cast< int >(val2);
23007 if (obj2) {
23008 ecode3 = SWIG_AsVal_int(obj2, &val3);
23009 if (!SWIG_IsOK(ecode3)) {
23010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23011 }
23012 arg3 = static_cast< wxDateTime::Month >(val3);
23013 }
23014 if (obj3) {
23015 ecode4 = SWIG_AsVal_int(obj3, &val4);
23016 if (!SWIG_IsOK(ecode4)) {
23017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23018 }
23019 arg4 = static_cast< int >(val4);
23020 }
23021 if (obj4) {
23022 ecode5 = SWIG_AsVal_int(obj4, &val5);
23023 if (!SWIG_IsOK(ecode5)) {
23024 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23025 }
23026 arg5 = static_cast< int >(val5);
23027 }
23028 if (obj5) {
23029 ecode6 = SWIG_AsVal_int(obj5, &val6);
23030 if (!SWIG_IsOK(ecode6)) {
23031 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23032 }
23033 arg6 = static_cast< int >(val6);
23034 }
23035 if (obj6) {
23036 ecode7 = SWIG_AsVal_int(obj6, &val7);
23037 if (!SWIG_IsOK(ecode7)) {
23038 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23039 }
23040 arg7 = static_cast< int >(val7);
23041 }
23042 if (obj7) {
23043 ecode8 = SWIG_AsVal_int(obj7, &val8);
23044 if (!SWIG_IsOK(ecode8)) {
23045 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23046 }
23047 arg8 = static_cast< int >(val8);
23048 }
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 {
23052 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23053 result = (wxDateTime *) &_result_ref;
23054 }
23055 wxPyEndAllowThreads(__tstate);
23056 if (PyErr_Occurred()) SWIG_fail;
23057 }
23058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23066 PyObject *resultobj = 0;
23067 wxDateTime *arg1 = (wxDateTime *) 0 ;
23068 wxDateTime *result = 0 ;
23069 void *argp1 = 0 ;
23070 int res1 = 0 ;
23071 PyObject *swig_obj[1] ;
23072
23073 if (!args) SWIG_fail;
23074 swig_obj[0] = args;
23075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23078 }
23079 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23080 {
23081 PyThreadState* __tstate = wxPyBeginAllowThreads();
23082 {
23083 wxDateTime &_result_ref = (arg1)->ResetTime();
23084 result = (wxDateTime *) &_result_ref;
23085 }
23086 wxPyEndAllowThreads(__tstate);
23087 if (PyErr_Occurred()) SWIG_fail;
23088 }
23089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23090 return resultobj;
23091 fail:
23092 return NULL;
23093 }
23094
23095
23096 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23097 PyObject *resultobj = 0;
23098 wxDateTime *arg1 = (wxDateTime *) 0 ;
23099 int arg2 ;
23100 wxDateTime *result = 0 ;
23101 void *argp1 = 0 ;
23102 int res1 = 0 ;
23103 int val2 ;
23104 int ecode2 = 0 ;
23105 PyObject * obj0 = 0 ;
23106 PyObject * obj1 = 0 ;
23107 char * kwnames[] = {
23108 (char *) "self",(char *) "year", NULL
23109 };
23110
23111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23113 if (!SWIG_IsOK(res1)) {
23114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23115 }
23116 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23117 ecode2 = SWIG_AsVal_int(obj1, &val2);
23118 if (!SWIG_IsOK(ecode2)) {
23119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23120 }
23121 arg2 = static_cast< int >(val2);
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 {
23125 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23126 result = (wxDateTime *) &_result_ref;
23127 }
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj = 0;
23140 wxDateTime *arg1 = (wxDateTime *) 0 ;
23141 wxDateTime::Month arg2 ;
23142 wxDateTime *result = 0 ;
23143 void *argp1 = 0 ;
23144 int res1 = 0 ;
23145 int val2 ;
23146 int ecode2 = 0 ;
23147 PyObject * obj0 = 0 ;
23148 PyObject * obj1 = 0 ;
23149 char * kwnames[] = {
23150 (char *) "self",(char *) "month", NULL
23151 };
23152
23153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23155 if (!SWIG_IsOK(res1)) {
23156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23157 }
23158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23159 ecode2 = SWIG_AsVal_int(obj1, &val2);
23160 if (!SWIG_IsOK(ecode2)) {
23161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23162 }
23163 arg2 = static_cast< wxDateTime::Month >(val2);
23164 {
23165 PyThreadState* __tstate = wxPyBeginAllowThreads();
23166 {
23167 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23168 result = (wxDateTime *) &_result_ref;
23169 }
23170 wxPyEndAllowThreads(__tstate);
23171 if (PyErr_Occurred()) SWIG_fail;
23172 }
23173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23174 return resultobj;
23175 fail:
23176 return NULL;
23177 }
23178
23179
23180 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23181 PyObject *resultobj = 0;
23182 wxDateTime *arg1 = (wxDateTime *) 0 ;
23183 int arg2 ;
23184 wxDateTime *result = 0 ;
23185 void *argp1 = 0 ;
23186 int res1 = 0 ;
23187 int val2 ;
23188 int ecode2 = 0 ;
23189 PyObject * obj0 = 0 ;
23190 PyObject * obj1 = 0 ;
23191 char * kwnames[] = {
23192 (char *) "self",(char *) "day", NULL
23193 };
23194
23195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23197 if (!SWIG_IsOK(res1)) {
23198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23199 }
23200 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23201 ecode2 = SWIG_AsVal_int(obj1, &val2);
23202 if (!SWIG_IsOK(ecode2)) {
23203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23204 }
23205 arg2 = static_cast< int >(val2);
23206 {
23207 PyThreadState* __tstate = wxPyBeginAllowThreads();
23208 {
23209 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23210 result = (wxDateTime *) &_result_ref;
23211 }
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23223 PyObject *resultobj = 0;
23224 wxDateTime *arg1 = (wxDateTime *) 0 ;
23225 int arg2 ;
23226 wxDateTime *result = 0 ;
23227 void *argp1 = 0 ;
23228 int res1 = 0 ;
23229 int val2 ;
23230 int ecode2 = 0 ;
23231 PyObject * obj0 = 0 ;
23232 PyObject * obj1 = 0 ;
23233 char * kwnames[] = {
23234 (char *) "self",(char *) "hour", NULL
23235 };
23236
23237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23239 if (!SWIG_IsOK(res1)) {
23240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23241 }
23242 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23243 ecode2 = SWIG_AsVal_int(obj1, &val2);
23244 if (!SWIG_IsOK(ecode2)) {
23245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23246 }
23247 arg2 = static_cast< int >(val2);
23248 {
23249 PyThreadState* __tstate = wxPyBeginAllowThreads();
23250 {
23251 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23252 result = (wxDateTime *) &_result_ref;
23253 }
23254 wxPyEndAllowThreads(__tstate);
23255 if (PyErr_Occurred()) SWIG_fail;
23256 }
23257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23258 return resultobj;
23259 fail:
23260 return NULL;
23261 }
23262
23263
23264 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23265 PyObject *resultobj = 0;
23266 wxDateTime *arg1 = (wxDateTime *) 0 ;
23267 int arg2 ;
23268 wxDateTime *result = 0 ;
23269 void *argp1 = 0 ;
23270 int res1 = 0 ;
23271 int val2 ;
23272 int ecode2 = 0 ;
23273 PyObject * obj0 = 0 ;
23274 PyObject * obj1 = 0 ;
23275 char * kwnames[] = {
23276 (char *) "self",(char *) "minute", NULL
23277 };
23278
23279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23281 if (!SWIG_IsOK(res1)) {
23282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23283 }
23284 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23285 ecode2 = SWIG_AsVal_int(obj1, &val2);
23286 if (!SWIG_IsOK(ecode2)) {
23287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23288 }
23289 arg2 = static_cast< int >(val2);
23290 {
23291 PyThreadState* __tstate = wxPyBeginAllowThreads();
23292 {
23293 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23294 result = (wxDateTime *) &_result_ref;
23295 }
23296 wxPyEndAllowThreads(__tstate);
23297 if (PyErr_Occurred()) SWIG_fail;
23298 }
23299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23300 return resultobj;
23301 fail:
23302 return NULL;
23303 }
23304
23305
23306 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23307 PyObject *resultobj = 0;
23308 wxDateTime *arg1 = (wxDateTime *) 0 ;
23309 int arg2 ;
23310 wxDateTime *result = 0 ;
23311 void *argp1 = 0 ;
23312 int res1 = 0 ;
23313 int val2 ;
23314 int ecode2 = 0 ;
23315 PyObject * obj0 = 0 ;
23316 PyObject * obj1 = 0 ;
23317 char * kwnames[] = {
23318 (char *) "self",(char *) "second", NULL
23319 };
23320
23321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23323 if (!SWIG_IsOK(res1)) {
23324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23325 }
23326 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23327 ecode2 = SWIG_AsVal_int(obj1, &val2);
23328 if (!SWIG_IsOK(ecode2)) {
23329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23330 }
23331 arg2 = static_cast< int >(val2);
23332 {
23333 PyThreadState* __tstate = wxPyBeginAllowThreads();
23334 {
23335 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23336 result = (wxDateTime *) &_result_ref;
23337 }
23338 wxPyEndAllowThreads(__tstate);
23339 if (PyErr_Occurred()) SWIG_fail;
23340 }
23341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23342 return resultobj;
23343 fail:
23344 return NULL;
23345 }
23346
23347
23348 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23349 PyObject *resultobj = 0;
23350 wxDateTime *arg1 = (wxDateTime *) 0 ;
23351 int arg2 ;
23352 wxDateTime *result = 0 ;
23353 void *argp1 = 0 ;
23354 int res1 = 0 ;
23355 int val2 ;
23356 int ecode2 = 0 ;
23357 PyObject * obj0 = 0 ;
23358 PyObject * obj1 = 0 ;
23359 char * kwnames[] = {
23360 (char *) "self",(char *) "millisecond", NULL
23361 };
23362
23363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23365 if (!SWIG_IsOK(res1)) {
23366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23367 }
23368 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23369 ecode2 = SWIG_AsVal_int(obj1, &val2);
23370 if (!SWIG_IsOK(ecode2)) {
23371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23372 }
23373 arg2 = static_cast< int >(val2);
23374 {
23375 PyThreadState* __tstate = wxPyBeginAllowThreads();
23376 {
23377 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23378 result = (wxDateTime *) &_result_ref;
23379 }
23380 wxPyEndAllowThreads(__tstate);
23381 if (PyErr_Occurred()) SWIG_fail;
23382 }
23383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23391 PyObject *resultobj = 0;
23392 wxDateTime *arg1 = (wxDateTime *) 0 ;
23393 wxDateTime::WeekDay arg2 ;
23394 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23395 wxDateTime *result = 0 ;
23396 void *argp1 = 0 ;
23397 int res1 = 0 ;
23398 int val2 ;
23399 int ecode2 = 0 ;
23400 int val3 ;
23401 int ecode3 = 0 ;
23402 PyObject * obj0 = 0 ;
23403 PyObject * obj1 = 0 ;
23404 PyObject * obj2 = 0 ;
23405 char * kwnames[] = {
23406 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23407 };
23408
23409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23411 if (!SWIG_IsOK(res1)) {
23412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23413 }
23414 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23415 ecode2 = SWIG_AsVal_int(obj1, &val2);
23416 if (!SWIG_IsOK(ecode2)) {
23417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23418 }
23419 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23420 if (obj2) {
23421 ecode3 = SWIG_AsVal_int(obj2, &val3);
23422 if (!SWIG_IsOK(ecode3)) {
23423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23424 }
23425 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23426 }
23427 {
23428 PyThreadState* __tstate = wxPyBeginAllowThreads();
23429 {
23430 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23431 result = (wxDateTime *) &_result_ref;
23432 }
23433 wxPyEndAllowThreads(__tstate);
23434 if (PyErr_Occurred()) SWIG_fail;
23435 }
23436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23437 return resultobj;
23438 fail:
23439 return NULL;
23440 }
23441
23442
23443 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23444 PyObject *resultobj = 0;
23445 wxDateTime *arg1 = (wxDateTime *) 0 ;
23446 wxDateTime::WeekDay arg2 ;
23447 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23448 wxDateTime result;
23449 void *argp1 = 0 ;
23450 int res1 = 0 ;
23451 int val2 ;
23452 int ecode2 = 0 ;
23453 int val3 ;
23454 int ecode3 = 0 ;
23455 PyObject * obj0 = 0 ;
23456 PyObject * obj1 = 0 ;
23457 PyObject * obj2 = 0 ;
23458 char * kwnames[] = {
23459 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23460 };
23461
23462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23464 if (!SWIG_IsOK(res1)) {
23465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23466 }
23467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23468 ecode2 = SWIG_AsVal_int(obj1, &val2);
23469 if (!SWIG_IsOK(ecode2)) {
23470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23471 }
23472 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23473 if (obj2) {
23474 ecode3 = SWIG_AsVal_int(obj2, &val3);
23475 if (!SWIG_IsOK(ecode3)) {
23476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23477 }
23478 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23479 }
23480 {
23481 PyThreadState* __tstate = wxPyBeginAllowThreads();
23482 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23483 wxPyEndAllowThreads(__tstate);
23484 if (PyErr_Occurred()) SWIG_fail;
23485 }
23486 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23487 return resultobj;
23488 fail:
23489 return NULL;
23490 }
23491
23492
23493 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23494 PyObject *resultobj = 0;
23495 wxDateTime *arg1 = (wxDateTime *) 0 ;
23496 wxDateTime::WeekDay arg2 ;
23497 wxDateTime *result = 0 ;
23498 void *argp1 = 0 ;
23499 int res1 = 0 ;
23500 int val2 ;
23501 int ecode2 = 0 ;
23502 PyObject * obj0 = 0 ;
23503 PyObject * obj1 = 0 ;
23504 char * kwnames[] = {
23505 (char *) "self",(char *) "weekday", NULL
23506 };
23507
23508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23510 if (!SWIG_IsOK(res1)) {
23511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23512 }
23513 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23514 ecode2 = SWIG_AsVal_int(obj1, &val2);
23515 if (!SWIG_IsOK(ecode2)) {
23516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23517 }
23518 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23519 {
23520 PyThreadState* __tstate = wxPyBeginAllowThreads();
23521 {
23522 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23523 result = (wxDateTime *) &_result_ref;
23524 }
23525 wxPyEndAllowThreads(__tstate);
23526 if (PyErr_Occurred()) SWIG_fail;
23527 }
23528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23536 PyObject *resultobj = 0;
23537 wxDateTime *arg1 = (wxDateTime *) 0 ;
23538 wxDateTime::WeekDay arg2 ;
23539 wxDateTime result;
23540 void *argp1 = 0 ;
23541 int res1 = 0 ;
23542 int val2 ;
23543 int ecode2 = 0 ;
23544 PyObject * obj0 = 0 ;
23545 PyObject * obj1 = 0 ;
23546 char * kwnames[] = {
23547 (char *) "self",(char *) "weekday", NULL
23548 };
23549
23550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23552 if (!SWIG_IsOK(res1)) {
23553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23554 }
23555 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23556 ecode2 = SWIG_AsVal_int(obj1, &val2);
23557 if (!SWIG_IsOK(ecode2)) {
23558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23559 }
23560 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 result = (arg1)->GetNextWeekDay(arg2);
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23568 return resultobj;
23569 fail:
23570 return NULL;
23571 }
23572
23573
23574 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23575 PyObject *resultobj = 0;
23576 wxDateTime *arg1 = (wxDateTime *) 0 ;
23577 wxDateTime::WeekDay arg2 ;
23578 wxDateTime *result = 0 ;
23579 void *argp1 = 0 ;
23580 int res1 = 0 ;
23581 int val2 ;
23582 int ecode2 = 0 ;
23583 PyObject * obj0 = 0 ;
23584 PyObject * obj1 = 0 ;
23585 char * kwnames[] = {
23586 (char *) "self",(char *) "weekday", NULL
23587 };
23588
23589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23591 if (!SWIG_IsOK(res1)) {
23592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23593 }
23594 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23595 ecode2 = SWIG_AsVal_int(obj1, &val2);
23596 if (!SWIG_IsOK(ecode2)) {
23597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23598 }
23599 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23600 {
23601 PyThreadState* __tstate = wxPyBeginAllowThreads();
23602 {
23603 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23604 result = (wxDateTime *) &_result_ref;
23605 }
23606 wxPyEndAllowThreads(__tstate);
23607 if (PyErr_Occurred()) SWIG_fail;
23608 }
23609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23610 return resultobj;
23611 fail:
23612 return NULL;
23613 }
23614
23615
23616 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23617 PyObject *resultobj = 0;
23618 wxDateTime *arg1 = (wxDateTime *) 0 ;
23619 wxDateTime::WeekDay arg2 ;
23620 wxDateTime result;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 int val2 ;
23624 int ecode2 = 0 ;
23625 PyObject * obj0 = 0 ;
23626 PyObject * obj1 = 0 ;
23627 char * kwnames[] = {
23628 (char *) "self",(char *) "weekday", NULL
23629 };
23630
23631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23633 if (!SWIG_IsOK(res1)) {
23634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23635 }
23636 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23637 ecode2 = SWIG_AsVal_int(obj1, &val2);
23638 if (!SWIG_IsOK(ecode2)) {
23639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23640 }
23641 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23642 {
23643 PyThreadState* __tstate = wxPyBeginAllowThreads();
23644 result = (arg1)->GetPrevWeekDay(arg2);
23645 wxPyEndAllowThreads(__tstate);
23646 if (PyErr_Occurred()) SWIG_fail;
23647 }
23648 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23656 PyObject *resultobj = 0;
23657 wxDateTime *arg1 = (wxDateTime *) 0 ;
23658 wxDateTime::WeekDay arg2 ;
23659 int arg3 = (int) 1 ;
23660 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23661 int arg5 = (int) wxDateTime::Inv_Year ;
23662 bool result;
23663 void *argp1 = 0 ;
23664 int res1 = 0 ;
23665 int val2 ;
23666 int ecode2 = 0 ;
23667 int val3 ;
23668 int ecode3 = 0 ;
23669 int val4 ;
23670 int ecode4 = 0 ;
23671 int val5 ;
23672 int ecode5 = 0 ;
23673 PyObject * obj0 = 0 ;
23674 PyObject * obj1 = 0 ;
23675 PyObject * obj2 = 0 ;
23676 PyObject * obj3 = 0 ;
23677 PyObject * obj4 = 0 ;
23678 char * kwnames[] = {
23679 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23680 };
23681
23682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23684 if (!SWIG_IsOK(res1)) {
23685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23686 }
23687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23688 ecode2 = SWIG_AsVal_int(obj1, &val2);
23689 if (!SWIG_IsOK(ecode2)) {
23690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23691 }
23692 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23693 if (obj2) {
23694 ecode3 = SWIG_AsVal_int(obj2, &val3);
23695 if (!SWIG_IsOK(ecode3)) {
23696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23697 }
23698 arg3 = static_cast< int >(val3);
23699 }
23700 if (obj3) {
23701 ecode4 = SWIG_AsVal_int(obj3, &val4);
23702 if (!SWIG_IsOK(ecode4)) {
23703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23704 }
23705 arg4 = static_cast< wxDateTime::Month >(val4);
23706 }
23707 if (obj4) {
23708 ecode5 = SWIG_AsVal_int(obj4, &val5);
23709 if (!SWIG_IsOK(ecode5)) {
23710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23711 }
23712 arg5 = static_cast< int >(val5);
23713 }
23714 {
23715 PyThreadState* __tstate = wxPyBeginAllowThreads();
23716 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 {
23721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23722 }
23723 return resultobj;
23724 fail:
23725 return NULL;
23726 }
23727
23728
23729 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23730 PyObject *resultobj = 0;
23731 wxDateTime *arg1 = (wxDateTime *) 0 ;
23732 wxDateTime::WeekDay arg2 ;
23733 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23734 int arg4 = (int) wxDateTime::Inv_Year ;
23735 bool result;
23736 void *argp1 = 0 ;
23737 int res1 = 0 ;
23738 int val2 ;
23739 int ecode2 = 0 ;
23740 int val3 ;
23741 int ecode3 = 0 ;
23742 int val4 ;
23743 int ecode4 = 0 ;
23744 PyObject * obj0 = 0 ;
23745 PyObject * obj1 = 0 ;
23746 PyObject * obj2 = 0 ;
23747 PyObject * obj3 = 0 ;
23748 char * kwnames[] = {
23749 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23750 };
23751
23752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23754 if (!SWIG_IsOK(res1)) {
23755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23756 }
23757 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23758 ecode2 = SWIG_AsVal_int(obj1, &val2);
23759 if (!SWIG_IsOK(ecode2)) {
23760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23761 }
23762 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23763 if (obj2) {
23764 ecode3 = SWIG_AsVal_int(obj2, &val3);
23765 if (!SWIG_IsOK(ecode3)) {
23766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23767 }
23768 arg3 = static_cast< wxDateTime::Month >(val3);
23769 }
23770 if (obj3) {
23771 ecode4 = SWIG_AsVal_int(obj3, &val4);
23772 if (!SWIG_IsOK(ecode4)) {
23773 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23774 }
23775 arg4 = static_cast< int >(val4);
23776 }
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 {
23784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23785 }
23786 return resultobj;
23787 fail:
23788 return NULL;
23789 }
23790
23791
23792 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23793 PyObject *resultobj = 0;
23794 wxDateTime *arg1 = (wxDateTime *) 0 ;
23795 wxDateTime::WeekDay arg2 ;
23796 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23797 int arg4 = (int) wxDateTime::Inv_Year ;
23798 wxDateTime result;
23799 void *argp1 = 0 ;
23800 int res1 = 0 ;
23801 int val2 ;
23802 int ecode2 = 0 ;
23803 int val3 ;
23804 int ecode3 = 0 ;
23805 int val4 ;
23806 int ecode4 = 0 ;
23807 PyObject * obj0 = 0 ;
23808 PyObject * obj1 = 0 ;
23809 PyObject * obj2 = 0 ;
23810 PyObject * obj3 = 0 ;
23811 char * kwnames[] = {
23812 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23813 };
23814
23815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23817 if (!SWIG_IsOK(res1)) {
23818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23819 }
23820 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23821 ecode2 = SWIG_AsVal_int(obj1, &val2);
23822 if (!SWIG_IsOK(ecode2)) {
23823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23824 }
23825 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23826 if (obj2) {
23827 ecode3 = SWIG_AsVal_int(obj2, &val3);
23828 if (!SWIG_IsOK(ecode3)) {
23829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23830 }
23831 arg3 = static_cast< wxDateTime::Month >(val3);
23832 }
23833 if (obj3) {
23834 ecode4 = SWIG_AsVal_int(obj3, &val4);
23835 if (!SWIG_IsOK(ecode4)) {
23836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23837 }
23838 arg4 = static_cast< int >(val4);
23839 }
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23854 PyObject *resultobj = 0;
23855 wxDateTime *arg1 = (wxDateTime *) 0 ;
23856 int arg2 ;
23857 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23858 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23859 bool result;
23860 void *argp1 = 0 ;
23861 int res1 = 0 ;
23862 int val2 ;
23863 int ecode2 = 0 ;
23864 int val3 ;
23865 int ecode3 = 0 ;
23866 int val4 ;
23867 int ecode4 = 0 ;
23868 PyObject * obj0 = 0 ;
23869 PyObject * obj1 = 0 ;
23870 PyObject * obj2 = 0 ;
23871 PyObject * obj3 = 0 ;
23872 char * kwnames[] = {
23873 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23874 };
23875
23876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23880 }
23881 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23882 ecode2 = SWIG_AsVal_int(obj1, &val2);
23883 if (!SWIG_IsOK(ecode2)) {
23884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23885 }
23886 arg2 = static_cast< int >(val2);
23887 if (obj2) {
23888 ecode3 = SWIG_AsVal_int(obj2, &val3);
23889 if (!SWIG_IsOK(ecode3)) {
23890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23891 }
23892 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23893 }
23894 if (obj3) {
23895 ecode4 = SWIG_AsVal_int(obj3, &val4);
23896 if (!SWIG_IsOK(ecode4)) {
23897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23898 }
23899 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23900 }
23901 {
23902 PyThreadState* __tstate = wxPyBeginAllowThreads();
23903 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23904 wxPyEndAllowThreads(__tstate);
23905 if (PyErr_Occurred()) SWIG_fail;
23906 }
23907 {
23908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23909 }
23910 return resultobj;
23911 fail:
23912 return NULL;
23913 }
23914
23915
23916 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23917 PyObject *resultobj = 0;
23918 wxDateTime *arg1 = (wxDateTime *) 0 ;
23919 int arg2 ;
23920 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23921 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23922 wxDateTime result;
23923 void *argp1 = 0 ;
23924 int res1 = 0 ;
23925 int val2 ;
23926 int ecode2 = 0 ;
23927 int val3 ;
23928 int ecode3 = 0 ;
23929 int val4 ;
23930 int ecode4 = 0 ;
23931 PyObject * obj0 = 0 ;
23932 PyObject * obj1 = 0 ;
23933 PyObject * obj2 = 0 ;
23934 PyObject * obj3 = 0 ;
23935 char * kwnames[] = {
23936 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23937 };
23938
23939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23941 if (!SWIG_IsOK(res1)) {
23942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23943 }
23944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23945 ecode2 = SWIG_AsVal_int(obj1, &val2);
23946 if (!SWIG_IsOK(ecode2)) {
23947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23948 }
23949 arg2 = static_cast< int >(val2);
23950 if (obj2) {
23951 ecode3 = SWIG_AsVal_int(obj2, &val3);
23952 if (!SWIG_IsOK(ecode3)) {
23953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23954 }
23955 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23956 }
23957 if (obj3) {
23958 ecode4 = SWIG_AsVal_int(obj3, &val4);
23959 if (!SWIG_IsOK(ecode4)) {
23960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23961 }
23962 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23963 }
23964 {
23965 PyThreadState* __tstate = wxPyBeginAllowThreads();
23966 result = (arg1)->GetWeek(arg2,arg3,arg4);
23967 wxPyEndAllowThreads(__tstate);
23968 if (PyErr_Occurred()) SWIG_fail;
23969 }
23970 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj = 0;
23979 int arg1 ;
23980 int arg2 ;
23981 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23982 wxDateTime result;
23983 int val1 ;
23984 int ecode1 = 0 ;
23985 int val2 ;
23986 int ecode2 = 0 ;
23987 int val3 ;
23988 int ecode3 = 0 ;
23989 PyObject * obj0 = 0 ;
23990 PyObject * obj1 = 0 ;
23991 PyObject * obj2 = 0 ;
23992 char * kwnames[] = {
23993 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
23994 };
23995
23996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23997 ecode1 = SWIG_AsVal_int(obj0, &val1);
23998 if (!SWIG_IsOK(ecode1)) {
23999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24000 }
24001 arg1 = static_cast< int >(val1);
24002 ecode2 = SWIG_AsVal_int(obj1, &val2);
24003 if (!SWIG_IsOK(ecode2)) {
24004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24005 }
24006 arg2 = static_cast< int >(val2);
24007 if (obj2) {
24008 ecode3 = SWIG_AsVal_int(obj2, &val3);
24009 if (!SWIG_IsOK(ecode3)) {
24010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24011 }
24012 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24013 }
24014 {
24015 PyThreadState* __tstate = wxPyBeginAllowThreads();
24016 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24017 wxPyEndAllowThreads(__tstate);
24018 if (PyErr_Occurred()) SWIG_fail;
24019 }
24020 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24021 return resultobj;
24022 fail:
24023 return NULL;
24024 }
24025
24026
24027 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24028 PyObject *resultobj = 0;
24029 wxDateTime *arg1 = (wxDateTime *) 0 ;
24030 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24031 int arg3 = (int) wxDateTime::Inv_Year ;
24032 wxDateTime *result = 0 ;
24033 void *argp1 = 0 ;
24034 int res1 = 0 ;
24035 int val2 ;
24036 int ecode2 = 0 ;
24037 int val3 ;
24038 int ecode3 = 0 ;
24039 PyObject * obj0 = 0 ;
24040 PyObject * obj1 = 0 ;
24041 PyObject * obj2 = 0 ;
24042 char * kwnames[] = {
24043 (char *) "self",(char *) "month",(char *) "year", NULL
24044 };
24045
24046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24048 if (!SWIG_IsOK(res1)) {
24049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24050 }
24051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24052 if (obj1) {
24053 ecode2 = SWIG_AsVal_int(obj1, &val2);
24054 if (!SWIG_IsOK(ecode2)) {
24055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24056 }
24057 arg2 = static_cast< wxDateTime::Month >(val2);
24058 }
24059 if (obj2) {
24060 ecode3 = SWIG_AsVal_int(obj2, &val3);
24061 if (!SWIG_IsOK(ecode3)) {
24062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24063 }
24064 arg3 = static_cast< int >(val3);
24065 }
24066 {
24067 PyThreadState* __tstate = wxPyBeginAllowThreads();
24068 {
24069 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24070 result = (wxDateTime *) &_result_ref;
24071 }
24072 wxPyEndAllowThreads(__tstate);
24073 if (PyErr_Occurred()) SWIG_fail;
24074 }
24075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24083 PyObject *resultobj = 0;
24084 wxDateTime *arg1 = (wxDateTime *) 0 ;
24085 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24086 int arg3 = (int) wxDateTime::Inv_Year ;
24087 wxDateTime result;
24088 void *argp1 = 0 ;
24089 int res1 = 0 ;
24090 int val2 ;
24091 int ecode2 = 0 ;
24092 int val3 ;
24093 int ecode3 = 0 ;
24094 PyObject * obj0 = 0 ;
24095 PyObject * obj1 = 0 ;
24096 PyObject * obj2 = 0 ;
24097 char * kwnames[] = {
24098 (char *) "self",(char *) "month",(char *) "year", NULL
24099 };
24100
24101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24103 if (!SWIG_IsOK(res1)) {
24104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24105 }
24106 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24107 if (obj1) {
24108 ecode2 = SWIG_AsVal_int(obj1, &val2);
24109 if (!SWIG_IsOK(ecode2)) {
24110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24111 }
24112 arg2 = static_cast< wxDateTime::Month >(val2);
24113 }
24114 if (obj2) {
24115 ecode3 = SWIG_AsVal_int(obj2, &val3);
24116 if (!SWIG_IsOK(ecode3)) {
24117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24118 }
24119 arg3 = static_cast< int >(val3);
24120 }
24121 {
24122 PyThreadState* __tstate = wxPyBeginAllowThreads();
24123 result = (arg1)->GetLastMonthDay(arg2,arg3);
24124 wxPyEndAllowThreads(__tstate);
24125 if (PyErr_Occurred()) SWIG_fail;
24126 }
24127 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24128 return resultobj;
24129 fail:
24130 return NULL;
24131 }
24132
24133
24134 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24135 PyObject *resultobj = 0;
24136 wxDateTime *arg1 = (wxDateTime *) 0 ;
24137 int arg2 ;
24138 wxDateTime *result = 0 ;
24139 void *argp1 = 0 ;
24140 int res1 = 0 ;
24141 int val2 ;
24142 int ecode2 = 0 ;
24143 PyObject * obj0 = 0 ;
24144 PyObject * obj1 = 0 ;
24145 char * kwnames[] = {
24146 (char *) "self",(char *) "yday", NULL
24147 };
24148
24149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24151 if (!SWIG_IsOK(res1)) {
24152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24153 }
24154 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24155 ecode2 = SWIG_AsVal_int(obj1, &val2);
24156 if (!SWIG_IsOK(ecode2)) {
24157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24158 }
24159 arg2 = static_cast< int >(val2);
24160 {
24161 PyThreadState* __tstate = wxPyBeginAllowThreads();
24162 {
24163 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24164 result = (wxDateTime *) &_result_ref;
24165 }
24166 wxPyEndAllowThreads(__tstate);
24167 if (PyErr_Occurred()) SWIG_fail;
24168 }
24169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24170 return resultobj;
24171 fail:
24172 return NULL;
24173 }
24174
24175
24176 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24177 PyObject *resultobj = 0;
24178 wxDateTime *arg1 = (wxDateTime *) 0 ;
24179 int arg2 ;
24180 wxDateTime result;
24181 void *argp1 = 0 ;
24182 int res1 = 0 ;
24183 int val2 ;
24184 int ecode2 = 0 ;
24185 PyObject * obj0 = 0 ;
24186 PyObject * obj1 = 0 ;
24187 char * kwnames[] = {
24188 (char *) "self",(char *) "yday", NULL
24189 };
24190
24191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24193 if (!SWIG_IsOK(res1)) {
24194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24195 }
24196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24197 ecode2 = SWIG_AsVal_int(obj1, &val2);
24198 if (!SWIG_IsOK(ecode2)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24200 }
24201 arg2 = static_cast< int >(val2);
24202 {
24203 PyThreadState* __tstate = wxPyBeginAllowThreads();
24204 result = (arg1)->GetYearDay(arg2);
24205 wxPyEndAllowThreads(__tstate);
24206 if (PyErr_Occurred()) SWIG_fail;
24207 }
24208 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216 PyObject *resultobj = 0;
24217 wxDateTime *arg1 = (wxDateTime *) 0 ;
24218 double result;
24219 void *argp1 = 0 ;
24220 int res1 = 0 ;
24221 PyObject *swig_obj[1] ;
24222
24223 if (!args) SWIG_fail;
24224 swig_obj[0] = args;
24225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24228 }
24229 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (double)(arg1)->GetJulianDayNumber();
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 resultobj = SWIG_From_double(static_cast< double >(result));
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24244 PyObject *resultobj = 0;
24245 wxDateTime *arg1 = (wxDateTime *) 0 ;
24246 double result;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 PyObject *swig_obj[1] ;
24250
24251 if (!args) SWIG_fail;
24252 swig_obj[0] = args;
24253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24254 if (!SWIG_IsOK(res1)) {
24255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24256 }
24257 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 result = (double)(arg1)->GetJDN();
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 resultobj = SWIG_From_double(static_cast< double >(result));
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24272 PyObject *resultobj = 0;
24273 wxDateTime *arg1 = (wxDateTime *) 0 ;
24274 double result;
24275 void *argp1 = 0 ;
24276 int res1 = 0 ;
24277 PyObject *swig_obj[1] ;
24278
24279 if (!args) SWIG_fail;
24280 swig_obj[0] = args;
24281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24282 if (!SWIG_IsOK(res1)) {
24283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24284 }
24285 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24286 {
24287 PyThreadState* __tstate = wxPyBeginAllowThreads();
24288 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 resultobj = SWIG_From_double(static_cast< double >(result));
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24300 PyObject *resultobj = 0;
24301 wxDateTime *arg1 = (wxDateTime *) 0 ;
24302 double result;
24303 void *argp1 = 0 ;
24304 int res1 = 0 ;
24305 PyObject *swig_obj[1] ;
24306
24307 if (!args) SWIG_fail;
24308 swig_obj[0] = args;
24309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24310 if (!SWIG_IsOK(res1)) {
24311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24312 }
24313 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24314 {
24315 PyThreadState* __tstate = wxPyBeginAllowThreads();
24316 result = (double)(arg1)->GetMJD();
24317 wxPyEndAllowThreads(__tstate);
24318 if (PyErr_Occurred()) SWIG_fail;
24319 }
24320 resultobj = SWIG_From_double(static_cast< double >(result));
24321 return resultobj;
24322 fail:
24323 return NULL;
24324 }
24325
24326
24327 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24328 PyObject *resultobj = 0;
24329 wxDateTime *arg1 = (wxDateTime *) 0 ;
24330 double result;
24331 void *argp1 = 0 ;
24332 int res1 = 0 ;
24333 PyObject *swig_obj[1] ;
24334
24335 if (!args) SWIG_fail;
24336 swig_obj[0] = args;
24337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24338 if (!SWIG_IsOK(res1)) {
24339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24340 }
24341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 result = (double)(arg1)->GetRataDie();
24345 wxPyEndAllowThreads(__tstate);
24346 if (PyErr_Occurred()) SWIG_fail;
24347 }
24348 resultobj = SWIG_From_double(static_cast< double >(result));
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24356 PyObject *resultobj = 0;
24357 wxDateTime *arg1 = (wxDateTime *) 0 ;
24358 wxDateTime::TimeZone *arg2 = 0 ;
24359 bool arg3 = (bool) false ;
24360 wxDateTime result;
24361 void *argp1 = 0 ;
24362 int res1 = 0 ;
24363 bool temp2 = false ;
24364 bool val3 ;
24365 int ecode3 = 0 ;
24366 PyObject * obj0 = 0 ;
24367 PyObject * obj1 = 0 ;
24368 PyObject * obj2 = 0 ;
24369 char * kwnames[] = {
24370 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24371 };
24372
24373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24377 }
24378 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24379 {
24380 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24381 temp2 = true;
24382 }
24383 if (obj2) {
24384 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24385 if (!SWIG_IsOK(ecode3)) {
24386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24387 }
24388 arg3 = static_cast< bool >(val3);
24389 }
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24397 {
24398 if (temp2) delete arg2;
24399 }
24400 return resultobj;
24401 fail:
24402 {
24403 if (temp2) delete arg2;
24404 }
24405 return NULL;
24406 }
24407
24408
24409 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24410 PyObject *resultobj = 0;
24411 wxDateTime *arg1 = (wxDateTime *) 0 ;
24412 wxDateTime::TimeZone *arg2 = 0 ;
24413 bool arg3 = (bool) false ;
24414 wxDateTime *result = 0 ;
24415 void *argp1 = 0 ;
24416 int res1 = 0 ;
24417 bool temp2 = false ;
24418 bool val3 ;
24419 int ecode3 = 0 ;
24420 PyObject * obj0 = 0 ;
24421 PyObject * obj1 = 0 ;
24422 PyObject * obj2 = 0 ;
24423 char * kwnames[] = {
24424 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24425 };
24426
24427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24429 if (!SWIG_IsOK(res1)) {
24430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24431 }
24432 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24433 {
24434 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24435 temp2 = true;
24436 }
24437 if (obj2) {
24438 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24439 if (!SWIG_IsOK(ecode3)) {
24440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24441 }
24442 arg3 = static_cast< bool >(val3);
24443 }
24444 {
24445 PyThreadState* __tstate = wxPyBeginAllowThreads();
24446 {
24447 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24448 result = (wxDateTime *) &_result_ref;
24449 }
24450 wxPyEndAllowThreads(__tstate);
24451 if (PyErr_Occurred()) SWIG_fail;
24452 }
24453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24454 {
24455 if (temp2) delete arg2;
24456 }
24457 return resultobj;
24458 fail:
24459 {
24460 if (temp2) delete arg2;
24461 }
24462 return NULL;
24463 }
24464
24465
24466 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24467 PyObject *resultobj = 0;
24468 wxDateTime *arg1 = (wxDateTime *) 0 ;
24469 wxDateTime::TimeZone *arg2 = 0 ;
24470 bool arg3 = (bool) false ;
24471 wxDateTime result;
24472 void *argp1 = 0 ;
24473 int res1 = 0 ;
24474 bool temp2 = false ;
24475 bool val3 ;
24476 int ecode3 = 0 ;
24477 PyObject * obj0 = 0 ;
24478 PyObject * obj1 = 0 ;
24479 PyObject * obj2 = 0 ;
24480 char * kwnames[] = {
24481 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24482 };
24483
24484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24488 }
24489 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24490 {
24491 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24492 temp2 = true;
24493 }
24494 if (obj2) {
24495 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24496 if (!SWIG_IsOK(ecode3)) {
24497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24498 }
24499 arg3 = static_cast< bool >(val3);
24500 }
24501 {
24502 PyThreadState* __tstate = wxPyBeginAllowThreads();
24503 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24504 wxPyEndAllowThreads(__tstate);
24505 if (PyErr_Occurred()) SWIG_fail;
24506 }
24507 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24508 {
24509 if (temp2) delete arg2;
24510 }
24511 return resultobj;
24512 fail:
24513 {
24514 if (temp2) delete arg2;
24515 }
24516 return NULL;
24517 }
24518
24519
24520 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24521 PyObject *resultobj = 0;
24522 wxDateTime *arg1 = (wxDateTime *) 0 ;
24523 wxDateTime::TimeZone *arg2 = 0 ;
24524 bool arg3 = (bool) false ;
24525 wxDateTime *result = 0 ;
24526 void *argp1 = 0 ;
24527 int res1 = 0 ;
24528 bool temp2 = false ;
24529 bool val3 ;
24530 int ecode3 = 0 ;
24531 PyObject * obj0 = 0 ;
24532 PyObject * obj1 = 0 ;
24533 PyObject * obj2 = 0 ;
24534 char * kwnames[] = {
24535 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24536 };
24537
24538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) 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_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24542 }
24543 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24544 {
24545 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24546 temp2 = true;
24547 }
24548 if (obj2) {
24549 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24550 if (!SWIG_IsOK(ecode3)) {
24551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24552 }
24553 arg3 = static_cast< bool >(val3);
24554 }
24555 {
24556 PyThreadState* __tstate = wxPyBeginAllowThreads();
24557 {
24558 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24559 result = (wxDateTime *) &_result_ref;
24560 }
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24565 {
24566 if (temp2) delete arg2;
24567 }
24568 return resultobj;
24569 fail:
24570 {
24571 if (temp2) delete arg2;
24572 }
24573 return NULL;
24574 }
24575
24576
24577 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24578 PyObject *resultobj = 0;
24579 wxDateTime *arg1 = (wxDateTime *) 0 ;
24580 bool arg2 = (bool) false ;
24581 wxDateTime result;
24582 void *argp1 = 0 ;
24583 int res1 = 0 ;
24584 bool val2 ;
24585 int ecode2 = 0 ;
24586 PyObject * obj0 = 0 ;
24587 PyObject * obj1 = 0 ;
24588 char * kwnames[] = {
24589 (char *) "self",(char *) "noDST", NULL
24590 };
24591
24592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24594 if (!SWIG_IsOK(res1)) {
24595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24596 }
24597 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24598 if (obj1) {
24599 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24600 if (!SWIG_IsOK(ecode2)) {
24601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24602 }
24603 arg2 = static_cast< bool >(val2);
24604 }
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24608 wxPyEndAllowThreads(__tstate);
24609 if (PyErr_Occurred()) SWIG_fail;
24610 }
24611 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj = 0;
24620 wxDateTime *arg1 = (wxDateTime *) 0 ;
24621 bool arg2 = (bool) false ;
24622 wxDateTime *result = 0 ;
24623 void *argp1 = 0 ;
24624 int res1 = 0 ;
24625 bool val2 ;
24626 int ecode2 = 0 ;
24627 PyObject * obj0 = 0 ;
24628 PyObject * obj1 = 0 ;
24629 char * kwnames[] = {
24630 (char *) "self",(char *) "noDST", NULL
24631 };
24632
24633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24635 if (!SWIG_IsOK(res1)) {
24636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24637 }
24638 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24639 if (obj1) {
24640 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24641 if (!SWIG_IsOK(ecode2)) {
24642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24643 }
24644 arg2 = static_cast< bool >(val2);
24645 }
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 {
24649 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24650 result = (wxDateTime *) &_result_ref;
24651 }
24652 wxPyEndAllowThreads(__tstate);
24653 if (PyErr_Occurred()) SWIG_fail;
24654 }
24655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj = 0;
24664 wxDateTime *arg1 = (wxDateTime *) 0 ;
24665 bool arg2 = (bool) false ;
24666 wxDateTime result;
24667 void *argp1 = 0 ;
24668 int res1 = 0 ;
24669 bool val2 ;
24670 int ecode2 = 0 ;
24671 PyObject * obj0 = 0 ;
24672 PyObject * obj1 = 0 ;
24673 char * kwnames[] = {
24674 (char *) "self",(char *) "noDST", NULL
24675 };
24676
24677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24679 if (!SWIG_IsOK(res1)) {
24680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24681 }
24682 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24683 if (obj1) {
24684 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24685 if (!SWIG_IsOK(ecode2)) {
24686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24687 }
24688 arg2 = static_cast< bool >(val2);
24689 }
24690 {
24691 PyThreadState* __tstate = wxPyBeginAllowThreads();
24692 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24693 wxPyEndAllowThreads(__tstate);
24694 if (PyErr_Occurred()) SWIG_fail;
24695 }
24696 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24697 return resultobj;
24698 fail:
24699 return NULL;
24700 }
24701
24702
24703 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24704 PyObject *resultobj = 0;
24705 wxDateTime *arg1 = (wxDateTime *) 0 ;
24706 bool arg2 = (bool) false ;
24707 wxDateTime *result = 0 ;
24708 void *argp1 = 0 ;
24709 int res1 = 0 ;
24710 bool val2 ;
24711 int ecode2 = 0 ;
24712 PyObject * obj0 = 0 ;
24713 PyObject * obj1 = 0 ;
24714 char * kwnames[] = {
24715 (char *) "self",(char *) "noDST", NULL
24716 };
24717
24718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24720 if (!SWIG_IsOK(res1)) {
24721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24722 }
24723 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24724 if (obj1) {
24725 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24726 if (!SWIG_IsOK(ecode2)) {
24727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24728 }
24729 arg2 = static_cast< bool >(val2);
24730 }
24731 {
24732 PyThreadState* __tstate = wxPyBeginAllowThreads();
24733 {
24734 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24735 result = (wxDateTime *) &_result_ref;
24736 }
24737 wxPyEndAllowThreads(__tstate);
24738 if (PyErr_Occurred()) SWIG_fail;
24739 }
24740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj = 0;
24749 wxDateTime *arg1 = (wxDateTime *) 0 ;
24750 bool arg2 = (bool) false ;
24751 wxDateTime result;
24752 void *argp1 = 0 ;
24753 int res1 = 0 ;
24754 bool val2 ;
24755 int ecode2 = 0 ;
24756 PyObject * obj0 = 0 ;
24757 PyObject * obj1 = 0 ;
24758 char * kwnames[] = {
24759 (char *) "self",(char *) "noDST", NULL
24760 };
24761
24762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24764 if (!SWIG_IsOK(res1)) {
24765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24766 }
24767 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24768 if (obj1) {
24769 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24770 if (!SWIG_IsOK(ecode2)) {
24771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24772 }
24773 arg2 = static_cast< bool >(val2);
24774 }
24775 {
24776 PyThreadState* __tstate = wxPyBeginAllowThreads();
24777 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24778 wxPyEndAllowThreads(__tstate);
24779 if (PyErr_Occurred()) SWIG_fail;
24780 }
24781 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj = 0;
24790 wxDateTime *arg1 = (wxDateTime *) 0 ;
24791 bool arg2 = (bool) false ;
24792 wxDateTime *result = 0 ;
24793 void *argp1 = 0 ;
24794 int res1 = 0 ;
24795 bool val2 ;
24796 int ecode2 = 0 ;
24797 PyObject * obj0 = 0 ;
24798 PyObject * obj1 = 0 ;
24799 char * kwnames[] = {
24800 (char *) "self",(char *) "noDST", NULL
24801 };
24802
24803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24805 if (!SWIG_IsOK(res1)) {
24806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24807 }
24808 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24809 if (obj1) {
24810 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24811 if (!SWIG_IsOK(ecode2)) {
24812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24813 }
24814 arg2 = static_cast< bool >(val2);
24815 }
24816 {
24817 PyThreadState* __tstate = wxPyBeginAllowThreads();
24818 {
24819 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24820 result = (wxDateTime *) &_result_ref;
24821 }
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24833 PyObject *resultobj = 0;
24834 wxDateTime *arg1 = (wxDateTime *) 0 ;
24835 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24836 int result;
24837 void *argp1 = 0 ;
24838 int res1 = 0 ;
24839 int val2 ;
24840 int ecode2 = 0 ;
24841 PyObject * obj0 = 0 ;
24842 PyObject * obj1 = 0 ;
24843 char * kwnames[] = {
24844 (char *) "self",(char *) "country", NULL
24845 };
24846
24847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) 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_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24851 }
24852 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24853 if (obj1) {
24854 ecode2 = SWIG_AsVal_int(obj1, &val2);
24855 if (!SWIG_IsOK(ecode2)) {
24856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24857 }
24858 arg2 = static_cast< wxDateTime::Country >(val2);
24859 }
24860 {
24861 PyThreadState* __tstate = wxPyBeginAllowThreads();
24862 result = (int)(arg1)->IsDST(arg2);
24863 wxPyEndAllowThreads(__tstate);
24864 if (PyErr_Occurred()) SWIG_fail;
24865 }
24866 resultobj = SWIG_From_int(static_cast< int >(result));
24867 return resultobj;
24868 fail:
24869 return NULL;
24870 }
24871
24872
24873 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24874 PyObject *resultobj = 0;
24875 wxDateTime *arg1 = (wxDateTime *) 0 ;
24876 bool result;
24877 void *argp1 = 0 ;
24878 int res1 = 0 ;
24879 PyObject *swig_obj[1] ;
24880
24881 if (!args) SWIG_fail;
24882 swig_obj[0] = args;
24883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24884 if (!SWIG_IsOK(res1)) {
24885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24886 }
24887 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24888 {
24889 PyThreadState* __tstate = wxPyBeginAllowThreads();
24890 result = (bool)((wxDateTime const *)arg1)->IsValid();
24891 wxPyEndAllowThreads(__tstate);
24892 if (PyErr_Occurred()) SWIG_fail;
24893 }
24894 {
24895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24896 }
24897 return resultobj;
24898 fail:
24899 return NULL;
24900 }
24901
24902
24903 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24904 PyObject *resultobj = 0;
24905 wxDateTime *arg1 = (wxDateTime *) 0 ;
24906 time_t result;
24907 void *argp1 = 0 ;
24908 int res1 = 0 ;
24909 PyObject *swig_obj[1] ;
24910
24911 if (!args) SWIG_fail;
24912 swig_obj[0] = args;
24913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24914 if (!SWIG_IsOK(res1)) {
24915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24916 }
24917 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24918 {
24919 PyThreadState* __tstate = wxPyBeginAllowThreads();
24920 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24921 wxPyEndAllowThreads(__tstate);
24922 if (PyErr_Occurred()) SWIG_fail;
24923 }
24924 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24925 return resultobj;
24926 fail:
24927 return NULL;
24928 }
24929
24930
24931 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24932 PyObject *resultobj = 0;
24933 wxDateTime *arg1 = (wxDateTime *) 0 ;
24934 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24935 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24936 int result;
24937 void *argp1 = 0 ;
24938 int res1 = 0 ;
24939 bool temp2 = false ;
24940 PyObject * obj0 = 0 ;
24941 PyObject * obj1 = 0 ;
24942 char * kwnames[] = {
24943 (char *) "self",(char *) "tz", NULL
24944 };
24945
24946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24948 if (!SWIG_IsOK(res1)) {
24949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24950 }
24951 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24952 if (obj1) {
24953 {
24954 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24955 temp2 = true;
24956 }
24957 }
24958 {
24959 PyThreadState* __tstate = wxPyBeginAllowThreads();
24960 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24961 wxPyEndAllowThreads(__tstate);
24962 if (PyErr_Occurred()) SWIG_fail;
24963 }
24964 resultobj = SWIG_From_int(static_cast< int >(result));
24965 {
24966 if (temp2) delete arg2;
24967 }
24968 return resultobj;
24969 fail:
24970 {
24971 if (temp2) delete arg2;
24972 }
24973 return NULL;
24974 }
24975
24976
24977 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24978 PyObject *resultobj = 0;
24979 wxDateTime *arg1 = (wxDateTime *) 0 ;
24980 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24981 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24982 wxDateTime::Month result;
24983 void *argp1 = 0 ;
24984 int res1 = 0 ;
24985 bool temp2 = false ;
24986 PyObject * obj0 = 0 ;
24987 PyObject * obj1 = 0 ;
24988 char * kwnames[] = {
24989 (char *) "self",(char *) "tz", NULL
24990 };
24991
24992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24994 if (!SWIG_IsOK(res1)) {
24995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24996 }
24997 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24998 if (obj1) {
24999 {
25000 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25001 temp2 = true;
25002 }
25003 }
25004 {
25005 PyThreadState* __tstate = wxPyBeginAllowThreads();
25006 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25007 wxPyEndAllowThreads(__tstate);
25008 if (PyErr_Occurred()) SWIG_fail;
25009 }
25010 resultobj = SWIG_From_int(static_cast< int >(result));
25011 {
25012 if (temp2) delete arg2;
25013 }
25014 return resultobj;
25015 fail:
25016 {
25017 if (temp2) delete arg2;
25018 }
25019 return NULL;
25020 }
25021
25022
25023 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25024 PyObject *resultobj = 0;
25025 wxDateTime *arg1 = (wxDateTime *) 0 ;
25026 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25027 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25028 int result;
25029 void *argp1 = 0 ;
25030 int res1 = 0 ;
25031 bool temp2 = false ;
25032 PyObject * obj0 = 0 ;
25033 PyObject * obj1 = 0 ;
25034 char * kwnames[] = {
25035 (char *) "self",(char *) "tz", NULL
25036 };
25037
25038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25040 if (!SWIG_IsOK(res1)) {
25041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25042 }
25043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25044 if (obj1) {
25045 {
25046 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25047 temp2 = true;
25048 }
25049 }
25050 {
25051 PyThreadState* __tstate = wxPyBeginAllowThreads();
25052 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25053 wxPyEndAllowThreads(__tstate);
25054 if (PyErr_Occurred()) SWIG_fail;
25055 }
25056 resultobj = SWIG_From_int(static_cast< int >(result));
25057 {
25058 if (temp2) delete arg2;
25059 }
25060 return resultobj;
25061 fail:
25062 {
25063 if (temp2) delete arg2;
25064 }
25065 return NULL;
25066 }
25067
25068
25069 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25070 PyObject *resultobj = 0;
25071 wxDateTime *arg1 = (wxDateTime *) 0 ;
25072 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25073 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25074 wxDateTime::WeekDay result;
25075 void *argp1 = 0 ;
25076 int res1 = 0 ;
25077 bool temp2 = false ;
25078 PyObject * obj0 = 0 ;
25079 PyObject * obj1 = 0 ;
25080 char * kwnames[] = {
25081 (char *) "self",(char *) "tz", NULL
25082 };
25083
25084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25086 if (!SWIG_IsOK(res1)) {
25087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25088 }
25089 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25090 if (obj1) {
25091 {
25092 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25093 temp2 = true;
25094 }
25095 }
25096 {
25097 PyThreadState* __tstate = wxPyBeginAllowThreads();
25098 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25099 wxPyEndAllowThreads(__tstate);
25100 if (PyErr_Occurred()) SWIG_fail;
25101 }
25102 resultobj = SWIG_From_int(static_cast< int >(result));
25103 {
25104 if (temp2) delete arg2;
25105 }
25106 return resultobj;
25107 fail:
25108 {
25109 if (temp2) delete arg2;
25110 }
25111 return NULL;
25112 }
25113
25114
25115 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25116 PyObject *resultobj = 0;
25117 wxDateTime *arg1 = (wxDateTime *) 0 ;
25118 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25119 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25120 int result;
25121 void *argp1 = 0 ;
25122 int res1 = 0 ;
25123 bool temp2 = false ;
25124 PyObject * obj0 = 0 ;
25125 PyObject * obj1 = 0 ;
25126 char * kwnames[] = {
25127 (char *) "self",(char *) "tz", NULL
25128 };
25129
25130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25132 if (!SWIG_IsOK(res1)) {
25133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25134 }
25135 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25136 if (obj1) {
25137 {
25138 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25139 temp2 = true;
25140 }
25141 }
25142 {
25143 PyThreadState* __tstate = wxPyBeginAllowThreads();
25144 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25145 wxPyEndAllowThreads(__tstate);
25146 if (PyErr_Occurred()) SWIG_fail;
25147 }
25148 resultobj = SWIG_From_int(static_cast< int >(result));
25149 {
25150 if (temp2) delete arg2;
25151 }
25152 return resultobj;
25153 fail:
25154 {
25155 if (temp2) delete arg2;
25156 }
25157 return NULL;
25158 }
25159
25160
25161 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25162 PyObject *resultobj = 0;
25163 wxDateTime *arg1 = (wxDateTime *) 0 ;
25164 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25165 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25166 int result;
25167 void *argp1 = 0 ;
25168 int res1 = 0 ;
25169 bool temp2 = false ;
25170 PyObject * obj0 = 0 ;
25171 PyObject * obj1 = 0 ;
25172 char * kwnames[] = {
25173 (char *) "self",(char *) "tz", NULL
25174 };
25175
25176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25178 if (!SWIG_IsOK(res1)) {
25179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25180 }
25181 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25182 if (obj1) {
25183 {
25184 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25185 temp2 = true;
25186 }
25187 }
25188 {
25189 PyThreadState* __tstate = wxPyBeginAllowThreads();
25190 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25191 wxPyEndAllowThreads(__tstate);
25192 if (PyErr_Occurred()) SWIG_fail;
25193 }
25194 resultobj = SWIG_From_int(static_cast< int >(result));
25195 {
25196 if (temp2) delete arg2;
25197 }
25198 return resultobj;
25199 fail:
25200 {
25201 if (temp2) delete arg2;
25202 }
25203 return NULL;
25204 }
25205
25206
25207 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj = 0;
25209 wxDateTime *arg1 = (wxDateTime *) 0 ;
25210 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25211 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25212 int result;
25213 void *argp1 = 0 ;
25214 int res1 = 0 ;
25215 bool temp2 = false ;
25216 PyObject * obj0 = 0 ;
25217 PyObject * obj1 = 0 ;
25218 char * kwnames[] = {
25219 (char *) "self",(char *) "tz", NULL
25220 };
25221
25222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25224 if (!SWIG_IsOK(res1)) {
25225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25226 }
25227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25228 if (obj1) {
25229 {
25230 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25231 temp2 = true;
25232 }
25233 }
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_From_int(static_cast< int >(result));
25241 {
25242 if (temp2) delete arg2;
25243 }
25244 return resultobj;
25245 fail:
25246 {
25247 if (temp2) delete arg2;
25248 }
25249 return NULL;
25250 }
25251
25252
25253 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25254 PyObject *resultobj = 0;
25255 wxDateTime *arg1 = (wxDateTime *) 0 ;
25256 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25257 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25258 int result;
25259 void *argp1 = 0 ;
25260 int res1 = 0 ;
25261 bool temp2 = false ;
25262 PyObject * obj0 = 0 ;
25263 PyObject * obj1 = 0 ;
25264 char * kwnames[] = {
25265 (char *) "self",(char *) "tz", NULL
25266 };
25267
25268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25270 if (!SWIG_IsOK(res1)) {
25271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25272 }
25273 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25274 if (obj1) {
25275 {
25276 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25277 temp2 = true;
25278 }
25279 }
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 resultobj = SWIG_From_int(static_cast< int >(result));
25287 {
25288 if (temp2) delete arg2;
25289 }
25290 return resultobj;
25291 fail:
25292 {
25293 if (temp2) delete arg2;
25294 }
25295 return NULL;
25296 }
25297
25298
25299 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25300 PyObject *resultobj = 0;
25301 wxDateTime *arg1 = (wxDateTime *) 0 ;
25302 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25303 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25304 int result;
25305 void *argp1 = 0 ;
25306 int res1 = 0 ;
25307 bool temp2 = false ;
25308 PyObject * obj0 = 0 ;
25309 PyObject * obj1 = 0 ;
25310 char * kwnames[] = {
25311 (char *) "self",(char *) "tz", NULL
25312 };
25313
25314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25316 if (!SWIG_IsOK(res1)) {
25317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25318 }
25319 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25320 if (obj1) {
25321 {
25322 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25323 temp2 = true;
25324 }
25325 }
25326 {
25327 PyThreadState* __tstate = wxPyBeginAllowThreads();
25328 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25329 wxPyEndAllowThreads(__tstate);
25330 if (PyErr_Occurred()) SWIG_fail;
25331 }
25332 resultobj = SWIG_From_int(static_cast< int >(result));
25333 {
25334 if (temp2) delete arg2;
25335 }
25336 return resultobj;
25337 fail:
25338 {
25339 if (temp2) delete arg2;
25340 }
25341 return NULL;
25342 }
25343
25344
25345 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25346 PyObject *resultobj = 0;
25347 wxDateTime *arg1 = (wxDateTime *) 0 ;
25348 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25349 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25350 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25351 int result;
25352 void *argp1 = 0 ;
25353 int res1 = 0 ;
25354 int val2 ;
25355 int ecode2 = 0 ;
25356 bool temp3 = false ;
25357 PyObject * obj0 = 0 ;
25358 PyObject * obj1 = 0 ;
25359 PyObject * obj2 = 0 ;
25360 char * kwnames[] = {
25361 (char *) "self",(char *) "flags",(char *) "tz", NULL
25362 };
25363
25364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25366 if (!SWIG_IsOK(res1)) {
25367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25368 }
25369 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25370 if (obj1) {
25371 ecode2 = SWIG_AsVal_int(obj1, &val2);
25372 if (!SWIG_IsOK(ecode2)) {
25373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25374 }
25375 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25376 }
25377 if (obj2) {
25378 {
25379 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25380 temp3 = true;
25381 }
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 resultobj = SWIG_From_int(static_cast< int >(result));
25390 {
25391 if (temp3) delete arg3;
25392 }
25393 return resultobj;
25394 fail:
25395 {
25396 if (temp3) delete arg3;
25397 }
25398 return NULL;
25399 }
25400
25401
25402 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25403 PyObject *resultobj = 0;
25404 wxDateTime *arg1 = (wxDateTime *) 0 ;
25405 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25406 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25407 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25408 int result;
25409 void *argp1 = 0 ;
25410 int res1 = 0 ;
25411 int val2 ;
25412 int ecode2 = 0 ;
25413 bool temp3 = false ;
25414 PyObject * obj0 = 0 ;
25415 PyObject * obj1 = 0 ;
25416 PyObject * obj2 = 0 ;
25417 char * kwnames[] = {
25418 (char *) "self",(char *) "flags",(char *) "tz", NULL
25419 };
25420
25421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25423 if (!SWIG_IsOK(res1)) {
25424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25425 }
25426 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25427 if (obj1) {
25428 ecode2 = SWIG_AsVal_int(obj1, &val2);
25429 if (!SWIG_IsOK(ecode2)) {
25430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25431 }
25432 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25433 }
25434 if (obj2) {
25435 {
25436 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25437 temp3 = true;
25438 }
25439 }
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25443 wxPyEndAllowThreads(__tstate);
25444 if (PyErr_Occurred()) SWIG_fail;
25445 }
25446 resultobj = SWIG_From_int(static_cast< int >(result));
25447 {
25448 if (temp3) delete arg3;
25449 }
25450 return resultobj;
25451 fail:
25452 {
25453 if (temp3) delete arg3;
25454 }
25455 return NULL;
25456 }
25457
25458
25459 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25460 PyObject *resultobj = 0;
25461 wxDateTime *arg1 = (wxDateTime *) 0 ;
25462 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25463 bool result;
25464 void *argp1 = 0 ;
25465 int res1 = 0 ;
25466 int val2 ;
25467 int ecode2 = 0 ;
25468 PyObject * obj0 = 0 ;
25469 PyObject * obj1 = 0 ;
25470 char * kwnames[] = {
25471 (char *) "self",(char *) "country", NULL
25472 };
25473
25474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25476 if (!SWIG_IsOK(res1)) {
25477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25478 }
25479 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25480 if (obj1) {
25481 ecode2 = SWIG_AsVal_int(obj1, &val2);
25482 if (!SWIG_IsOK(ecode2)) {
25483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25484 }
25485 arg2 = static_cast< wxDateTime::Country >(val2);
25486 }
25487 {
25488 PyThreadState* __tstate = wxPyBeginAllowThreads();
25489 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25490 wxPyEndAllowThreads(__tstate);
25491 if (PyErr_Occurred()) SWIG_fail;
25492 }
25493 {
25494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25495 }
25496 return resultobj;
25497 fail:
25498 return NULL;
25499 }
25500
25501
25502 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25503 PyObject *resultobj = 0;
25504 wxDateTime *arg1 = (wxDateTime *) 0 ;
25505 wxDateTime *arg2 = 0 ;
25506 bool result;
25507 void *argp1 = 0 ;
25508 int res1 = 0 ;
25509 void *argp2 = 0 ;
25510 int res2 = 0 ;
25511 PyObject * obj0 = 0 ;
25512 PyObject * obj1 = 0 ;
25513 char * kwnames[] = {
25514 (char *) "self",(char *) "datetime", NULL
25515 };
25516
25517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25519 if (!SWIG_IsOK(res1)) {
25520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25521 }
25522 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25524 if (!SWIG_IsOK(res2)) {
25525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25526 }
25527 if (!argp2) {
25528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25529 }
25530 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25534 wxPyEndAllowThreads(__tstate);
25535 if (PyErr_Occurred()) SWIG_fail;
25536 }
25537 {
25538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25539 }
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj = 0;
25548 wxDateTime *arg1 = (wxDateTime *) 0 ;
25549 wxDateTime *arg2 = 0 ;
25550 bool result;
25551 void *argp1 = 0 ;
25552 int res1 = 0 ;
25553 void *argp2 = 0 ;
25554 int res2 = 0 ;
25555 PyObject * obj0 = 0 ;
25556 PyObject * obj1 = 0 ;
25557 char * kwnames[] = {
25558 (char *) "self",(char *) "datetime", NULL
25559 };
25560
25561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25563 if (!SWIG_IsOK(res1)) {
25564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25565 }
25566 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25567 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25568 if (!SWIG_IsOK(res2)) {
25569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25570 }
25571 if (!argp2) {
25572 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25573 }
25574 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 {
25582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25583 }
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj = 0;
25592 wxDateTime *arg1 = (wxDateTime *) 0 ;
25593 wxDateTime *arg2 = 0 ;
25594 bool result;
25595 void *argp1 = 0 ;
25596 int res1 = 0 ;
25597 void *argp2 = 0 ;
25598 int res2 = 0 ;
25599 PyObject * obj0 = 0 ;
25600 PyObject * obj1 = 0 ;
25601 char * kwnames[] = {
25602 (char *) "self",(char *) "datetime", NULL
25603 };
25604
25605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25607 if (!SWIG_IsOK(res1)) {
25608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25609 }
25610 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25611 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25612 if (!SWIG_IsOK(res2)) {
25613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25614 }
25615 if (!argp2) {
25616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25617 }
25618 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25619 {
25620 PyThreadState* __tstate = wxPyBeginAllowThreads();
25621 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25622 wxPyEndAllowThreads(__tstate);
25623 if (PyErr_Occurred()) SWIG_fail;
25624 }
25625 {
25626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25627 }
25628 return resultobj;
25629 fail:
25630 return NULL;
25631 }
25632
25633
25634 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25635 PyObject *resultobj = 0;
25636 wxDateTime *arg1 = (wxDateTime *) 0 ;
25637 wxDateTime *arg2 = 0 ;
25638 wxDateTime *arg3 = 0 ;
25639 bool result;
25640 void *argp1 = 0 ;
25641 int res1 = 0 ;
25642 void *argp2 = 0 ;
25643 int res2 = 0 ;
25644 void *argp3 = 0 ;
25645 int res3 = 0 ;
25646 PyObject * obj0 = 0 ;
25647 PyObject * obj1 = 0 ;
25648 PyObject * obj2 = 0 ;
25649 char * kwnames[] = {
25650 (char *) "self",(char *) "t1",(char *) "t2", NULL
25651 };
25652
25653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25655 if (!SWIG_IsOK(res1)) {
25656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25657 }
25658 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25659 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25660 if (!SWIG_IsOK(res2)) {
25661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25662 }
25663 if (!argp2) {
25664 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25665 }
25666 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25667 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25668 if (!SWIG_IsOK(res3)) {
25669 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25670 }
25671 if (!argp3) {
25672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25673 }
25674 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25675 {
25676 PyThreadState* __tstate = wxPyBeginAllowThreads();
25677 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25678 wxPyEndAllowThreads(__tstate);
25679 if (PyErr_Occurred()) SWIG_fail;
25680 }
25681 {
25682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25683 }
25684 return resultobj;
25685 fail:
25686 return NULL;
25687 }
25688
25689
25690 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25691 PyObject *resultobj = 0;
25692 wxDateTime *arg1 = (wxDateTime *) 0 ;
25693 wxDateTime *arg2 = 0 ;
25694 wxDateTime *arg3 = 0 ;
25695 bool result;
25696 void *argp1 = 0 ;
25697 int res1 = 0 ;
25698 void *argp2 = 0 ;
25699 int res2 = 0 ;
25700 void *argp3 = 0 ;
25701 int res3 = 0 ;
25702 PyObject * obj0 = 0 ;
25703 PyObject * obj1 = 0 ;
25704 PyObject * obj2 = 0 ;
25705 char * kwnames[] = {
25706 (char *) "self",(char *) "t1",(char *) "t2", NULL
25707 };
25708
25709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25711 if (!SWIG_IsOK(res1)) {
25712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25713 }
25714 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25716 if (!SWIG_IsOK(res2)) {
25717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25718 }
25719 if (!argp2) {
25720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25721 }
25722 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25723 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25724 if (!SWIG_IsOK(res3)) {
25725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25726 }
25727 if (!argp3) {
25728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25729 }
25730 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25731 {
25732 PyThreadState* __tstate = wxPyBeginAllowThreads();
25733 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25734 wxPyEndAllowThreads(__tstate);
25735 if (PyErr_Occurred()) SWIG_fail;
25736 }
25737 {
25738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25739 }
25740 return resultobj;
25741 fail:
25742 return NULL;
25743 }
25744
25745
25746 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25747 PyObject *resultobj = 0;
25748 wxDateTime *arg1 = (wxDateTime *) 0 ;
25749 wxDateTime *arg2 = 0 ;
25750 bool result;
25751 void *argp1 = 0 ;
25752 int res1 = 0 ;
25753 void *argp2 = 0 ;
25754 int res2 = 0 ;
25755 PyObject * obj0 = 0 ;
25756 PyObject * obj1 = 0 ;
25757 char * kwnames[] = {
25758 (char *) "self",(char *) "dt", NULL
25759 };
25760
25761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25763 if (!SWIG_IsOK(res1)) {
25764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25765 }
25766 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25767 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25768 if (!SWIG_IsOK(res2)) {
25769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25770 }
25771 if (!argp2) {
25772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25773 }
25774 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25775 {
25776 PyThreadState* __tstate = wxPyBeginAllowThreads();
25777 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25778 wxPyEndAllowThreads(__tstate);
25779 if (PyErr_Occurred()) SWIG_fail;
25780 }
25781 {
25782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25783 }
25784 return resultobj;
25785 fail:
25786 return NULL;
25787 }
25788
25789
25790 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25791 PyObject *resultobj = 0;
25792 wxDateTime *arg1 = (wxDateTime *) 0 ;
25793 wxDateTime *arg2 = 0 ;
25794 bool result;
25795 void *argp1 = 0 ;
25796 int res1 = 0 ;
25797 void *argp2 = 0 ;
25798 int res2 = 0 ;
25799 PyObject * obj0 = 0 ;
25800 PyObject * obj1 = 0 ;
25801 char * kwnames[] = {
25802 (char *) "self",(char *) "dt", NULL
25803 };
25804
25805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25807 if (!SWIG_IsOK(res1)) {
25808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25809 }
25810 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25811 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25812 if (!SWIG_IsOK(res2)) {
25813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25814 }
25815 if (!argp2) {
25816 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25817 }
25818 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25819 {
25820 PyThreadState* __tstate = wxPyBeginAllowThreads();
25821 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25822 wxPyEndAllowThreads(__tstate);
25823 if (PyErr_Occurred()) SWIG_fail;
25824 }
25825 {
25826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25827 }
25828 return resultobj;
25829 fail:
25830 return NULL;
25831 }
25832
25833
25834 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25835 PyObject *resultobj = 0;
25836 wxDateTime *arg1 = (wxDateTime *) 0 ;
25837 wxDateTime *arg2 = 0 ;
25838 wxTimeSpan *arg3 = 0 ;
25839 bool result;
25840 void *argp1 = 0 ;
25841 int res1 = 0 ;
25842 void *argp2 = 0 ;
25843 int res2 = 0 ;
25844 void *argp3 = 0 ;
25845 int res3 = 0 ;
25846 PyObject * obj0 = 0 ;
25847 PyObject * obj1 = 0 ;
25848 PyObject * obj2 = 0 ;
25849 char * kwnames[] = {
25850 (char *) "self",(char *) "dt",(char *) "ts", NULL
25851 };
25852
25853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25855 if (!SWIG_IsOK(res1)) {
25856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25857 }
25858 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25859 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25860 if (!SWIG_IsOK(res2)) {
25861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25862 }
25863 if (!argp2) {
25864 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25865 }
25866 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25867 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25868 if (!SWIG_IsOK(res3)) {
25869 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25870 }
25871 if (!argp3) {
25872 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25873 }
25874 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25875 {
25876 PyThreadState* __tstate = wxPyBeginAllowThreads();
25877 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25878 wxPyEndAllowThreads(__tstate);
25879 if (PyErr_Occurred()) SWIG_fail;
25880 }
25881 {
25882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25883 }
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25891 PyObject *resultobj = 0;
25892 wxDateTime *arg1 = (wxDateTime *) 0 ;
25893 wxTimeSpan *arg2 = 0 ;
25894 wxDateTime *result = 0 ;
25895 void *argp1 = 0 ;
25896 int res1 = 0 ;
25897 void *argp2 = 0 ;
25898 int res2 = 0 ;
25899 PyObject * obj0 = 0 ;
25900 PyObject * obj1 = 0 ;
25901 char * kwnames[] = {
25902 (char *) "self",(char *) "diff", NULL
25903 };
25904
25905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25907 if (!SWIG_IsOK(res1)) {
25908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25909 }
25910 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25911 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25912 if (!SWIG_IsOK(res2)) {
25913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25914 }
25915 if (!argp2) {
25916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25917 }
25918 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25919 {
25920 PyThreadState* __tstate = wxPyBeginAllowThreads();
25921 {
25922 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25923 result = (wxDateTime *) &_result_ref;
25924 }
25925 wxPyEndAllowThreads(__tstate);
25926 if (PyErr_Occurred()) SWIG_fail;
25927 }
25928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25936 PyObject *resultobj = 0;
25937 wxDateTime *arg1 = (wxDateTime *) 0 ;
25938 wxDateSpan *arg2 = 0 ;
25939 wxDateTime *result = 0 ;
25940 void *argp1 = 0 ;
25941 int res1 = 0 ;
25942 void *argp2 = 0 ;
25943 int res2 = 0 ;
25944 PyObject * obj0 = 0 ;
25945 PyObject * obj1 = 0 ;
25946 char * kwnames[] = {
25947 (char *) "self",(char *) "diff", NULL
25948 };
25949
25950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25952 if (!SWIG_IsOK(res1)) {
25953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25954 }
25955 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25957 if (!SWIG_IsOK(res2)) {
25958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25959 }
25960 if (!argp2) {
25961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25962 }
25963 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 {
25967 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25968 result = (wxDateTime *) &_result_ref;
25969 }
25970 wxPyEndAllowThreads(__tstate);
25971 if (PyErr_Occurred()) SWIG_fail;
25972 }
25973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25974 return resultobj;
25975 fail:
25976 return NULL;
25977 }
25978
25979
25980 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25981 PyObject *resultobj = 0;
25982 wxDateTime *arg1 = (wxDateTime *) 0 ;
25983 wxTimeSpan *arg2 = 0 ;
25984 wxDateTime *result = 0 ;
25985 void *argp1 = 0 ;
25986 int res1 = 0 ;
25987 void *argp2 = 0 ;
25988 int res2 = 0 ;
25989 PyObject * obj0 = 0 ;
25990 PyObject * obj1 = 0 ;
25991 char * kwnames[] = {
25992 (char *) "self",(char *) "diff", NULL
25993 };
25994
25995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
25996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25997 if (!SWIG_IsOK(res1)) {
25998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25999 }
26000 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26002 if (!SWIG_IsOK(res2)) {
26003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26004 }
26005 if (!argp2) {
26006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26007 }
26008 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26009 {
26010 PyThreadState* __tstate = wxPyBeginAllowThreads();
26011 {
26012 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26013 result = (wxDateTime *) &_result_ref;
26014 }
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj = 0;
26027 wxDateTime *arg1 = (wxDateTime *) 0 ;
26028 wxDateSpan *arg2 = 0 ;
26029 wxDateTime *result = 0 ;
26030 void *argp1 = 0 ;
26031 int res1 = 0 ;
26032 void *argp2 = 0 ;
26033 int res2 = 0 ;
26034 PyObject * obj0 = 0 ;
26035 PyObject * obj1 = 0 ;
26036 char * kwnames[] = {
26037 (char *) "self",(char *) "diff", NULL
26038 };
26039
26040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26044 }
26045 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26046 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26047 if (!SWIG_IsOK(res2)) {
26048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26049 }
26050 if (!argp2) {
26051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26052 }
26053 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26054 {
26055 PyThreadState* __tstate = wxPyBeginAllowThreads();
26056 {
26057 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26058 result = (wxDateTime *) &_result_ref;
26059 }
26060 wxPyEndAllowThreads(__tstate);
26061 if (PyErr_Occurred()) SWIG_fail;
26062 }
26063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26071 PyObject *resultobj = 0;
26072 wxDateTime *arg1 = (wxDateTime *) 0 ;
26073 wxDateTime *arg2 = 0 ;
26074 wxTimeSpan result;
26075 void *argp1 = 0 ;
26076 int res1 = 0 ;
26077 void *argp2 = 0 ;
26078 int res2 = 0 ;
26079 PyObject * obj0 = 0 ;
26080 PyObject * obj1 = 0 ;
26081 char * kwnames[] = {
26082 (char *) "self",(char *) "dt", NULL
26083 };
26084
26085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26087 if (!SWIG_IsOK(res1)) {
26088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26089 }
26090 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26091 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26092 if (!SWIG_IsOK(res2)) {
26093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26094 }
26095 if (!argp2) {
26096 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26097 }
26098 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26099 {
26100 PyThreadState* __tstate = wxPyBeginAllowThreads();
26101 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26102 wxPyEndAllowThreads(__tstate);
26103 if (PyErr_Occurred()) SWIG_fail;
26104 }
26105 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26106 return resultobj;
26107 fail:
26108 return NULL;
26109 }
26110
26111
26112 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26113 PyObject *resultobj = 0;
26114 wxDateTime *arg1 = (wxDateTime *) 0 ;
26115 wxTimeSpan *arg2 = 0 ;
26116 wxDateTime *result = 0 ;
26117 void *argp1 = 0 ;
26118 int res1 = 0 ;
26119 void *argp2 = 0 ;
26120 int res2 = 0 ;
26121
26122 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26124 if (!SWIG_IsOK(res1)) {
26125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26126 }
26127 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26128 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26129 if (!SWIG_IsOK(res2)) {
26130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26131 }
26132 if (!argp2) {
26133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26134 }
26135 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 {
26139 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26140 result = (wxDateTime *) &_result_ref;
26141 }
26142 wxPyEndAllowThreads(__tstate);
26143 if (PyErr_Occurred()) SWIG_fail;
26144 }
26145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26153 PyObject *resultobj = 0;
26154 wxDateTime *arg1 = (wxDateTime *) 0 ;
26155 wxDateSpan *arg2 = 0 ;
26156 wxDateTime *result = 0 ;
26157 void *argp1 = 0 ;
26158 int res1 = 0 ;
26159 void *argp2 = 0 ;
26160 int res2 = 0 ;
26161
26162 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26164 if (!SWIG_IsOK(res1)) {
26165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26166 }
26167 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26168 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26169 if (!SWIG_IsOK(res2)) {
26170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26171 }
26172 if (!argp2) {
26173 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26174 }
26175 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 {
26179 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26180 result = (wxDateTime *) &_result_ref;
26181 }
26182 wxPyEndAllowThreads(__tstate);
26183 if (PyErr_Occurred()) SWIG_fail;
26184 }
26185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26186 return resultobj;
26187 fail:
26188 return NULL;
26189 }
26190
26191
26192 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26193 int argc;
26194 PyObject *argv[3];
26195
26196 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26197 --argc;
26198 if (argc == 2) {
26199 int _v = 0;
26200 {
26201 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26202 _v = SWIG_CheckState(res);
26203 }
26204 if (!_v) goto check_1;
26205 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26206 }
26207 check_1:
26208
26209 if (argc == 2) {
26210 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26211 }
26212
26213 fail:
26214 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26215 return NULL;
26216 }
26217
26218
26219 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26220 PyObject *resultobj = 0;
26221 wxDateTime *arg1 = (wxDateTime *) 0 ;
26222 wxTimeSpan *arg2 = 0 ;
26223 wxDateTime *result = 0 ;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 void *argp2 = 0 ;
26227 int res2 = 0 ;
26228
26229 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26231 if (!SWIG_IsOK(res1)) {
26232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26233 }
26234 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26235 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26236 if (!SWIG_IsOK(res2)) {
26237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26238 }
26239 if (!argp2) {
26240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26241 }
26242 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 {
26246 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26247 result = (wxDateTime *) &_result_ref;
26248 }
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26260 PyObject *resultobj = 0;
26261 wxDateTime *arg1 = (wxDateTime *) 0 ;
26262 wxDateSpan *arg2 = 0 ;
26263 wxDateTime *result = 0 ;
26264 void *argp1 = 0 ;
26265 int res1 = 0 ;
26266 void *argp2 = 0 ;
26267 int res2 = 0 ;
26268
26269 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26271 if (!SWIG_IsOK(res1)) {
26272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26273 }
26274 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26275 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26276 if (!SWIG_IsOK(res2)) {
26277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26278 }
26279 if (!argp2) {
26280 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26281 }
26282 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26283 {
26284 PyThreadState* __tstate = wxPyBeginAllowThreads();
26285 {
26286 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26287 result = (wxDateTime *) &_result_ref;
26288 }
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26293 return resultobj;
26294 fail:
26295 return NULL;
26296 }
26297
26298
26299 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26300 int argc;
26301 PyObject *argv[3];
26302
26303 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26304 --argc;
26305 if (argc == 2) {
26306 int _v = 0;
26307 {
26308 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26309 _v = SWIG_CheckState(res);
26310 }
26311 if (!_v) goto check_1;
26312 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26313 }
26314 check_1:
26315
26316 if (argc == 2) {
26317 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26318 }
26319
26320 fail:
26321 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26322 return NULL;
26323 }
26324
26325
26326 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26327 PyObject *resultobj = 0;
26328 wxDateTime *arg1 = (wxDateTime *) 0 ;
26329 wxTimeSpan *arg2 = 0 ;
26330 wxDateTime result;
26331 void *argp1 = 0 ;
26332 int res1 = 0 ;
26333 void *argp2 = 0 ;
26334 int res2 = 0 ;
26335
26336 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26338 if (!SWIG_IsOK(res1)) {
26339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26340 }
26341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26342 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26343 if (!SWIG_IsOK(res2)) {
26344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26345 }
26346 if (!argp2) {
26347 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26348 }
26349 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26364 PyObject *resultobj = 0;
26365 wxDateTime *arg1 = (wxDateTime *) 0 ;
26366 wxDateSpan *arg2 = 0 ;
26367 wxDateTime result;
26368 void *argp1 = 0 ;
26369 int res1 = 0 ;
26370 void *argp2 = 0 ;
26371 int res2 = 0 ;
26372
26373 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26375 if (!SWIG_IsOK(res1)) {
26376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26377 }
26378 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26379 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26380 if (!SWIG_IsOK(res2)) {
26381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26382 }
26383 if (!argp2) {
26384 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26385 }
26386 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26387 {
26388 PyThreadState* __tstate = wxPyBeginAllowThreads();
26389 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26390 wxPyEndAllowThreads(__tstate);
26391 if (PyErr_Occurred()) SWIG_fail;
26392 }
26393 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26394 return resultobj;
26395 fail:
26396 return NULL;
26397 }
26398
26399
26400 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26401 int argc;
26402 PyObject *argv[3];
26403
26404 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26405 --argc;
26406 if (argc == 2) {
26407 int _v = 0;
26408 {
26409 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26410 _v = SWIG_CheckState(res);
26411 }
26412 if (!_v) goto check_1;
26413 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26414 }
26415 check_1:
26416
26417 if (argc == 2) {
26418 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26419 }
26420
26421 fail:
26422 Py_INCREF(Py_NotImplemented);
26423 return Py_NotImplemented;
26424 }
26425
26426
26427 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26428 PyObject *resultobj = 0;
26429 wxDateTime *arg1 = (wxDateTime *) 0 ;
26430 wxDateTime *arg2 = 0 ;
26431 wxTimeSpan result;
26432 void *argp1 = 0 ;
26433 int res1 = 0 ;
26434 void *argp2 = 0 ;
26435 int res2 = 0 ;
26436
26437 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26439 if (!SWIG_IsOK(res1)) {
26440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26441 }
26442 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26443 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26444 if (!SWIG_IsOK(res2)) {
26445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26446 }
26447 if (!argp2) {
26448 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26449 }
26450 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26451 {
26452 PyThreadState* __tstate = wxPyBeginAllowThreads();
26453 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26458 return resultobj;
26459 fail:
26460 return NULL;
26461 }
26462
26463
26464 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26465 PyObject *resultobj = 0;
26466 wxDateTime *arg1 = (wxDateTime *) 0 ;
26467 wxTimeSpan *arg2 = 0 ;
26468 wxDateTime result;
26469 void *argp1 = 0 ;
26470 int res1 = 0 ;
26471 void *argp2 = 0 ;
26472 int res2 = 0 ;
26473
26474 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26476 if (!SWIG_IsOK(res1)) {
26477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26478 }
26479 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26480 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26481 if (!SWIG_IsOK(res2)) {
26482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26483 }
26484 if (!argp2) {
26485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26486 }
26487 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26495 return resultobj;
26496 fail:
26497 return NULL;
26498 }
26499
26500
26501 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26502 PyObject *resultobj = 0;
26503 wxDateTime *arg1 = (wxDateTime *) 0 ;
26504 wxDateSpan *arg2 = 0 ;
26505 wxDateTime result;
26506 void *argp1 = 0 ;
26507 int res1 = 0 ;
26508 void *argp2 = 0 ;
26509 int res2 = 0 ;
26510
26511 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26513 if (!SWIG_IsOK(res1)) {
26514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26515 }
26516 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26517 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26518 if (!SWIG_IsOK(res2)) {
26519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26520 }
26521 if (!argp2) {
26522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26523 }
26524 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26525 {
26526 PyThreadState* __tstate = wxPyBeginAllowThreads();
26527 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26528 wxPyEndAllowThreads(__tstate);
26529 if (PyErr_Occurred()) SWIG_fail;
26530 }
26531 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26532 return resultobj;
26533 fail:
26534 return NULL;
26535 }
26536
26537
26538 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26539 int argc;
26540 PyObject *argv[3];
26541
26542 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26543 --argc;
26544 if (argc == 2) {
26545 int _v = 0;
26546 {
26547 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26548 _v = SWIG_CheckState(res);
26549 }
26550 if (!_v) goto check_1;
26551 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26552 }
26553 check_1:
26554
26555 if (argc == 2) {
26556 int _v = 0;
26557 {
26558 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26559 _v = SWIG_CheckState(res);
26560 }
26561 if (!_v) goto check_2;
26562 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26563 }
26564 check_2:
26565
26566 if (argc == 2) {
26567 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26568 }
26569
26570 fail:
26571 Py_INCREF(Py_NotImplemented);
26572 return Py_NotImplemented;
26573 }
26574
26575
26576 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26577 PyObject *resultobj = 0;
26578 wxDateTime *arg1 = (wxDateTime *) 0 ;
26579 wxDateTime *arg2 = (wxDateTime *) 0 ;
26580 bool result;
26581 void *argp1 = 0 ;
26582 int res1 = 0 ;
26583 void *argp2 = 0 ;
26584 int res2 = 0 ;
26585 PyObject * obj0 = 0 ;
26586 PyObject * obj1 = 0 ;
26587 char * kwnames[] = {
26588 (char *) "self",(char *) "other", NULL
26589 };
26590
26591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26593 if (!SWIG_IsOK(res1)) {
26594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26595 }
26596 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26598 if (!SWIG_IsOK(res2)) {
26599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26600 }
26601 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26605 wxPyEndAllowThreads(__tstate);
26606 if (PyErr_Occurred()) SWIG_fail;
26607 }
26608 {
26609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26610 }
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26618 PyObject *resultobj = 0;
26619 wxDateTime *arg1 = (wxDateTime *) 0 ;
26620 wxDateTime *arg2 = (wxDateTime *) 0 ;
26621 bool result;
26622 void *argp1 = 0 ;
26623 int res1 = 0 ;
26624 void *argp2 = 0 ;
26625 int res2 = 0 ;
26626 PyObject * obj0 = 0 ;
26627 PyObject * obj1 = 0 ;
26628 char * kwnames[] = {
26629 (char *) "self",(char *) "other", NULL
26630 };
26631
26632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26634 if (!SWIG_IsOK(res1)) {
26635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26636 }
26637 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26639 if (!SWIG_IsOK(res2)) {
26640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26641 }
26642 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26643 {
26644 PyThreadState* __tstate = wxPyBeginAllowThreads();
26645 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26646 wxPyEndAllowThreads(__tstate);
26647 if (PyErr_Occurred()) SWIG_fail;
26648 }
26649 {
26650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26651 }
26652 return resultobj;
26653 fail:
26654 return NULL;
26655 }
26656
26657
26658 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26659 PyObject *resultobj = 0;
26660 wxDateTime *arg1 = (wxDateTime *) 0 ;
26661 wxDateTime *arg2 = (wxDateTime *) 0 ;
26662 bool result;
26663 void *argp1 = 0 ;
26664 int res1 = 0 ;
26665 void *argp2 = 0 ;
26666 int res2 = 0 ;
26667 PyObject * obj0 = 0 ;
26668 PyObject * obj1 = 0 ;
26669 char * kwnames[] = {
26670 (char *) "self",(char *) "other", NULL
26671 };
26672
26673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26675 if (!SWIG_IsOK(res1)) {
26676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26677 }
26678 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26680 if (!SWIG_IsOK(res2)) {
26681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26682 }
26683 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26687 wxPyEndAllowThreads(__tstate);
26688 if (PyErr_Occurred()) SWIG_fail;
26689 }
26690 {
26691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26692 }
26693 return resultobj;
26694 fail:
26695 return NULL;
26696 }
26697
26698
26699 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26700 PyObject *resultobj = 0;
26701 wxDateTime *arg1 = (wxDateTime *) 0 ;
26702 wxDateTime *arg2 = (wxDateTime *) 0 ;
26703 bool result;
26704 void *argp1 = 0 ;
26705 int res1 = 0 ;
26706 void *argp2 = 0 ;
26707 int res2 = 0 ;
26708 PyObject * obj0 = 0 ;
26709 PyObject * obj1 = 0 ;
26710 char * kwnames[] = {
26711 (char *) "self",(char *) "other", NULL
26712 };
26713
26714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26716 if (!SWIG_IsOK(res1)) {
26717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26718 }
26719 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26720 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26721 if (!SWIG_IsOK(res2)) {
26722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26723 }
26724 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26725 {
26726 PyThreadState* __tstate = wxPyBeginAllowThreads();
26727 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26728 wxPyEndAllowThreads(__tstate);
26729 if (PyErr_Occurred()) SWIG_fail;
26730 }
26731 {
26732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26733 }
26734 return resultobj;
26735 fail:
26736 return NULL;
26737 }
26738
26739
26740 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26741 PyObject *resultobj = 0;
26742 wxDateTime *arg1 = (wxDateTime *) 0 ;
26743 wxDateTime *arg2 = (wxDateTime *) 0 ;
26744 bool result;
26745 void *argp1 = 0 ;
26746 int res1 = 0 ;
26747 void *argp2 = 0 ;
26748 int res2 = 0 ;
26749 PyObject * obj0 = 0 ;
26750 PyObject * obj1 = 0 ;
26751 char * kwnames[] = {
26752 (char *) "self",(char *) "other", NULL
26753 };
26754
26755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26757 if (!SWIG_IsOK(res1)) {
26758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26759 }
26760 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26762 if (!SWIG_IsOK(res2)) {
26763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26764 }
26765 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26766 {
26767 PyThreadState* __tstate = wxPyBeginAllowThreads();
26768 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26769 wxPyEndAllowThreads(__tstate);
26770 if (PyErr_Occurred()) SWIG_fail;
26771 }
26772 {
26773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26774 }
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26782 PyObject *resultobj = 0;
26783 wxDateTime *arg1 = (wxDateTime *) 0 ;
26784 wxDateTime *arg2 = (wxDateTime *) 0 ;
26785 bool result;
26786 void *argp1 = 0 ;
26787 int res1 = 0 ;
26788 void *argp2 = 0 ;
26789 int res2 = 0 ;
26790 PyObject * obj0 = 0 ;
26791 PyObject * obj1 = 0 ;
26792 char * kwnames[] = {
26793 (char *) "self",(char *) "other", NULL
26794 };
26795
26796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26798 if (!SWIG_IsOK(res1)) {
26799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26800 }
26801 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26802 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26803 if (!SWIG_IsOK(res2)) {
26804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26805 }
26806 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26807 {
26808 PyThreadState* __tstate = wxPyBeginAllowThreads();
26809 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26810 wxPyEndAllowThreads(__tstate);
26811 if (PyErr_Occurred()) SWIG_fail;
26812 }
26813 {
26814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26815 }
26816 return resultobj;
26817 fail:
26818 return NULL;
26819 }
26820
26821
26822 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26823 PyObject *resultobj = 0;
26824 wxDateTime *arg1 = (wxDateTime *) 0 ;
26825 wxString *arg2 = 0 ;
26826 int result;
26827 void *argp1 = 0 ;
26828 int res1 = 0 ;
26829 bool temp2 = false ;
26830 PyObject * obj0 = 0 ;
26831 PyObject * obj1 = 0 ;
26832 char * kwnames[] = {
26833 (char *) "self",(char *) "date", NULL
26834 };
26835
26836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26838 if (!SWIG_IsOK(res1)) {
26839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26840 }
26841 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26842 {
26843 arg2 = wxString_in_helper(obj1);
26844 if (arg2 == NULL) SWIG_fail;
26845 temp2 = true;
26846 }
26847 {
26848 PyThreadState* __tstate = wxPyBeginAllowThreads();
26849 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26850 wxPyEndAllowThreads(__tstate);
26851 if (PyErr_Occurred()) SWIG_fail;
26852 }
26853 resultobj = SWIG_From_int(static_cast< int >(result));
26854 {
26855 if (temp2)
26856 delete arg2;
26857 }
26858 return resultobj;
26859 fail:
26860 {
26861 if (temp2)
26862 delete arg2;
26863 }
26864 return NULL;
26865 }
26866
26867
26868 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26869 PyObject *resultobj = 0;
26870 wxDateTime *arg1 = (wxDateTime *) 0 ;
26871 wxString *arg2 = 0 ;
26872 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26873 wxString *arg3 = (wxString *) &arg3_defvalue ;
26874 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26875 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26876 int result;
26877 void *argp1 = 0 ;
26878 int res1 = 0 ;
26879 bool temp2 = false ;
26880 bool temp3 = false ;
26881 void *argp4 = 0 ;
26882 int res4 = 0 ;
26883 PyObject * obj0 = 0 ;
26884 PyObject * obj1 = 0 ;
26885 PyObject * obj2 = 0 ;
26886 PyObject * obj3 = 0 ;
26887 char * kwnames[] = {
26888 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26889 };
26890
26891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26893 if (!SWIG_IsOK(res1)) {
26894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26895 }
26896 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26897 {
26898 arg2 = wxString_in_helper(obj1);
26899 if (arg2 == NULL) SWIG_fail;
26900 temp2 = true;
26901 }
26902 if (obj2) {
26903 {
26904 arg3 = wxString_in_helper(obj2);
26905 if (arg3 == NULL) SWIG_fail;
26906 temp3 = true;
26907 }
26908 }
26909 if (obj3) {
26910 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26911 if (!SWIG_IsOK(res4)) {
26912 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26913 }
26914 if (!argp4) {
26915 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26916 }
26917 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26918 }
26919 {
26920 PyThreadState* __tstate = wxPyBeginAllowThreads();
26921 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26922 wxPyEndAllowThreads(__tstate);
26923 if (PyErr_Occurred()) SWIG_fail;
26924 }
26925 resultobj = SWIG_From_int(static_cast< int >(result));
26926 {
26927 if (temp2)
26928 delete arg2;
26929 }
26930 {
26931 if (temp3)
26932 delete arg3;
26933 }
26934 return resultobj;
26935 fail:
26936 {
26937 if (temp2)
26938 delete arg2;
26939 }
26940 {
26941 if (temp3)
26942 delete arg3;
26943 }
26944 return NULL;
26945 }
26946
26947
26948 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj = 0;
26950 wxDateTime *arg1 = (wxDateTime *) 0 ;
26951 wxString *arg2 = 0 ;
26952 int result;
26953 void *argp1 = 0 ;
26954 int res1 = 0 ;
26955 bool temp2 = false ;
26956 PyObject * obj0 = 0 ;
26957 PyObject * obj1 = 0 ;
26958 char * kwnames[] = {
26959 (char *) "self",(char *) "datetime", NULL
26960 };
26961
26962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26964 if (!SWIG_IsOK(res1)) {
26965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26966 }
26967 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26968 {
26969 arg2 = wxString_in_helper(obj1);
26970 if (arg2 == NULL) SWIG_fail;
26971 temp2 = true;
26972 }
26973 {
26974 PyThreadState* __tstate = wxPyBeginAllowThreads();
26975 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26976 wxPyEndAllowThreads(__tstate);
26977 if (PyErr_Occurred()) SWIG_fail;
26978 }
26979 resultobj = SWIG_From_int(static_cast< int >(result));
26980 {
26981 if (temp2)
26982 delete arg2;
26983 }
26984 return resultobj;
26985 fail:
26986 {
26987 if (temp2)
26988 delete arg2;
26989 }
26990 return NULL;
26991 }
26992
26993
26994 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26995 PyObject *resultobj = 0;
26996 wxDateTime *arg1 = (wxDateTime *) 0 ;
26997 wxString *arg2 = 0 ;
26998 int result;
26999 void *argp1 = 0 ;
27000 int res1 = 0 ;
27001 bool temp2 = false ;
27002 PyObject * obj0 = 0 ;
27003 PyObject * obj1 = 0 ;
27004 char * kwnames[] = {
27005 (char *) "self",(char *) "date", NULL
27006 };
27007
27008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27010 if (!SWIG_IsOK(res1)) {
27011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27012 }
27013 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27014 {
27015 arg2 = wxString_in_helper(obj1);
27016 if (arg2 == NULL) SWIG_fail;
27017 temp2 = true;
27018 }
27019 {
27020 PyThreadState* __tstate = wxPyBeginAllowThreads();
27021 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27022 wxPyEndAllowThreads(__tstate);
27023 if (PyErr_Occurred()) SWIG_fail;
27024 }
27025 resultobj = SWIG_From_int(static_cast< int >(result));
27026 {
27027 if (temp2)
27028 delete arg2;
27029 }
27030 return resultobj;
27031 fail:
27032 {
27033 if (temp2)
27034 delete arg2;
27035 }
27036 return NULL;
27037 }
27038
27039
27040 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27041 PyObject *resultobj = 0;
27042 wxDateTime *arg1 = (wxDateTime *) 0 ;
27043 wxString *arg2 = 0 ;
27044 int result;
27045 void *argp1 = 0 ;
27046 int res1 = 0 ;
27047 bool temp2 = false ;
27048 PyObject * obj0 = 0 ;
27049 PyObject * obj1 = 0 ;
27050 char * kwnames[] = {
27051 (char *) "self",(char *) "time", NULL
27052 };
27053
27054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27058 }
27059 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27060 {
27061 arg2 = wxString_in_helper(obj1);
27062 if (arg2 == NULL) SWIG_fail;
27063 temp2 = true;
27064 }
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27068 wxPyEndAllowThreads(__tstate);
27069 if (PyErr_Occurred()) SWIG_fail;
27070 }
27071 resultobj = SWIG_From_int(static_cast< int >(result));
27072 {
27073 if (temp2)
27074 delete arg2;
27075 }
27076 return resultobj;
27077 fail:
27078 {
27079 if (temp2)
27080 delete arg2;
27081 }
27082 return NULL;
27083 }
27084
27085
27086 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27087 PyObject *resultobj = 0;
27088 wxDateTime *arg1 = (wxDateTime *) 0 ;
27089 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27090 wxString *arg2 = (wxString *) &arg2_defvalue ;
27091 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27092 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27093 wxString result;
27094 void *argp1 = 0 ;
27095 int res1 = 0 ;
27096 bool temp2 = false ;
27097 bool temp3 = false ;
27098 PyObject * obj0 = 0 ;
27099 PyObject * obj1 = 0 ;
27100 PyObject * obj2 = 0 ;
27101 char * kwnames[] = {
27102 (char *) "self",(char *) "format",(char *) "tz", NULL
27103 };
27104
27105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27107 if (!SWIG_IsOK(res1)) {
27108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27109 }
27110 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27111 if (obj1) {
27112 {
27113 arg2 = wxString_in_helper(obj1);
27114 if (arg2 == NULL) SWIG_fail;
27115 temp2 = true;
27116 }
27117 }
27118 if (obj2) {
27119 {
27120 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27121 temp3 = true;
27122 }
27123 }
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27127 wxPyEndAllowThreads(__tstate);
27128 if (PyErr_Occurred()) SWIG_fail;
27129 }
27130 {
27131 #if wxUSE_UNICODE
27132 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27133 #else
27134 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27135 #endif
27136 }
27137 {
27138 if (temp2)
27139 delete arg2;
27140 }
27141 {
27142 if (temp3) delete arg3;
27143 }
27144 return resultobj;
27145 fail:
27146 {
27147 if (temp2)
27148 delete arg2;
27149 }
27150 {
27151 if (temp3) delete arg3;
27152 }
27153 return NULL;
27154 }
27155
27156
27157 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27158 PyObject *resultobj = 0;
27159 wxDateTime *arg1 = (wxDateTime *) 0 ;
27160 wxString result;
27161 void *argp1 = 0 ;
27162 int res1 = 0 ;
27163 PyObject *swig_obj[1] ;
27164
27165 if (!args) SWIG_fail;
27166 swig_obj[0] = args;
27167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27168 if (!SWIG_IsOK(res1)) {
27169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27170 }
27171 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27172 {
27173 PyThreadState* __tstate = wxPyBeginAllowThreads();
27174 result = ((wxDateTime const *)arg1)->FormatDate();
27175 wxPyEndAllowThreads(__tstate);
27176 if (PyErr_Occurred()) SWIG_fail;
27177 }
27178 {
27179 #if wxUSE_UNICODE
27180 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27181 #else
27182 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27183 #endif
27184 }
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27192 PyObject *resultobj = 0;
27193 wxDateTime *arg1 = (wxDateTime *) 0 ;
27194 wxString result;
27195 void *argp1 = 0 ;
27196 int res1 = 0 ;
27197 PyObject *swig_obj[1] ;
27198
27199 if (!args) SWIG_fail;
27200 swig_obj[0] = args;
27201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27202 if (!SWIG_IsOK(res1)) {
27203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27204 }
27205 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27206 {
27207 PyThreadState* __tstate = wxPyBeginAllowThreads();
27208 result = ((wxDateTime const *)arg1)->FormatTime();
27209 wxPyEndAllowThreads(__tstate);
27210 if (PyErr_Occurred()) SWIG_fail;
27211 }
27212 {
27213 #if wxUSE_UNICODE
27214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27215 #else
27216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27217 #endif
27218 }
27219 return resultobj;
27220 fail:
27221 return NULL;
27222 }
27223
27224
27225 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27226 PyObject *resultobj = 0;
27227 wxDateTime *arg1 = (wxDateTime *) 0 ;
27228 wxString result;
27229 void *argp1 = 0 ;
27230 int res1 = 0 ;
27231 PyObject *swig_obj[1] ;
27232
27233 if (!args) SWIG_fail;
27234 swig_obj[0] = args;
27235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27236 if (!SWIG_IsOK(res1)) {
27237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27238 }
27239 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = ((wxDateTime const *)arg1)->FormatISODate();
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 {
27247 #if wxUSE_UNICODE
27248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27249 #else
27250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27251 #endif
27252 }
27253 return resultobj;
27254 fail:
27255 return NULL;
27256 }
27257
27258
27259 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27260 PyObject *resultobj = 0;
27261 wxDateTime *arg1 = (wxDateTime *) 0 ;
27262 wxString result;
27263 void *argp1 = 0 ;
27264 int res1 = 0 ;
27265 PyObject *swig_obj[1] ;
27266
27267 if (!args) SWIG_fail;
27268 swig_obj[0] = args;
27269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27270 if (!SWIG_IsOK(res1)) {
27271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27272 }
27273 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 result = ((wxDateTime const *)arg1)->FormatISOTime();
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 {
27281 #if wxUSE_UNICODE
27282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27283 #else
27284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27285 #endif
27286 }
27287 return resultobj;
27288 fail:
27289 return NULL;
27290 }
27291
27292
27293 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27294 PyObject *obj;
27295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27296 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27297 return SWIG_Py_Void();
27298 }
27299
27300 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27301 return SWIG_Python_InitShadowInstance(args);
27302 }
27303
27304 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27305 PyObject *resultobj = 0;
27306 long arg1 ;
27307 wxTimeSpan result;
27308 long val1 ;
27309 int ecode1 = 0 ;
27310 PyObject * obj0 = 0 ;
27311 char * kwnames[] = {
27312 (char *) "ms", NULL
27313 };
27314
27315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27316 ecode1 = SWIG_AsVal_long(obj0, &val1);
27317 if (!SWIG_IsOK(ecode1)) {
27318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27319 }
27320 arg1 = static_cast< long >(val1);
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = wxTimeSpan::Milliseconds(arg1);
27324 wxPyEndAllowThreads(__tstate);
27325 if (PyErr_Occurred()) SWIG_fail;
27326 }
27327 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27328 return resultobj;
27329 fail:
27330 return NULL;
27331 }
27332
27333
27334 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27335 PyObject *resultobj = 0;
27336 wxTimeSpan result;
27337
27338 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27339 {
27340 PyThreadState* __tstate = wxPyBeginAllowThreads();
27341 result = wxTimeSpan::Millisecond();
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj = 0;
27354 long arg1 ;
27355 wxTimeSpan result;
27356 long val1 ;
27357 int ecode1 = 0 ;
27358 PyObject * obj0 = 0 ;
27359 char * kwnames[] = {
27360 (char *) "sec", NULL
27361 };
27362
27363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27364 ecode1 = SWIG_AsVal_long(obj0, &val1);
27365 if (!SWIG_IsOK(ecode1)) {
27366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27367 }
27368 arg1 = static_cast< long >(val1);
27369 {
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 result = wxTimeSpan::Seconds(arg1);
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27383 PyObject *resultobj = 0;
27384 wxTimeSpan result;
27385
27386 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = wxTimeSpan::Second();
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27401 PyObject *resultobj = 0;
27402 long arg1 ;
27403 wxTimeSpan result;
27404 long val1 ;
27405 int ecode1 = 0 ;
27406 PyObject * obj0 = 0 ;
27407 char * kwnames[] = {
27408 (char *) "min", NULL
27409 };
27410
27411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27412 ecode1 = SWIG_AsVal_long(obj0, &val1);
27413 if (!SWIG_IsOK(ecode1)) {
27414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27415 }
27416 arg1 = static_cast< long >(val1);
27417 {
27418 PyThreadState* __tstate = wxPyBeginAllowThreads();
27419 result = wxTimeSpan::Minutes(arg1);
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27431 PyObject *resultobj = 0;
27432 wxTimeSpan result;
27433
27434 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27435 {
27436 PyThreadState* __tstate = wxPyBeginAllowThreads();
27437 result = wxTimeSpan::Minute();
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27442 return resultobj;
27443 fail:
27444 return NULL;
27445 }
27446
27447
27448 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj = 0;
27450 long arg1 ;
27451 wxTimeSpan result;
27452 long val1 ;
27453 int ecode1 = 0 ;
27454 PyObject * obj0 = 0 ;
27455 char * kwnames[] = {
27456 (char *) "hours", NULL
27457 };
27458
27459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27460 ecode1 = SWIG_AsVal_long(obj0, &val1);
27461 if (!SWIG_IsOK(ecode1)) {
27462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27463 }
27464 arg1 = static_cast< long >(val1);
27465 {
27466 PyThreadState* __tstate = wxPyBeginAllowThreads();
27467 result = wxTimeSpan::Hours(arg1);
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27479 PyObject *resultobj = 0;
27480 wxTimeSpan result;
27481
27482 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 result = wxTimeSpan::Hour();
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27490 return resultobj;
27491 fail:
27492 return NULL;
27493 }
27494
27495
27496 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27497 PyObject *resultobj = 0;
27498 long arg1 ;
27499 wxTimeSpan result;
27500 long val1 ;
27501 int ecode1 = 0 ;
27502 PyObject * obj0 = 0 ;
27503 char * kwnames[] = {
27504 (char *) "days", NULL
27505 };
27506
27507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27508 ecode1 = SWIG_AsVal_long(obj0, &val1);
27509 if (!SWIG_IsOK(ecode1)) {
27510 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27511 }
27512 arg1 = static_cast< long >(val1);
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 result = wxTimeSpan::Days(arg1);
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27527 PyObject *resultobj = 0;
27528 wxTimeSpan result;
27529
27530 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27531 {
27532 PyThreadState* __tstate = wxPyBeginAllowThreads();
27533 result = wxTimeSpan::Day();
27534 wxPyEndAllowThreads(__tstate);
27535 if (PyErr_Occurred()) SWIG_fail;
27536 }
27537 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27538 return resultobj;
27539 fail:
27540 return NULL;
27541 }
27542
27543
27544 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27545 PyObject *resultobj = 0;
27546 long arg1 ;
27547 wxTimeSpan result;
27548 long val1 ;
27549 int ecode1 = 0 ;
27550 PyObject * obj0 = 0 ;
27551 char * kwnames[] = {
27552 (char *) "days", NULL
27553 };
27554
27555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27556 ecode1 = SWIG_AsVal_long(obj0, &val1);
27557 if (!SWIG_IsOK(ecode1)) {
27558 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27559 }
27560 arg1 = static_cast< long >(val1);
27561 {
27562 PyThreadState* __tstate = wxPyBeginAllowThreads();
27563 result = wxTimeSpan::Weeks(arg1);
27564 wxPyEndAllowThreads(__tstate);
27565 if (PyErr_Occurred()) SWIG_fail;
27566 }
27567 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27568 return resultobj;
27569 fail:
27570 return NULL;
27571 }
27572
27573
27574 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27575 PyObject *resultobj = 0;
27576 wxTimeSpan result;
27577
27578 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 result = wxTimeSpan::Week();
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27586 return resultobj;
27587 fail:
27588 return NULL;
27589 }
27590
27591
27592 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27593 PyObject *resultobj = 0;
27594 long arg1 = (long) 0 ;
27595 long arg2 = (long) 0 ;
27596 long arg3 = (long) 0 ;
27597 long arg4 = (long) 0 ;
27598 wxTimeSpan *result = 0 ;
27599 long val1 ;
27600 int ecode1 = 0 ;
27601 long val2 ;
27602 int ecode2 = 0 ;
27603 long val3 ;
27604 int ecode3 = 0 ;
27605 long val4 ;
27606 int ecode4 = 0 ;
27607 PyObject * obj0 = 0 ;
27608 PyObject * obj1 = 0 ;
27609 PyObject * obj2 = 0 ;
27610 PyObject * obj3 = 0 ;
27611 char * kwnames[] = {
27612 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27613 };
27614
27615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27616 if (obj0) {
27617 ecode1 = SWIG_AsVal_long(obj0, &val1);
27618 if (!SWIG_IsOK(ecode1)) {
27619 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27620 }
27621 arg1 = static_cast< long >(val1);
27622 }
27623 if (obj1) {
27624 ecode2 = SWIG_AsVal_long(obj1, &val2);
27625 if (!SWIG_IsOK(ecode2)) {
27626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27627 }
27628 arg2 = static_cast< long >(val2);
27629 }
27630 if (obj2) {
27631 ecode3 = SWIG_AsVal_long(obj2, &val3);
27632 if (!SWIG_IsOK(ecode3)) {
27633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27634 }
27635 arg3 = static_cast< long >(val3);
27636 }
27637 if (obj3) {
27638 ecode4 = SWIG_AsVal_long(obj3, &val4);
27639 if (!SWIG_IsOK(ecode4)) {
27640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27641 }
27642 arg4 = static_cast< long >(val4);
27643 }
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27647 wxPyEndAllowThreads(__tstate);
27648 if (PyErr_Occurred()) SWIG_fail;
27649 }
27650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27651 return resultobj;
27652 fail:
27653 return NULL;
27654 }
27655
27656
27657 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27658 PyObject *resultobj = 0;
27659 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27660 void *argp1 = 0 ;
27661 int res1 = 0 ;
27662 PyObject *swig_obj[1] ;
27663
27664 if (!args) SWIG_fail;
27665 swig_obj[0] = args;
27666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27667 if (!SWIG_IsOK(res1)) {
27668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27669 }
27670 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27671 {
27672 PyThreadState* __tstate = wxPyBeginAllowThreads();
27673 delete arg1;
27674
27675 wxPyEndAllowThreads(__tstate);
27676 if (PyErr_Occurred()) SWIG_fail;
27677 }
27678 resultobj = SWIG_Py_Void();
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27686 PyObject *resultobj = 0;
27687 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27688 wxTimeSpan *arg2 = 0 ;
27689 wxTimeSpan *result = 0 ;
27690 void *argp1 = 0 ;
27691 int res1 = 0 ;
27692 void *argp2 = 0 ;
27693 int res2 = 0 ;
27694 PyObject * obj0 = 0 ;
27695 PyObject * obj1 = 0 ;
27696 char * kwnames[] = {
27697 (char *) "self",(char *) "diff", NULL
27698 };
27699
27700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27702 if (!SWIG_IsOK(res1)) {
27703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27704 }
27705 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27707 if (!SWIG_IsOK(res2)) {
27708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27709 }
27710 if (!argp2) {
27711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27712 }
27713 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 {
27717 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27718 result = (wxTimeSpan *) &_result_ref;
27719 }
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27731 PyObject *resultobj = 0;
27732 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27733 wxTimeSpan *arg2 = 0 ;
27734 wxTimeSpan *result = 0 ;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 void *argp2 = 0 ;
27738 int res2 = 0 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char * kwnames[] = {
27742 (char *) "self",(char *) "diff", NULL
27743 };
27744
27745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27747 if (!SWIG_IsOK(res1)) {
27748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27749 }
27750 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27751 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27752 if (!SWIG_IsOK(res2)) {
27753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27754 }
27755 if (!argp2) {
27756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27757 }
27758 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27759 {
27760 PyThreadState* __tstate = wxPyBeginAllowThreads();
27761 {
27762 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27763 result = (wxTimeSpan *) &_result_ref;
27764 }
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27776 PyObject *resultobj = 0;
27777 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27778 int arg2 ;
27779 wxTimeSpan *result = 0 ;
27780 void *argp1 = 0 ;
27781 int res1 = 0 ;
27782 int val2 ;
27783 int ecode2 = 0 ;
27784 PyObject * obj0 = 0 ;
27785 PyObject * obj1 = 0 ;
27786 char * kwnames[] = {
27787 (char *) "self",(char *) "n", NULL
27788 };
27789
27790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27792 if (!SWIG_IsOK(res1)) {
27793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27794 }
27795 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27796 ecode2 = SWIG_AsVal_int(obj1, &val2);
27797 if (!SWIG_IsOK(ecode2)) {
27798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27799 }
27800 arg2 = static_cast< int >(val2);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 {
27804 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27805 result = (wxTimeSpan *) &_result_ref;
27806 }
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27818 PyObject *resultobj = 0;
27819 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27820 wxTimeSpan *result = 0 ;
27821 void *argp1 = 0 ;
27822 int res1 = 0 ;
27823 PyObject *swig_obj[1] ;
27824
27825 if (!args) SWIG_fail;
27826 swig_obj[0] = args;
27827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27828 if (!SWIG_IsOK(res1)) {
27829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27830 }
27831 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 {
27835 wxTimeSpan &_result_ref = (arg1)->Neg();
27836 result = (wxTimeSpan *) &_result_ref;
27837 }
27838 wxPyEndAllowThreads(__tstate);
27839 if (PyErr_Occurred()) SWIG_fail;
27840 }
27841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27842 return resultobj;
27843 fail:
27844 return NULL;
27845 }
27846
27847
27848 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27849 PyObject *resultobj = 0;
27850 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27851 wxTimeSpan result;
27852 void *argp1 = 0 ;
27853 int res1 = 0 ;
27854 PyObject *swig_obj[1] ;
27855
27856 if (!args) SWIG_fail;
27857 swig_obj[0] = args;
27858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27859 if (!SWIG_IsOK(res1)) {
27860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27861 }
27862 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27863 {
27864 PyThreadState* __tstate = wxPyBeginAllowThreads();
27865 result = ((wxTimeSpan const *)arg1)->Abs();
27866 wxPyEndAllowThreads(__tstate);
27867 if (PyErr_Occurred()) SWIG_fail;
27868 }
27869 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27877 PyObject *resultobj = 0;
27878 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27879 wxTimeSpan *arg2 = 0 ;
27880 wxTimeSpan *result = 0 ;
27881 void *argp1 = 0 ;
27882 int res1 = 0 ;
27883 void *argp2 = 0 ;
27884 int res2 = 0 ;
27885 PyObject * obj0 = 0 ;
27886 PyObject * obj1 = 0 ;
27887 char * kwnames[] = {
27888 (char *) "self",(char *) "diff", NULL
27889 };
27890
27891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27893 if (!SWIG_IsOK(res1)) {
27894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27895 }
27896 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27898 if (!SWIG_IsOK(res2)) {
27899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27900 }
27901 if (!argp2) {
27902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27903 }
27904 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 {
27908 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27909 result = (wxTimeSpan *) &_result_ref;
27910 }
27911 wxPyEndAllowThreads(__tstate);
27912 if (PyErr_Occurred()) SWIG_fail;
27913 }
27914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27915 return resultobj;
27916 fail:
27917 return NULL;
27918 }
27919
27920
27921 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27922 PyObject *resultobj = 0;
27923 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27924 wxTimeSpan *arg2 = 0 ;
27925 wxTimeSpan *result = 0 ;
27926 void *argp1 = 0 ;
27927 int res1 = 0 ;
27928 void *argp2 = 0 ;
27929 int res2 = 0 ;
27930 PyObject * obj0 = 0 ;
27931 PyObject * obj1 = 0 ;
27932 char * kwnames[] = {
27933 (char *) "self",(char *) "diff", NULL
27934 };
27935
27936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27940 }
27941 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27943 if (!SWIG_IsOK(res2)) {
27944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27945 }
27946 if (!argp2) {
27947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27948 }
27949 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27950 {
27951 PyThreadState* __tstate = wxPyBeginAllowThreads();
27952 {
27953 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27954 result = (wxTimeSpan *) &_result_ref;
27955 }
27956 wxPyEndAllowThreads(__tstate);
27957 if (PyErr_Occurred()) SWIG_fail;
27958 }
27959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27960 return resultobj;
27961 fail:
27962 return NULL;
27963 }
27964
27965
27966 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27967 PyObject *resultobj = 0;
27968 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27969 int arg2 ;
27970 wxTimeSpan *result = 0 ;
27971 void *argp1 = 0 ;
27972 int res1 = 0 ;
27973 int val2 ;
27974 int ecode2 = 0 ;
27975 PyObject * obj0 = 0 ;
27976 PyObject * obj1 = 0 ;
27977 char * kwnames[] = {
27978 (char *) "self",(char *) "n", NULL
27979 };
27980
27981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27983 if (!SWIG_IsOK(res1)) {
27984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27985 }
27986 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27987 ecode2 = SWIG_AsVal_int(obj1, &val2);
27988 if (!SWIG_IsOK(ecode2)) {
27989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
27990 }
27991 arg2 = static_cast< int >(val2);
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 {
27995 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
27996 result = (wxTimeSpan *) &_result_ref;
27997 }
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28002 return resultobj;
28003 fail:
28004 return NULL;
28005 }
28006
28007
28008 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28009 PyObject *resultobj = 0;
28010 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28011 wxTimeSpan *result = 0 ;
28012 void *argp1 = 0 ;
28013 int res1 = 0 ;
28014 PyObject *swig_obj[1] ;
28015
28016 if (!args) SWIG_fail;
28017 swig_obj[0] = args;
28018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28019 if (!SWIG_IsOK(res1)) {
28020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28021 }
28022 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28023 {
28024 PyThreadState* __tstate = wxPyBeginAllowThreads();
28025 {
28026 wxTimeSpan &_result_ref = (arg1)->operator -();
28027 result = (wxTimeSpan *) &_result_ref;
28028 }
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28040 PyObject *resultobj = 0;
28041 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28042 wxTimeSpan *arg2 = 0 ;
28043 wxTimeSpan result;
28044 void *argp1 = 0 ;
28045 int res1 = 0 ;
28046 void *argp2 = 0 ;
28047 int res2 = 0 ;
28048 PyObject * obj0 = 0 ;
28049 PyObject * obj1 = 0 ;
28050 char * kwnames[] = {
28051 (char *) "self",(char *) "other", NULL
28052 };
28053
28054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28056 if (!SWIG_IsOK(res1)) {
28057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28058 }
28059 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28061 if (!SWIG_IsOK(res2)) {
28062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28063 }
28064 if (!argp2) {
28065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28066 }
28067 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28071 wxPyEndAllowThreads(__tstate);
28072 if (PyErr_Occurred()) SWIG_fail;
28073 }
28074 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28075 return resultobj;
28076 fail:
28077 return NULL;
28078 }
28079
28080
28081 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28082 PyObject *resultobj = 0;
28083 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28084 wxTimeSpan *arg2 = 0 ;
28085 wxTimeSpan result;
28086 void *argp1 = 0 ;
28087 int res1 = 0 ;
28088 void *argp2 = 0 ;
28089 int res2 = 0 ;
28090 PyObject * obj0 = 0 ;
28091 PyObject * obj1 = 0 ;
28092 char * kwnames[] = {
28093 (char *) "self",(char *) "other", NULL
28094 };
28095
28096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28098 if (!SWIG_IsOK(res1)) {
28099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28100 }
28101 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28102 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28103 if (!SWIG_IsOK(res2)) {
28104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28105 }
28106 if (!argp2) {
28107 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28108 }
28109 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28110 {
28111 PyThreadState* __tstate = wxPyBeginAllowThreads();
28112 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28124 PyObject *resultobj = 0;
28125 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28126 int arg2 ;
28127 wxTimeSpan result;
28128 void *argp1 = 0 ;
28129 int res1 = 0 ;
28130 int val2 ;
28131 int ecode2 = 0 ;
28132 PyObject * obj0 = 0 ;
28133 PyObject * obj1 = 0 ;
28134 char * kwnames[] = {
28135 (char *) "self",(char *) "n", NULL
28136 };
28137
28138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28140 if (!SWIG_IsOK(res1)) {
28141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28142 }
28143 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28144 ecode2 = SWIG_AsVal_int(obj1, &val2);
28145 if (!SWIG_IsOK(ecode2)) {
28146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28147 }
28148 arg2 = static_cast< int >(val2);
28149 {
28150 PyThreadState* __tstate = wxPyBeginAllowThreads();
28151 result = wxTimeSpan___mul__(arg1,arg2);
28152 wxPyEndAllowThreads(__tstate);
28153 if (PyErr_Occurred()) SWIG_fail;
28154 }
28155 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28156 return resultobj;
28157 fail:
28158 return NULL;
28159 }
28160
28161
28162 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28163 PyObject *resultobj = 0;
28164 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28165 int arg2 ;
28166 wxTimeSpan result;
28167 void *argp1 = 0 ;
28168 int res1 = 0 ;
28169 int val2 ;
28170 int ecode2 = 0 ;
28171 PyObject * obj0 = 0 ;
28172 PyObject * obj1 = 0 ;
28173 char * kwnames[] = {
28174 (char *) "self",(char *) "n", NULL
28175 };
28176
28177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28179 if (!SWIG_IsOK(res1)) {
28180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28181 }
28182 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28183 ecode2 = SWIG_AsVal_int(obj1, &val2);
28184 if (!SWIG_IsOK(ecode2)) {
28185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28186 }
28187 arg2 = static_cast< int >(val2);
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = wxTimeSpan___rmul__(arg1,arg2);
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28195 return resultobj;
28196 fail:
28197 return NULL;
28198 }
28199
28200
28201 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28202 PyObject *resultobj = 0;
28203 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28204 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28205 bool result;
28206 void *argp1 = 0 ;
28207 int res1 = 0 ;
28208 void *argp2 = 0 ;
28209 int res2 = 0 ;
28210 PyObject * obj0 = 0 ;
28211 PyObject * obj1 = 0 ;
28212 char * kwnames[] = {
28213 (char *) "self",(char *) "other", NULL
28214 };
28215
28216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28218 if (!SWIG_IsOK(res1)) {
28219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28220 }
28221 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28223 if (!SWIG_IsOK(res2)) {
28224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28225 }
28226 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28227 {
28228 PyThreadState* __tstate = wxPyBeginAllowThreads();
28229 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 {
28234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28235 }
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28243 PyObject *resultobj = 0;
28244 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28245 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28246 bool result;
28247 void *argp1 = 0 ;
28248 int res1 = 0 ;
28249 void *argp2 = 0 ;
28250 int res2 = 0 ;
28251 PyObject * obj0 = 0 ;
28252 PyObject * obj1 = 0 ;
28253 char * kwnames[] = {
28254 (char *) "self",(char *) "other", NULL
28255 };
28256
28257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28259 if (!SWIG_IsOK(res1)) {
28260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28261 }
28262 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28264 if (!SWIG_IsOK(res2)) {
28265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28266 }
28267 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28268 {
28269 PyThreadState* __tstate = wxPyBeginAllowThreads();
28270 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 {
28275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28276 }
28277 return resultobj;
28278 fail:
28279 return NULL;
28280 }
28281
28282
28283 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28284 PyObject *resultobj = 0;
28285 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28286 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28287 bool result;
28288 void *argp1 = 0 ;
28289 int res1 = 0 ;
28290 void *argp2 = 0 ;
28291 int res2 = 0 ;
28292 PyObject * obj0 = 0 ;
28293 PyObject * obj1 = 0 ;
28294 char * kwnames[] = {
28295 (char *) "self",(char *) "other", NULL
28296 };
28297
28298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28300 if (!SWIG_IsOK(res1)) {
28301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28302 }
28303 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28304 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28305 if (!SWIG_IsOK(res2)) {
28306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28307 }
28308 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28309 {
28310 PyThreadState* __tstate = wxPyBeginAllowThreads();
28311 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 {
28316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28317 }
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28325 PyObject *resultobj = 0;
28326 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28327 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28328 bool result;
28329 void *argp1 = 0 ;
28330 int res1 = 0 ;
28331 void *argp2 = 0 ;
28332 int res2 = 0 ;
28333 PyObject * obj0 = 0 ;
28334 PyObject * obj1 = 0 ;
28335 char * kwnames[] = {
28336 (char *) "self",(char *) "other", NULL
28337 };
28338
28339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28341 if (!SWIG_IsOK(res1)) {
28342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28343 }
28344 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28346 if (!SWIG_IsOK(res2)) {
28347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28348 }
28349 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28350 {
28351 PyThreadState* __tstate = wxPyBeginAllowThreads();
28352 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28353 wxPyEndAllowThreads(__tstate);
28354 if (PyErr_Occurred()) SWIG_fail;
28355 }
28356 {
28357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28358 }
28359 return resultobj;
28360 fail:
28361 return NULL;
28362 }
28363
28364
28365 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28366 PyObject *resultobj = 0;
28367 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28368 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28369 bool result;
28370 void *argp1 = 0 ;
28371 int res1 = 0 ;
28372 void *argp2 = 0 ;
28373 int res2 = 0 ;
28374 PyObject * obj0 = 0 ;
28375 PyObject * obj1 = 0 ;
28376 char * kwnames[] = {
28377 (char *) "self",(char *) "other", NULL
28378 };
28379
28380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28382 if (!SWIG_IsOK(res1)) {
28383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28384 }
28385 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28387 if (!SWIG_IsOK(res2)) {
28388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28389 }
28390 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28391 {
28392 PyThreadState* __tstate = wxPyBeginAllowThreads();
28393 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28394 wxPyEndAllowThreads(__tstate);
28395 if (PyErr_Occurred()) SWIG_fail;
28396 }
28397 {
28398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28399 }
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28407 PyObject *resultobj = 0;
28408 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28409 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28410 bool result;
28411 void *argp1 = 0 ;
28412 int res1 = 0 ;
28413 void *argp2 = 0 ;
28414 int res2 = 0 ;
28415 PyObject * obj0 = 0 ;
28416 PyObject * obj1 = 0 ;
28417 char * kwnames[] = {
28418 (char *) "self",(char *) "other", NULL
28419 };
28420
28421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28423 if (!SWIG_IsOK(res1)) {
28424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28425 }
28426 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28427 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28428 if (!SWIG_IsOK(res2)) {
28429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28430 }
28431 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28432 {
28433 PyThreadState* __tstate = wxPyBeginAllowThreads();
28434 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 {
28439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28440 }
28441 return resultobj;
28442 fail:
28443 return NULL;
28444 }
28445
28446
28447 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28448 PyObject *resultobj = 0;
28449 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28450 bool result;
28451 void *argp1 = 0 ;
28452 int res1 = 0 ;
28453 PyObject *swig_obj[1] ;
28454
28455 if (!args) SWIG_fail;
28456 swig_obj[0] = args;
28457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28458 if (!SWIG_IsOK(res1)) {
28459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28460 }
28461 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 {
28469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28470 }
28471 return resultobj;
28472 fail:
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28478 PyObject *resultobj = 0;
28479 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28480 bool result;
28481 void *argp1 = 0 ;
28482 int res1 = 0 ;
28483 PyObject *swig_obj[1] ;
28484
28485 if (!args) SWIG_fail;
28486 swig_obj[0] = args;
28487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28488 if (!SWIG_IsOK(res1)) {
28489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28490 }
28491 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28492 {
28493 PyThreadState* __tstate = wxPyBeginAllowThreads();
28494 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 {
28499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28500 }
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28508 PyObject *resultobj = 0;
28509 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28510 bool result;
28511 void *argp1 = 0 ;
28512 int res1 = 0 ;
28513 PyObject *swig_obj[1] ;
28514
28515 if (!args) SWIG_fail;
28516 swig_obj[0] = args;
28517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28518 if (!SWIG_IsOK(res1)) {
28519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28520 }
28521 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 {
28529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28530 }
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28538 PyObject *resultobj = 0;
28539 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28540 wxTimeSpan *arg2 = 0 ;
28541 bool result;
28542 void *argp1 = 0 ;
28543 int res1 = 0 ;
28544 void *argp2 = 0 ;
28545 int res2 = 0 ;
28546 PyObject * obj0 = 0 ;
28547 PyObject * obj1 = 0 ;
28548 char * kwnames[] = {
28549 (char *) "self",(char *) "ts", NULL
28550 };
28551
28552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28554 if (!SWIG_IsOK(res1)) {
28555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28556 }
28557 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28558 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28559 if (!SWIG_IsOK(res2)) {
28560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28561 }
28562 if (!argp2) {
28563 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28564 }
28565 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28569 wxPyEndAllowThreads(__tstate);
28570 if (PyErr_Occurred()) SWIG_fail;
28571 }
28572 {
28573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28574 }
28575 return resultobj;
28576 fail:
28577 return NULL;
28578 }
28579
28580
28581 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28582 PyObject *resultobj = 0;
28583 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28584 wxTimeSpan *arg2 = 0 ;
28585 bool result;
28586 void *argp1 = 0 ;
28587 int res1 = 0 ;
28588 void *argp2 = 0 ;
28589 int res2 = 0 ;
28590 PyObject * obj0 = 0 ;
28591 PyObject * obj1 = 0 ;
28592 char * kwnames[] = {
28593 (char *) "self",(char *) "ts", NULL
28594 };
28595
28596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28598 if (!SWIG_IsOK(res1)) {
28599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28600 }
28601 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28602 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28603 if (!SWIG_IsOK(res2)) {
28604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28605 }
28606 if (!argp2) {
28607 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28608 }
28609 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28610 {
28611 PyThreadState* __tstate = wxPyBeginAllowThreads();
28612 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28613 wxPyEndAllowThreads(__tstate);
28614 if (PyErr_Occurred()) SWIG_fail;
28615 }
28616 {
28617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28618 }
28619 return resultobj;
28620 fail:
28621 return NULL;
28622 }
28623
28624
28625 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28626 PyObject *resultobj = 0;
28627 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28628 wxTimeSpan *arg2 = 0 ;
28629 bool result;
28630 void *argp1 = 0 ;
28631 int res1 = 0 ;
28632 void *argp2 = 0 ;
28633 int res2 = 0 ;
28634 PyObject * obj0 = 0 ;
28635 PyObject * obj1 = 0 ;
28636 char * kwnames[] = {
28637 (char *) "self",(char *) "t", NULL
28638 };
28639
28640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28642 if (!SWIG_IsOK(res1)) {
28643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28644 }
28645 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28647 if (!SWIG_IsOK(res2)) {
28648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28649 }
28650 if (!argp2) {
28651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28652 }
28653 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 {
28661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28662 }
28663 return resultobj;
28664 fail:
28665 return NULL;
28666 }
28667
28668
28669 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28670 PyObject *resultobj = 0;
28671 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28672 int result;
28673 void *argp1 = 0 ;
28674 int res1 = 0 ;
28675 PyObject *swig_obj[1] ;
28676
28677 if (!args) SWIG_fail;
28678 swig_obj[0] = args;
28679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28680 if (!SWIG_IsOK(res1)) {
28681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28682 }
28683 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28684 {
28685 PyThreadState* __tstate = wxPyBeginAllowThreads();
28686 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 resultobj = SWIG_From_int(static_cast< int >(result));
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28698 PyObject *resultobj = 0;
28699 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28700 int result;
28701 void *argp1 = 0 ;
28702 int res1 = 0 ;
28703 PyObject *swig_obj[1] ;
28704
28705 if (!args) SWIG_fail;
28706 swig_obj[0] = args;
28707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28708 if (!SWIG_IsOK(res1)) {
28709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28710 }
28711 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28712 {
28713 PyThreadState* __tstate = wxPyBeginAllowThreads();
28714 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28715 wxPyEndAllowThreads(__tstate);
28716 if (PyErr_Occurred()) SWIG_fail;
28717 }
28718 resultobj = SWIG_From_int(static_cast< int >(result));
28719 return resultobj;
28720 fail:
28721 return NULL;
28722 }
28723
28724
28725 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28726 PyObject *resultobj = 0;
28727 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28728 int result;
28729 void *argp1 = 0 ;
28730 int res1 = 0 ;
28731 PyObject *swig_obj[1] ;
28732
28733 if (!args) SWIG_fail;
28734 swig_obj[0] = args;
28735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28736 if (!SWIG_IsOK(res1)) {
28737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28738 }
28739 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28740 {
28741 PyThreadState* __tstate = wxPyBeginAllowThreads();
28742 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28743 wxPyEndAllowThreads(__tstate);
28744 if (PyErr_Occurred()) SWIG_fail;
28745 }
28746 resultobj = SWIG_From_int(static_cast< int >(result));
28747 return resultobj;
28748 fail:
28749 return NULL;
28750 }
28751
28752
28753 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28754 PyObject *resultobj = 0;
28755 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28756 int result;
28757 void *argp1 = 0 ;
28758 int res1 = 0 ;
28759 PyObject *swig_obj[1] ;
28760
28761 if (!args) SWIG_fail;
28762 swig_obj[0] = args;
28763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28764 if (!SWIG_IsOK(res1)) {
28765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28766 }
28767 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28768 {
28769 PyThreadState* __tstate = wxPyBeginAllowThreads();
28770 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 resultobj = SWIG_From_int(static_cast< int >(result));
28775 return resultobj;
28776 fail:
28777 return NULL;
28778 }
28779
28780
28781 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28782 PyObject *resultobj = 0;
28783 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28784 wxLongLong result;
28785 void *argp1 = 0 ;
28786 int res1 = 0 ;
28787 PyObject *swig_obj[1] ;
28788
28789 if (!args) SWIG_fail;
28790 swig_obj[0] = args;
28791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28792 if (!SWIG_IsOK(res1)) {
28793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28794 }
28795 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 {
28803 PyObject *hi, *lo, *shifter, *shifted;
28804 hi = PyLong_FromLong( (&result)->GetHi() );
28805 lo = PyLong_FromLong( (&result)->GetLo() );
28806 shifter = PyLong_FromLong(32);
28807 shifted = PyNumber_Lshift(hi, shifter);
28808 resultobj = PyNumber_Or(shifted, lo);
28809 Py_DECREF(hi);
28810 Py_DECREF(lo);
28811 Py_DECREF(shifter);
28812 Py_DECREF(shifted);
28813 }
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28821 PyObject *resultobj = 0;
28822 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28823 wxLongLong result;
28824 void *argp1 = 0 ;
28825 int res1 = 0 ;
28826 PyObject *swig_obj[1] ;
28827
28828 if (!args) SWIG_fail;
28829 swig_obj[0] = args;
28830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28831 if (!SWIG_IsOK(res1)) {
28832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28833 }
28834 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28835 {
28836 PyThreadState* __tstate = wxPyBeginAllowThreads();
28837 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28838 wxPyEndAllowThreads(__tstate);
28839 if (PyErr_Occurred()) SWIG_fail;
28840 }
28841 {
28842 PyObject *hi, *lo, *shifter, *shifted;
28843 hi = PyLong_FromLong( (&result)->GetHi() );
28844 lo = PyLong_FromLong( (&result)->GetLo() );
28845 shifter = PyLong_FromLong(32);
28846 shifted = PyNumber_Lshift(hi, shifter);
28847 resultobj = PyNumber_Or(shifted, lo);
28848 Py_DECREF(hi);
28849 Py_DECREF(lo);
28850 Py_DECREF(shifter);
28851 Py_DECREF(shifted);
28852 }
28853 return resultobj;
28854 fail:
28855 return NULL;
28856 }
28857
28858
28859 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28860 PyObject *resultobj = 0;
28861 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28862 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28863 wxString *arg2 = (wxString *) &arg2_defvalue ;
28864 wxString result;
28865 void *argp1 = 0 ;
28866 int res1 = 0 ;
28867 bool temp2 = false ;
28868 PyObject * obj0 = 0 ;
28869 PyObject * obj1 = 0 ;
28870 char * kwnames[] = {
28871 (char *) "self",(char *) "format", NULL
28872 };
28873
28874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28876 if (!SWIG_IsOK(res1)) {
28877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28878 }
28879 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28880 if (obj1) {
28881 {
28882 arg2 = wxString_in_helper(obj1);
28883 if (arg2 == NULL) SWIG_fail;
28884 temp2 = true;
28885 }
28886 }
28887 {
28888 PyThreadState* __tstate = wxPyBeginAllowThreads();
28889 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28890 wxPyEndAllowThreads(__tstate);
28891 if (PyErr_Occurred()) SWIG_fail;
28892 }
28893 {
28894 #if wxUSE_UNICODE
28895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28896 #else
28897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28898 #endif
28899 }
28900 {
28901 if (temp2)
28902 delete arg2;
28903 }
28904 return resultobj;
28905 fail:
28906 {
28907 if (temp2)
28908 delete arg2;
28909 }
28910 return NULL;
28911 }
28912
28913
28914 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28915 PyObject *obj;
28916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28917 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28918 return SWIG_Py_Void();
28919 }
28920
28921 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28922 return SWIG_Python_InitShadowInstance(args);
28923 }
28924
28925 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28926 PyObject *resultobj = 0;
28927 int arg1 = (int) 0 ;
28928 int arg2 = (int) 0 ;
28929 int arg3 = (int) 0 ;
28930 int arg4 = (int) 0 ;
28931 wxDateSpan *result = 0 ;
28932 int val1 ;
28933 int ecode1 = 0 ;
28934 int val2 ;
28935 int ecode2 = 0 ;
28936 int val3 ;
28937 int ecode3 = 0 ;
28938 int val4 ;
28939 int ecode4 = 0 ;
28940 PyObject * obj0 = 0 ;
28941 PyObject * obj1 = 0 ;
28942 PyObject * obj2 = 0 ;
28943 PyObject * obj3 = 0 ;
28944 char * kwnames[] = {
28945 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28946 };
28947
28948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28949 if (obj0) {
28950 ecode1 = SWIG_AsVal_int(obj0, &val1);
28951 if (!SWIG_IsOK(ecode1)) {
28952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28953 }
28954 arg1 = static_cast< int >(val1);
28955 }
28956 if (obj1) {
28957 ecode2 = SWIG_AsVal_int(obj1, &val2);
28958 if (!SWIG_IsOK(ecode2)) {
28959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28960 }
28961 arg2 = static_cast< int >(val2);
28962 }
28963 if (obj2) {
28964 ecode3 = SWIG_AsVal_int(obj2, &val3);
28965 if (!SWIG_IsOK(ecode3)) {
28966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28967 }
28968 arg3 = static_cast< int >(val3);
28969 }
28970 if (obj3) {
28971 ecode4 = SWIG_AsVal_int(obj3, &val4);
28972 if (!SWIG_IsOK(ecode4)) {
28973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28974 }
28975 arg4 = static_cast< int >(val4);
28976 }
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28980 wxPyEndAllowThreads(__tstate);
28981 if (PyErr_Occurred()) SWIG_fail;
28982 }
28983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28984 return resultobj;
28985 fail:
28986 return NULL;
28987 }
28988
28989
28990 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28991 PyObject *resultobj = 0;
28992 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
28993 void *argp1 = 0 ;
28994 int res1 = 0 ;
28995 PyObject *swig_obj[1] ;
28996
28997 if (!args) SWIG_fail;
28998 swig_obj[0] = args;
28999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29000 if (!SWIG_IsOK(res1)) {
29001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29002 }
29003 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29004 {
29005 PyThreadState* __tstate = wxPyBeginAllowThreads();
29006 delete arg1;
29007
29008 wxPyEndAllowThreads(__tstate);
29009 if (PyErr_Occurred()) SWIG_fail;
29010 }
29011 resultobj = SWIG_Py_Void();
29012 return resultobj;
29013 fail:
29014 return NULL;
29015 }
29016
29017
29018 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29019 PyObject *resultobj = 0;
29020 int arg1 ;
29021 wxDateSpan result;
29022 int val1 ;
29023 int ecode1 = 0 ;
29024 PyObject * obj0 = 0 ;
29025 char * kwnames[] = {
29026 (char *) "days", NULL
29027 };
29028
29029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29030 ecode1 = SWIG_AsVal_int(obj0, &val1);
29031 if (!SWIG_IsOK(ecode1)) {
29032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29033 }
29034 arg1 = static_cast< int >(val1);
29035 {
29036 PyThreadState* __tstate = wxPyBeginAllowThreads();
29037 result = wxDateSpan::Days(arg1);
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29042 return resultobj;
29043 fail:
29044 return NULL;
29045 }
29046
29047
29048 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29049 PyObject *resultobj = 0;
29050 wxDateSpan result;
29051
29052 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = wxDateSpan::Day();
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29060 return resultobj;
29061 fail:
29062 return NULL;
29063 }
29064
29065
29066 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29067 PyObject *resultobj = 0;
29068 int arg1 ;
29069 wxDateSpan result;
29070 int val1 ;
29071 int ecode1 = 0 ;
29072 PyObject * obj0 = 0 ;
29073 char * kwnames[] = {
29074 (char *) "weeks", NULL
29075 };
29076
29077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29078 ecode1 = SWIG_AsVal_int(obj0, &val1);
29079 if (!SWIG_IsOK(ecode1)) {
29080 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29081 }
29082 arg1 = static_cast< int >(val1);
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 result = wxDateSpan::Weeks(arg1);
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29090 return resultobj;
29091 fail:
29092 return NULL;
29093 }
29094
29095
29096 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29097 PyObject *resultobj = 0;
29098 wxDateSpan result;
29099
29100 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29101 {
29102 PyThreadState* __tstate = wxPyBeginAllowThreads();
29103 result = wxDateSpan::Week();
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29108 return resultobj;
29109 fail:
29110 return NULL;
29111 }
29112
29113
29114 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29115 PyObject *resultobj = 0;
29116 int arg1 ;
29117 wxDateSpan result;
29118 int val1 ;
29119 int ecode1 = 0 ;
29120 PyObject * obj0 = 0 ;
29121 char * kwnames[] = {
29122 (char *) "mon", NULL
29123 };
29124
29125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29126 ecode1 = SWIG_AsVal_int(obj0, &val1);
29127 if (!SWIG_IsOK(ecode1)) {
29128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29129 }
29130 arg1 = static_cast< int >(val1);
29131 {
29132 PyThreadState* __tstate = wxPyBeginAllowThreads();
29133 result = wxDateSpan::Months(arg1);
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29145 PyObject *resultobj = 0;
29146 wxDateSpan result;
29147
29148 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 result = wxDateSpan::Month();
29152 wxPyEndAllowThreads(__tstate);
29153 if (PyErr_Occurred()) SWIG_fail;
29154 }
29155 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29156 return resultobj;
29157 fail:
29158 return NULL;
29159 }
29160
29161
29162 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29163 PyObject *resultobj = 0;
29164 int arg1 ;
29165 wxDateSpan result;
29166 int val1 ;
29167 int ecode1 = 0 ;
29168 PyObject * obj0 = 0 ;
29169 char * kwnames[] = {
29170 (char *) "years", NULL
29171 };
29172
29173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29174 ecode1 = SWIG_AsVal_int(obj0, &val1);
29175 if (!SWIG_IsOK(ecode1)) {
29176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29177 }
29178 arg1 = static_cast< int >(val1);
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 result = wxDateSpan::Years(arg1);
29182 wxPyEndAllowThreads(__tstate);
29183 if (PyErr_Occurred()) SWIG_fail;
29184 }
29185 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29186 return resultobj;
29187 fail:
29188 return NULL;
29189 }
29190
29191
29192 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29193 PyObject *resultobj = 0;
29194 wxDateSpan result;
29195
29196 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29197 {
29198 PyThreadState* __tstate = wxPyBeginAllowThreads();
29199 result = wxDateSpan::Year();
29200 wxPyEndAllowThreads(__tstate);
29201 if (PyErr_Occurred()) SWIG_fail;
29202 }
29203 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29211 PyObject *resultobj = 0;
29212 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29213 int arg2 ;
29214 wxDateSpan *result = 0 ;
29215 void *argp1 = 0 ;
29216 int res1 = 0 ;
29217 int val2 ;
29218 int ecode2 = 0 ;
29219 PyObject * obj0 = 0 ;
29220 PyObject * obj1 = 0 ;
29221 char * kwnames[] = {
29222 (char *) "self",(char *) "n", NULL
29223 };
29224
29225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29227 if (!SWIG_IsOK(res1)) {
29228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29229 }
29230 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29231 ecode2 = SWIG_AsVal_int(obj1, &val2);
29232 if (!SWIG_IsOK(ecode2)) {
29233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29234 }
29235 arg2 = static_cast< int >(val2);
29236 {
29237 PyThreadState* __tstate = wxPyBeginAllowThreads();
29238 {
29239 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29240 result = (wxDateSpan *) &_result_ref;
29241 }
29242 wxPyEndAllowThreads(__tstate);
29243 if (PyErr_Occurred()) SWIG_fail;
29244 }
29245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29246 return resultobj;
29247 fail:
29248 return NULL;
29249 }
29250
29251
29252 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29253 PyObject *resultobj = 0;
29254 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29255 int arg2 ;
29256 wxDateSpan *result = 0 ;
29257 void *argp1 = 0 ;
29258 int res1 = 0 ;
29259 int val2 ;
29260 int ecode2 = 0 ;
29261 PyObject * obj0 = 0 ;
29262 PyObject * obj1 = 0 ;
29263 char * kwnames[] = {
29264 (char *) "self",(char *) "n", NULL
29265 };
29266
29267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29269 if (!SWIG_IsOK(res1)) {
29270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29271 }
29272 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29273 ecode2 = SWIG_AsVal_int(obj1, &val2);
29274 if (!SWIG_IsOK(ecode2)) {
29275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29276 }
29277 arg2 = static_cast< int >(val2);
29278 {
29279 PyThreadState* __tstate = wxPyBeginAllowThreads();
29280 {
29281 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29282 result = (wxDateSpan *) &_result_ref;
29283 }
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29295 PyObject *resultobj = 0;
29296 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29297 int arg2 ;
29298 wxDateSpan *result = 0 ;
29299 void *argp1 = 0 ;
29300 int res1 = 0 ;
29301 int val2 ;
29302 int ecode2 = 0 ;
29303 PyObject * obj0 = 0 ;
29304 PyObject * obj1 = 0 ;
29305 char * kwnames[] = {
29306 (char *) "self",(char *) "n", NULL
29307 };
29308
29309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29311 if (!SWIG_IsOK(res1)) {
29312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29313 }
29314 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29315 ecode2 = SWIG_AsVal_int(obj1, &val2);
29316 if (!SWIG_IsOK(ecode2)) {
29317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29318 }
29319 arg2 = static_cast< int >(val2);
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 {
29323 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29324 result = (wxDateSpan *) &_result_ref;
29325 }
29326 wxPyEndAllowThreads(__tstate);
29327 if (PyErr_Occurred()) SWIG_fail;
29328 }
29329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29330 return resultobj;
29331 fail:
29332 return NULL;
29333 }
29334
29335
29336 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29337 PyObject *resultobj = 0;
29338 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29339 int arg2 ;
29340 wxDateSpan *result = 0 ;
29341 void *argp1 = 0 ;
29342 int res1 = 0 ;
29343 int val2 ;
29344 int ecode2 = 0 ;
29345 PyObject * obj0 = 0 ;
29346 PyObject * obj1 = 0 ;
29347 char * kwnames[] = {
29348 (char *) "self",(char *) "n", NULL
29349 };
29350
29351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29353 if (!SWIG_IsOK(res1)) {
29354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29355 }
29356 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29357 ecode2 = SWIG_AsVal_int(obj1, &val2);
29358 if (!SWIG_IsOK(ecode2)) {
29359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29360 }
29361 arg2 = static_cast< int >(val2);
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 {
29365 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29366 result = (wxDateSpan *) &_result_ref;
29367 }
29368 wxPyEndAllowThreads(__tstate);
29369 if (PyErr_Occurred()) SWIG_fail;
29370 }
29371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29379 PyObject *resultobj = 0;
29380 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29381 int result;
29382 void *argp1 = 0 ;
29383 int res1 = 0 ;
29384 PyObject *swig_obj[1] ;
29385
29386 if (!args) SWIG_fail;
29387 swig_obj[0] = args;
29388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29389 if (!SWIG_IsOK(res1)) {
29390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29391 }
29392 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 result = (int)((wxDateSpan const *)arg1)->GetYears();
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 resultobj = SWIG_From_int(static_cast< int >(result));
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29407 PyObject *resultobj = 0;
29408 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29409 int result;
29410 void *argp1 = 0 ;
29411 int res1 = 0 ;
29412 PyObject *swig_obj[1] ;
29413
29414 if (!args) SWIG_fail;
29415 swig_obj[0] = args;
29416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29417 if (!SWIG_IsOK(res1)) {
29418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29419 }
29420 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29421 {
29422 PyThreadState* __tstate = wxPyBeginAllowThreads();
29423 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29424 wxPyEndAllowThreads(__tstate);
29425 if (PyErr_Occurred()) SWIG_fail;
29426 }
29427 resultobj = SWIG_From_int(static_cast< int >(result));
29428 return resultobj;
29429 fail:
29430 return NULL;
29431 }
29432
29433
29434 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29435 PyObject *resultobj = 0;
29436 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29437 int result;
29438 void *argp1 = 0 ;
29439 int res1 = 0 ;
29440 PyObject *swig_obj[1] ;
29441
29442 if (!args) SWIG_fail;
29443 swig_obj[0] = args;
29444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29445 if (!SWIG_IsOK(res1)) {
29446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29447 }
29448 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29449 {
29450 PyThreadState* __tstate = wxPyBeginAllowThreads();
29451 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29452 wxPyEndAllowThreads(__tstate);
29453 if (PyErr_Occurred()) SWIG_fail;
29454 }
29455 resultobj = SWIG_From_int(static_cast< int >(result));
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29463 PyObject *resultobj = 0;
29464 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29465 int result;
29466 void *argp1 = 0 ;
29467 int res1 = 0 ;
29468 PyObject *swig_obj[1] ;
29469
29470 if (!args) SWIG_fail;
29471 swig_obj[0] = args;
29472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29473 if (!SWIG_IsOK(res1)) {
29474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29475 }
29476 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 result = (int)((wxDateSpan const *)arg1)->GetDays();
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 resultobj = SWIG_From_int(static_cast< int >(result));
29484 return resultobj;
29485 fail:
29486 return NULL;
29487 }
29488
29489
29490 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29491 PyObject *resultobj = 0;
29492 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29493 int result;
29494 void *argp1 = 0 ;
29495 int res1 = 0 ;
29496 PyObject *swig_obj[1] ;
29497
29498 if (!args) SWIG_fail;
29499 swig_obj[0] = args;
29500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29501 if (!SWIG_IsOK(res1)) {
29502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29503 }
29504 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29505 {
29506 PyThreadState* __tstate = wxPyBeginAllowThreads();
29507 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29508 wxPyEndAllowThreads(__tstate);
29509 if (PyErr_Occurred()) SWIG_fail;
29510 }
29511 resultobj = SWIG_From_int(static_cast< int >(result));
29512 return resultobj;
29513 fail:
29514 return NULL;
29515 }
29516
29517
29518 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29519 PyObject *resultobj = 0;
29520 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29521 wxDateSpan *arg2 = 0 ;
29522 wxDateSpan *result = 0 ;
29523 void *argp1 = 0 ;
29524 int res1 = 0 ;
29525 void *argp2 = 0 ;
29526 int res2 = 0 ;
29527 PyObject * obj0 = 0 ;
29528 PyObject * obj1 = 0 ;
29529 char * kwnames[] = {
29530 (char *) "self",(char *) "other", NULL
29531 };
29532
29533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29535 if (!SWIG_IsOK(res1)) {
29536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29537 }
29538 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29540 if (!SWIG_IsOK(res2)) {
29541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29542 }
29543 if (!argp2) {
29544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29545 }
29546 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29547 {
29548 PyThreadState* __tstate = wxPyBeginAllowThreads();
29549 {
29550 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29551 result = (wxDateSpan *) &_result_ref;
29552 }
29553 wxPyEndAllowThreads(__tstate);
29554 if (PyErr_Occurred()) SWIG_fail;
29555 }
29556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj = 0;
29565 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29566 wxDateSpan *arg2 = 0 ;
29567 wxDateSpan *result = 0 ;
29568 void *argp1 = 0 ;
29569 int res1 = 0 ;
29570 void *argp2 = 0 ;
29571 int res2 = 0 ;
29572 PyObject * obj0 = 0 ;
29573 PyObject * obj1 = 0 ;
29574 char * kwnames[] = {
29575 (char *) "self",(char *) "other", NULL
29576 };
29577
29578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29580 if (!SWIG_IsOK(res1)) {
29581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29582 }
29583 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29584 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29585 if (!SWIG_IsOK(res2)) {
29586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29587 }
29588 if (!argp2) {
29589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29590 }
29591 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 {
29595 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29596 result = (wxDateSpan *) &_result_ref;
29597 }
29598 wxPyEndAllowThreads(__tstate);
29599 if (PyErr_Occurred()) SWIG_fail;
29600 }
29601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29602 return resultobj;
29603 fail:
29604 return NULL;
29605 }
29606
29607
29608 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29609 PyObject *resultobj = 0;
29610 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29611 wxDateSpan *result = 0 ;
29612 void *argp1 = 0 ;
29613 int res1 = 0 ;
29614 PyObject *swig_obj[1] ;
29615
29616 if (!args) SWIG_fail;
29617 swig_obj[0] = args;
29618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29619 if (!SWIG_IsOK(res1)) {
29620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29621 }
29622 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29623 {
29624 PyThreadState* __tstate = wxPyBeginAllowThreads();
29625 {
29626 wxDateSpan &_result_ref = (arg1)->Neg();
29627 result = (wxDateSpan *) &_result_ref;
29628 }
29629 wxPyEndAllowThreads(__tstate);
29630 if (PyErr_Occurred()) SWIG_fail;
29631 }
29632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29633 return resultobj;
29634 fail:
29635 return NULL;
29636 }
29637
29638
29639 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29640 PyObject *resultobj = 0;
29641 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29642 int arg2 ;
29643 wxDateSpan *result = 0 ;
29644 void *argp1 = 0 ;
29645 int res1 = 0 ;
29646 int val2 ;
29647 int ecode2 = 0 ;
29648 PyObject * obj0 = 0 ;
29649 PyObject * obj1 = 0 ;
29650 char * kwnames[] = {
29651 (char *) "self",(char *) "factor", NULL
29652 };
29653
29654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29656 if (!SWIG_IsOK(res1)) {
29657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29658 }
29659 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29660 ecode2 = SWIG_AsVal_int(obj1, &val2);
29661 if (!SWIG_IsOK(ecode2)) {
29662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29663 }
29664 arg2 = static_cast< int >(val2);
29665 {
29666 PyThreadState* __tstate = wxPyBeginAllowThreads();
29667 {
29668 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29669 result = (wxDateSpan *) &_result_ref;
29670 }
29671 wxPyEndAllowThreads(__tstate);
29672 if (PyErr_Occurred()) SWIG_fail;
29673 }
29674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29682 PyObject *resultobj = 0;
29683 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29684 wxDateSpan *arg2 = 0 ;
29685 wxDateSpan *result = 0 ;
29686 void *argp1 = 0 ;
29687 int res1 = 0 ;
29688 void *argp2 = 0 ;
29689 int res2 = 0 ;
29690 PyObject * obj0 = 0 ;
29691 PyObject * obj1 = 0 ;
29692 char * kwnames[] = {
29693 (char *) "self",(char *) "other", NULL
29694 };
29695
29696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29698 if (!SWIG_IsOK(res1)) {
29699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29700 }
29701 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29702 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29703 if (!SWIG_IsOK(res2)) {
29704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29705 }
29706 if (!argp2) {
29707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29708 }
29709 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29710 {
29711 PyThreadState* __tstate = wxPyBeginAllowThreads();
29712 {
29713 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29714 result = (wxDateSpan *) &_result_ref;
29715 }
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29720 return resultobj;
29721 fail:
29722 return NULL;
29723 }
29724
29725
29726 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29727 PyObject *resultobj = 0;
29728 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29729 wxDateSpan *arg2 = 0 ;
29730 wxDateSpan *result = 0 ;
29731 void *argp1 = 0 ;
29732 int res1 = 0 ;
29733 void *argp2 = 0 ;
29734 int res2 = 0 ;
29735 PyObject * obj0 = 0 ;
29736 PyObject * obj1 = 0 ;
29737 char * kwnames[] = {
29738 (char *) "self",(char *) "other", NULL
29739 };
29740
29741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29743 if (!SWIG_IsOK(res1)) {
29744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29745 }
29746 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29748 if (!SWIG_IsOK(res2)) {
29749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29750 }
29751 if (!argp2) {
29752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29753 }
29754 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 {
29758 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29759 result = (wxDateSpan *) &_result_ref;
29760 }
29761 wxPyEndAllowThreads(__tstate);
29762 if (PyErr_Occurred()) SWIG_fail;
29763 }
29764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29765 return resultobj;
29766 fail:
29767 return NULL;
29768 }
29769
29770
29771 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29772 PyObject *resultobj = 0;
29773 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29774 wxDateSpan *result = 0 ;
29775 void *argp1 = 0 ;
29776 int res1 = 0 ;
29777 PyObject *swig_obj[1] ;
29778
29779 if (!args) SWIG_fail;
29780 swig_obj[0] = args;
29781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29782 if (!SWIG_IsOK(res1)) {
29783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29784 }
29785 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 {
29789 wxDateSpan &_result_ref = (arg1)->operator -();
29790 result = (wxDateSpan *) &_result_ref;
29791 }
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj = 0;
29804 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29805 int arg2 ;
29806 wxDateSpan *result = 0 ;
29807 void *argp1 = 0 ;
29808 int res1 = 0 ;
29809 int val2 ;
29810 int ecode2 = 0 ;
29811 PyObject * obj0 = 0 ;
29812 PyObject * obj1 = 0 ;
29813 char * kwnames[] = {
29814 (char *) "self",(char *) "factor", NULL
29815 };
29816
29817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29819 if (!SWIG_IsOK(res1)) {
29820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29821 }
29822 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29823 ecode2 = SWIG_AsVal_int(obj1, &val2);
29824 if (!SWIG_IsOK(ecode2)) {
29825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29826 }
29827 arg2 = static_cast< int >(val2);
29828 {
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 {
29831 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29832 result = (wxDateSpan *) &_result_ref;
29833 }
29834 wxPyEndAllowThreads(__tstate);
29835 if (PyErr_Occurred()) SWIG_fail;
29836 }
29837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29838 return resultobj;
29839 fail:
29840 return NULL;
29841 }
29842
29843
29844 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29845 PyObject *resultobj = 0;
29846 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29847 wxDateSpan *arg2 = 0 ;
29848 wxDateSpan result;
29849 void *argp1 = 0 ;
29850 int res1 = 0 ;
29851 void *argp2 = 0 ;
29852 int res2 = 0 ;
29853 PyObject * obj0 = 0 ;
29854 PyObject * obj1 = 0 ;
29855 char * kwnames[] = {
29856 (char *) "self",(char *) "other", NULL
29857 };
29858
29859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29861 if (!SWIG_IsOK(res1)) {
29862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29863 }
29864 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29865 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29866 if (!SWIG_IsOK(res2)) {
29867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29868 }
29869 if (!argp2) {
29870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29871 }
29872 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29873 {
29874 PyThreadState* __tstate = wxPyBeginAllowThreads();
29875 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29876 wxPyEndAllowThreads(__tstate);
29877 if (PyErr_Occurred()) SWIG_fail;
29878 }
29879 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29880 return resultobj;
29881 fail:
29882 return NULL;
29883 }
29884
29885
29886 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29887 PyObject *resultobj = 0;
29888 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29889 wxDateSpan *arg2 = 0 ;
29890 wxDateSpan result;
29891 void *argp1 = 0 ;
29892 int res1 = 0 ;
29893 void *argp2 = 0 ;
29894 int res2 = 0 ;
29895 PyObject * obj0 = 0 ;
29896 PyObject * obj1 = 0 ;
29897 char * kwnames[] = {
29898 (char *) "self",(char *) "other", NULL
29899 };
29900
29901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29903 if (!SWIG_IsOK(res1)) {
29904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29905 }
29906 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29907 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29908 if (!SWIG_IsOK(res2)) {
29909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29910 }
29911 if (!argp2) {
29912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29913 }
29914 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29922 return resultobj;
29923 fail:
29924 return NULL;
29925 }
29926
29927
29928 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29929 PyObject *resultobj = 0;
29930 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29931 int arg2 ;
29932 wxDateSpan result;
29933 void *argp1 = 0 ;
29934 int res1 = 0 ;
29935 int val2 ;
29936 int ecode2 = 0 ;
29937 PyObject * obj0 = 0 ;
29938 PyObject * obj1 = 0 ;
29939 char * kwnames[] = {
29940 (char *) "self",(char *) "n", NULL
29941 };
29942
29943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29945 if (!SWIG_IsOK(res1)) {
29946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29947 }
29948 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29949 ecode2 = SWIG_AsVal_int(obj1, &val2);
29950 if (!SWIG_IsOK(ecode2)) {
29951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29952 }
29953 arg2 = static_cast< int >(val2);
29954 {
29955 PyThreadState* __tstate = wxPyBeginAllowThreads();
29956 result = wxDateSpan___mul__(arg1,arg2);
29957 wxPyEndAllowThreads(__tstate);
29958 if (PyErr_Occurred()) SWIG_fail;
29959 }
29960 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29961 return resultobj;
29962 fail:
29963 return NULL;
29964 }
29965
29966
29967 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29968 PyObject *resultobj = 0;
29969 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29970 int arg2 ;
29971 wxDateSpan result;
29972 void *argp1 = 0 ;
29973 int res1 = 0 ;
29974 int val2 ;
29975 int ecode2 = 0 ;
29976 PyObject * obj0 = 0 ;
29977 PyObject * obj1 = 0 ;
29978 char * kwnames[] = {
29979 (char *) "self",(char *) "n", NULL
29980 };
29981
29982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29986 }
29987 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29988 ecode2 = SWIG_AsVal_int(obj1, &val2);
29989 if (!SWIG_IsOK(ecode2)) {
29990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29991 }
29992 arg2 = static_cast< int >(val2);
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 result = wxDateSpan___rmul__(arg1,arg2);
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30000 return resultobj;
30001 fail:
30002 return NULL;
30003 }
30004
30005
30006 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj = 0;
30008 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30009 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30010 bool result;
30011 void *argp1 = 0 ;
30012 int res1 = 0 ;
30013 void *argp2 = 0 ;
30014 int res2 = 0 ;
30015 PyObject * obj0 = 0 ;
30016 PyObject * obj1 = 0 ;
30017 char * kwnames[] = {
30018 (char *) "self",(char *) "other", NULL
30019 };
30020
30021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30023 if (!SWIG_IsOK(res1)) {
30024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30025 }
30026 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30027 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30028 if (!SWIG_IsOK(res2)) {
30029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30030 }
30031 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30032 {
30033 PyThreadState* __tstate = wxPyBeginAllowThreads();
30034 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 {
30039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30040 }
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj = 0;
30049 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30050 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30051 bool result;
30052 void *argp1 = 0 ;
30053 int res1 = 0 ;
30054 void *argp2 = 0 ;
30055 int res2 = 0 ;
30056 PyObject * obj0 = 0 ;
30057 PyObject * obj1 = 0 ;
30058 char * kwnames[] = {
30059 (char *) "self",(char *) "other", NULL
30060 };
30061
30062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30064 if (!SWIG_IsOK(res1)) {
30065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30066 }
30067 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30069 if (!SWIG_IsOK(res2)) {
30070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30071 }
30072 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 {
30080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30081 }
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30089 PyObject *obj;
30090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30091 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30092 return SWIG_Py_Void();
30093 }
30094
30095 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30096 return SWIG_Python_InitShadowInstance(args);
30097 }
30098
30099 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *resultobj = 0;
30101 long result;
30102
30103 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30104 {
30105 PyThreadState* __tstate = wxPyBeginAllowThreads();
30106 result = (long)wxGetLocalTime();
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 resultobj = SWIG_From_long(static_cast< long >(result));
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30118 PyObject *resultobj = 0;
30119 long result;
30120
30121 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 result = (long)wxGetUTCTime();
30125 wxPyEndAllowThreads(__tstate);
30126 if (PyErr_Occurred()) SWIG_fail;
30127 }
30128 resultobj = SWIG_From_long(static_cast< long >(result));
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30136 PyObject *resultobj = 0;
30137 long result;
30138
30139 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30140 {
30141 PyThreadState* __tstate = wxPyBeginAllowThreads();
30142 result = (long)wxGetCurrentTime();
30143 wxPyEndAllowThreads(__tstate);
30144 if (PyErr_Occurred()) SWIG_fail;
30145 }
30146 resultobj = SWIG_From_long(static_cast< long >(result));
30147 return resultobj;
30148 fail:
30149 return NULL;
30150 }
30151
30152
30153 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30154 PyObject *resultobj = 0;
30155 wxLongLong result;
30156
30157 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 result = wxGetLocalTimeMillis();
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 {
30165 PyObject *hi, *lo, *shifter, *shifted;
30166 hi = PyLong_FromLong( (&result)->GetHi() );
30167 lo = PyLong_FromLong( (&result)->GetLo() );
30168 shifter = PyLong_FromLong(32);
30169 shifted = PyNumber_Lshift(hi, shifter);
30170 resultobj = PyNumber_Or(shifted, lo);
30171 Py_DECREF(hi);
30172 Py_DECREF(lo);
30173 Py_DECREF(shifter);
30174 Py_DECREF(shifted);
30175 }
30176 return resultobj;
30177 fail:
30178 return NULL;
30179 }
30180
30181
30182 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30183 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30184 return 1;
30185 }
30186
30187
30188 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30189 PyObject *pyobj = 0;
30190
30191 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30192 return pyobj;
30193 }
30194
30195
30196 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30197 PyObject *resultobj = 0;
30198 wxDataFormatId arg1 ;
30199 wxDataFormat *result = 0 ;
30200 int val1 ;
30201 int ecode1 = 0 ;
30202 PyObject * obj0 = 0 ;
30203 char * kwnames[] = {
30204 (char *) "type", NULL
30205 };
30206
30207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30208 ecode1 = SWIG_AsVal_int(obj0, &val1);
30209 if (!SWIG_IsOK(ecode1)) {
30210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30211 }
30212 arg1 = static_cast< wxDataFormatId >(val1);
30213 {
30214 PyThreadState* __tstate = wxPyBeginAllowThreads();
30215 result = (wxDataFormat *)new wxDataFormat(arg1);
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30220 return resultobj;
30221 fail:
30222 return NULL;
30223 }
30224
30225
30226 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30227 PyObject *resultobj = 0;
30228 wxString *arg1 = 0 ;
30229 wxDataFormat *result = 0 ;
30230 bool temp1 = false ;
30231 PyObject * obj0 = 0 ;
30232 char * kwnames[] = {
30233 (char *) "format", NULL
30234 };
30235
30236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30237 {
30238 arg1 = wxString_in_helper(obj0);
30239 if (arg1 == NULL) SWIG_fail;
30240 temp1 = true;
30241 }
30242 {
30243 PyThreadState* __tstate = wxPyBeginAllowThreads();
30244 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30245 wxPyEndAllowThreads(__tstate);
30246 if (PyErr_Occurred()) SWIG_fail;
30247 }
30248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30249 {
30250 if (temp1)
30251 delete arg1;
30252 }
30253 return resultobj;
30254 fail:
30255 {
30256 if (temp1)
30257 delete arg1;
30258 }
30259 return NULL;
30260 }
30261
30262
30263 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30264 PyObject *resultobj = 0;
30265 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30266 void *argp1 = 0 ;
30267 int res1 = 0 ;
30268 PyObject *swig_obj[1] ;
30269
30270 if (!args) SWIG_fail;
30271 swig_obj[0] = args;
30272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30273 if (!SWIG_IsOK(res1)) {
30274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30275 }
30276 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30277 {
30278 PyThreadState* __tstate = wxPyBeginAllowThreads();
30279 delete arg1;
30280
30281 wxPyEndAllowThreads(__tstate);
30282 if (PyErr_Occurred()) SWIG_fail;
30283 }
30284 resultobj = SWIG_Py_Void();
30285 return resultobj;
30286 fail:
30287 return NULL;
30288 }
30289
30290
30291 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30292 PyObject *resultobj = 0;
30293 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30294 wxDataFormatId arg2 ;
30295 bool result;
30296 void *argp1 = 0 ;
30297 int res1 = 0 ;
30298 int val2 ;
30299 int ecode2 = 0 ;
30300
30301 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30303 if (!SWIG_IsOK(res1)) {
30304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30305 }
30306 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30307 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30308 if (!SWIG_IsOK(ecode2)) {
30309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30310 }
30311 arg2 = static_cast< wxDataFormatId >(val2);
30312 {
30313 PyThreadState* __tstate = wxPyBeginAllowThreads();
30314 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30315 wxPyEndAllowThreads(__tstate);
30316 if (PyErr_Occurred()) SWIG_fail;
30317 }
30318 {
30319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30320 }
30321 return resultobj;
30322 fail:
30323 return NULL;
30324 }
30325
30326
30327 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30328 PyObject *resultobj = 0;
30329 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30330 wxDataFormatId arg2 ;
30331 bool result;
30332 void *argp1 = 0 ;
30333 int res1 = 0 ;
30334 int val2 ;
30335 int ecode2 = 0 ;
30336
30337 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30339 if (!SWIG_IsOK(res1)) {
30340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30341 }
30342 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30343 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30344 if (!SWIG_IsOK(ecode2)) {
30345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30346 }
30347 arg2 = static_cast< wxDataFormatId >(val2);
30348 {
30349 PyThreadState* __tstate = wxPyBeginAllowThreads();
30350 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30351 wxPyEndAllowThreads(__tstate);
30352 if (PyErr_Occurred()) SWIG_fail;
30353 }
30354 {
30355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30356 }
30357 return resultobj;
30358 fail:
30359 return NULL;
30360 }
30361
30362
30363 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30364 PyObject *resultobj = 0;
30365 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30366 wxDataFormat *arg2 = 0 ;
30367 bool result;
30368 void *argp1 = 0 ;
30369 int res1 = 0 ;
30370 void *argp2 = 0 ;
30371 int res2 = 0 ;
30372
30373 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30375 if (!SWIG_IsOK(res1)) {
30376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30377 }
30378 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30379 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30380 if (!SWIG_IsOK(res2)) {
30381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30382 }
30383 if (!argp2) {
30384 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30385 }
30386 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 {
30394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30395 }
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30403 int argc;
30404 PyObject *argv[3];
30405
30406 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30407 --argc;
30408 if (argc == 2) {
30409 int _v = 0;
30410 {
30411 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30412 _v = SWIG_CheckState(res);
30413 }
30414 if (!_v) goto check_1;
30415 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30416 }
30417 check_1:
30418
30419 if (argc == 2) {
30420 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30421 }
30422
30423 fail:
30424 Py_INCREF(Py_NotImplemented);
30425 return Py_NotImplemented;
30426 }
30427
30428
30429 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30430 PyObject *resultobj = 0;
30431 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30432 wxDataFormat *arg2 = 0 ;
30433 bool result;
30434 void *argp1 = 0 ;
30435 int res1 = 0 ;
30436 void *argp2 = 0 ;
30437 int res2 = 0 ;
30438
30439 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30441 if (!SWIG_IsOK(res1)) {
30442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30443 }
30444 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30445 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30446 if (!SWIG_IsOK(res2)) {
30447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30448 }
30449 if (!argp2) {
30450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30451 }
30452 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30453 {
30454 PyThreadState* __tstate = wxPyBeginAllowThreads();
30455 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30456 wxPyEndAllowThreads(__tstate);
30457 if (PyErr_Occurred()) SWIG_fail;
30458 }
30459 {
30460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30461 }
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30469 int argc;
30470 PyObject *argv[3];
30471
30472 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30473 --argc;
30474 if (argc == 2) {
30475 int _v = 0;
30476 {
30477 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30478 _v = SWIG_CheckState(res);
30479 }
30480 if (!_v) goto check_1;
30481 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30482 }
30483 check_1:
30484
30485 if (argc == 2) {
30486 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30487 }
30488
30489 fail:
30490 Py_INCREF(Py_NotImplemented);
30491 return Py_NotImplemented;
30492 }
30493
30494
30495 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30496 PyObject *resultobj = 0;
30497 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30498 wxDataFormatId arg2 ;
30499 void *argp1 = 0 ;
30500 int res1 = 0 ;
30501 int val2 ;
30502 int ecode2 = 0 ;
30503 PyObject * obj0 = 0 ;
30504 PyObject * obj1 = 0 ;
30505 char * kwnames[] = {
30506 (char *) "self",(char *) "format", NULL
30507 };
30508
30509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30511 if (!SWIG_IsOK(res1)) {
30512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30513 }
30514 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30515 ecode2 = SWIG_AsVal_int(obj1, &val2);
30516 if (!SWIG_IsOK(ecode2)) {
30517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30518 }
30519 arg2 = static_cast< wxDataFormatId >(val2);
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 (arg1)->SetType(arg2);
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 resultobj = SWIG_Py_Void();
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30534 PyObject *resultobj = 0;
30535 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30536 wxDataFormatId result;
30537 void *argp1 = 0 ;
30538 int res1 = 0 ;
30539 PyObject *swig_obj[1] ;
30540
30541 if (!args) SWIG_fail;
30542 swig_obj[0] = args;
30543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30544 if (!SWIG_IsOK(res1)) {
30545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30546 }
30547 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30548 {
30549 PyThreadState* __tstate = wxPyBeginAllowThreads();
30550 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30551 wxPyEndAllowThreads(__tstate);
30552 if (PyErr_Occurred()) SWIG_fail;
30553 }
30554 resultobj = SWIG_From_int(static_cast< int >(result));
30555 return resultobj;
30556 fail:
30557 return NULL;
30558 }
30559
30560
30561 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30562 PyObject *resultobj = 0;
30563 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30564 wxString result;
30565 void *argp1 = 0 ;
30566 int res1 = 0 ;
30567 PyObject *swig_obj[1] ;
30568
30569 if (!args) SWIG_fail;
30570 swig_obj[0] = args;
30571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30572 if (!SWIG_IsOK(res1)) {
30573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30574 }
30575 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30576 {
30577 PyThreadState* __tstate = wxPyBeginAllowThreads();
30578 result = ((wxDataFormat const *)arg1)->GetId();
30579 wxPyEndAllowThreads(__tstate);
30580 if (PyErr_Occurred()) SWIG_fail;
30581 }
30582 {
30583 #if wxUSE_UNICODE
30584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30585 #else
30586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30587 #endif
30588 }
30589 return resultobj;
30590 fail:
30591 return NULL;
30592 }
30593
30594
30595 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30596 PyObject *resultobj = 0;
30597 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30598 wxString *arg2 = 0 ;
30599 void *argp1 = 0 ;
30600 int res1 = 0 ;
30601 bool temp2 = false ;
30602 PyObject * obj0 = 0 ;
30603 PyObject * obj1 = 0 ;
30604 char * kwnames[] = {
30605 (char *) "self",(char *) "format", NULL
30606 };
30607
30608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30610 if (!SWIG_IsOK(res1)) {
30611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30612 }
30613 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30614 {
30615 arg2 = wxString_in_helper(obj1);
30616 if (arg2 == NULL) SWIG_fail;
30617 temp2 = true;
30618 }
30619 {
30620 PyThreadState* __tstate = wxPyBeginAllowThreads();
30621 (arg1)->SetId((wxString const &)*arg2);
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 resultobj = SWIG_Py_Void();
30626 {
30627 if (temp2)
30628 delete arg2;
30629 }
30630 return resultobj;
30631 fail:
30632 {
30633 if (temp2)
30634 delete arg2;
30635 }
30636 return NULL;
30637 }
30638
30639
30640 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30641 PyObject *obj;
30642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30643 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30644 return SWIG_Py_Void();
30645 }
30646
30647 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30648 return SWIG_Python_InitShadowInstance(args);
30649 }
30650
30651 SWIGINTERN int FormatInvalid_set(PyObject *) {
30652 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30653 return 1;
30654 }
30655
30656
30657 SWIGINTERN PyObject *FormatInvalid_get(void) {
30658 PyObject *pyobj = 0;
30659
30660 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30661 return pyobj;
30662 }
30663
30664
30665 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30666 PyObject *resultobj = 0;
30667 wxDataObject *arg1 = (wxDataObject *) 0 ;
30668 void *argp1 = 0 ;
30669 int res1 = 0 ;
30670 PyObject *swig_obj[1] ;
30671
30672 if (!args) SWIG_fail;
30673 swig_obj[0] = args;
30674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30675 if (!SWIG_IsOK(res1)) {
30676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30677 }
30678 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30679 {
30680 PyThreadState* __tstate = wxPyBeginAllowThreads();
30681 delete arg1;
30682
30683 wxPyEndAllowThreads(__tstate);
30684 if (PyErr_Occurred()) SWIG_fail;
30685 }
30686 resultobj = SWIG_Py_Void();
30687 return resultobj;
30688 fail:
30689 return NULL;
30690 }
30691
30692
30693 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30694 PyObject *resultobj = 0;
30695 wxDataObject *arg1 = (wxDataObject *) 0 ;
30696 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30697 SwigValueWrapper<wxDataFormat > result;
30698 void *argp1 = 0 ;
30699 int res1 = 0 ;
30700 int val2 ;
30701 int ecode2 = 0 ;
30702 PyObject * obj0 = 0 ;
30703 PyObject * obj1 = 0 ;
30704 char * kwnames[] = {
30705 (char *) "self",(char *) "dir", NULL
30706 };
30707
30708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30710 if (!SWIG_IsOK(res1)) {
30711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30712 }
30713 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30714 if (obj1) {
30715 ecode2 = SWIG_AsVal_int(obj1, &val2);
30716 if (!SWIG_IsOK(ecode2)) {
30717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30718 }
30719 arg2 = static_cast< wxDataObject::Direction >(val2);
30720 }
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30735 PyObject *resultobj = 0;
30736 wxDataObject *arg1 = (wxDataObject *) 0 ;
30737 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30738 size_t result;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 int val2 ;
30742 int ecode2 = 0 ;
30743 PyObject * obj0 = 0 ;
30744 PyObject * obj1 = 0 ;
30745 char * kwnames[] = {
30746 (char *) "self",(char *) "dir", NULL
30747 };
30748
30749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30751 if (!SWIG_IsOK(res1)) {
30752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30753 }
30754 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30755 if (obj1) {
30756 ecode2 = SWIG_AsVal_int(obj1, &val2);
30757 if (!SWIG_IsOK(ecode2)) {
30758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30759 }
30760 arg2 = static_cast< wxDataObject::Direction >(val2);
30761 }
30762 {
30763 PyThreadState* __tstate = wxPyBeginAllowThreads();
30764 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30765 wxPyEndAllowThreads(__tstate);
30766 if (PyErr_Occurred()) SWIG_fail;
30767 }
30768 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30769 return resultobj;
30770 fail:
30771 return NULL;
30772 }
30773
30774
30775 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30776 PyObject *resultobj = 0;
30777 wxDataObject *arg1 = (wxDataObject *) 0 ;
30778 wxDataFormat *arg2 = 0 ;
30779 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30780 bool result;
30781 void *argp1 = 0 ;
30782 int res1 = 0 ;
30783 void *argp2 = 0 ;
30784 int res2 = 0 ;
30785 int val3 ;
30786 int ecode3 = 0 ;
30787 PyObject * obj0 = 0 ;
30788 PyObject * obj1 = 0 ;
30789 PyObject * obj2 = 0 ;
30790 char * kwnames[] = {
30791 (char *) "self",(char *) "format",(char *) "dir", NULL
30792 };
30793
30794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30796 if (!SWIG_IsOK(res1)) {
30797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30798 }
30799 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30801 if (!SWIG_IsOK(res2)) {
30802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30803 }
30804 if (!argp2) {
30805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30806 }
30807 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30808 if (obj2) {
30809 ecode3 = SWIG_AsVal_int(obj2, &val3);
30810 if (!SWIG_IsOK(ecode3)) {
30811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30812 }
30813 arg3 = static_cast< wxDataObject::Direction >(val3);
30814 }
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 {
30822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30823 }
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj = 0;
30832 wxDataObject *arg1 = (wxDataObject *) 0 ;
30833 wxDataFormat *arg2 = 0 ;
30834 size_t result;
30835 void *argp1 = 0 ;
30836 int res1 = 0 ;
30837 void *argp2 = 0 ;
30838 int res2 = 0 ;
30839 PyObject * obj0 = 0 ;
30840 PyObject * obj1 = 0 ;
30841 char * kwnames[] = {
30842 (char *) "self",(char *) "format", NULL
30843 };
30844
30845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30847 if (!SWIG_IsOK(res1)) {
30848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30849 }
30850 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30851 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30852 if (!SWIG_IsOK(res2)) {
30853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30854 }
30855 if (!argp2) {
30856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30857 }
30858 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30859 {
30860 PyThreadState* __tstate = wxPyBeginAllowThreads();
30861 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj = 0;
30874 wxDataObject *arg1 = (wxDataObject *) 0 ;
30875 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30876 PyObject *result = 0 ;
30877 void *argp1 = 0 ;
30878 int res1 = 0 ;
30879 int val2 ;
30880 int ecode2 = 0 ;
30881 PyObject * obj0 = 0 ;
30882 PyObject * obj1 = 0 ;
30883 char * kwnames[] = {
30884 (char *) "self",(char *) "dir", NULL
30885 };
30886
30887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30889 if (!SWIG_IsOK(res1)) {
30890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30891 }
30892 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30893 if (obj1) {
30894 ecode2 = SWIG_AsVal_int(obj1, &val2);
30895 if (!SWIG_IsOK(ecode2)) {
30896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30897 }
30898 arg2 = static_cast< wxDataObject::Direction >(val2);
30899 }
30900 {
30901 PyThreadState* __tstate = wxPyBeginAllowThreads();
30902 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30903 wxPyEndAllowThreads(__tstate);
30904 if (PyErr_Occurred()) SWIG_fail;
30905 }
30906 resultobj = result;
30907 return resultobj;
30908 fail:
30909 return NULL;
30910 }
30911
30912
30913 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30914 PyObject *resultobj = 0;
30915 wxDataObject *arg1 = (wxDataObject *) 0 ;
30916 wxDataFormat *arg2 = 0 ;
30917 PyObject *result = 0 ;
30918 void *argp1 = 0 ;
30919 int res1 = 0 ;
30920 void *argp2 = 0 ;
30921 int res2 = 0 ;
30922 PyObject * obj0 = 0 ;
30923 PyObject * obj1 = 0 ;
30924 char * kwnames[] = {
30925 (char *) "self",(char *) "format", NULL
30926 };
30927
30928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30930 if (!SWIG_IsOK(res1)) {
30931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30932 }
30933 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30935 if (!SWIG_IsOK(res2)) {
30936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30937 }
30938 if (!argp2) {
30939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30940 }
30941 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30942 {
30943 PyThreadState* __tstate = wxPyBeginAllowThreads();
30944 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30945 wxPyEndAllowThreads(__tstate);
30946 if (PyErr_Occurred()) SWIG_fail;
30947 }
30948 resultobj = result;
30949 return resultobj;
30950 fail:
30951 return NULL;
30952 }
30953
30954
30955 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30956 PyObject *resultobj = 0;
30957 wxDataObject *arg1 = (wxDataObject *) 0 ;
30958 wxDataFormat *arg2 = 0 ;
30959 PyObject *arg3 = (PyObject *) 0 ;
30960 bool result;
30961 void *argp1 = 0 ;
30962 int res1 = 0 ;
30963 void *argp2 = 0 ;
30964 int res2 = 0 ;
30965 PyObject * obj0 = 0 ;
30966 PyObject * obj1 = 0 ;
30967 PyObject * obj2 = 0 ;
30968 char * kwnames[] = {
30969 (char *) "self",(char *) "format",(char *) "data", NULL
30970 };
30971
30972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30974 if (!SWIG_IsOK(res1)) {
30975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30976 }
30977 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30979 if (!SWIG_IsOK(res2)) {
30980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30981 }
30982 if (!argp2) {
30983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30984 }
30985 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30986 arg3 = obj2;
30987 {
30988 PyThreadState* __tstate = wxPyBeginAllowThreads();
30989 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
30990 wxPyEndAllowThreads(__tstate);
30991 if (PyErr_Occurred()) SWIG_fail;
30992 }
30993 {
30994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30995 }
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31003 PyObject *obj;
31004 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31005 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31006 return SWIG_Py_Void();
31007 }
31008
31009 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31010 PyObject *resultobj = 0;
31011 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31012 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31013 wxDataObjectSimple *result = 0 ;
31014 void *argp1 = 0 ;
31015 int res1 = 0 ;
31016 PyObject * obj0 = 0 ;
31017 char * kwnames[] = {
31018 (char *) "format", NULL
31019 };
31020
31021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31022 if (obj0) {
31023 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31024 if (!SWIG_IsOK(res1)) {
31025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31026 }
31027 if (!argp1) {
31028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31029 }
31030 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31031 }
31032 {
31033 PyThreadState* __tstate = wxPyBeginAllowThreads();
31034 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31035 wxPyEndAllowThreads(__tstate);
31036 if (PyErr_Occurred()) SWIG_fail;
31037 }
31038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31039 return resultobj;
31040 fail:
31041 return NULL;
31042 }
31043
31044
31045 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31046 PyObject *resultobj = 0;
31047 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31048 wxDataFormat *result = 0 ;
31049 void *argp1 = 0 ;
31050 int res1 = 0 ;
31051 PyObject *swig_obj[1] ;
31052
31053 if (!args) SWIG_fail;
31054 swig_obj[0] = args;
31055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31056 if (!SWIG_IsOK(res1)) {
31057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31058 }
31059 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 {
31063 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31064 result = (wxDataFormat *) &_result_ref;
31065 }
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31070 return resultobj;
31071 fail:
31072 return NULL;
31073 }
31074
31075
31076 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31077 PyObject *resultobj = 0;
31078 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31079 wxDataFormat *arg2 = 0 ;
31080 void *argp1 = 0 ;
31081 int res1 = 0 ;
31082 void *argp2 = 0 ;
31083 int res2 = 0 ;
31084 PyObject * obj0 = 0 ;
31085 PyObject * obj1 = 0 ;
31086 char * kwnames[] = {
31087 (char *) "self",(char *) "format", NULL
31088 };
31089
31090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31092 if (!SWIG_IsOK(res1)) {
31093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31094 }
31095 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31097 if (!SWIG_IsOK(res2)) {
31098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31099 }
31100 if (!argp2) {
31101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31102 }
31103 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 resultobj = SWIG_Py_Void();
31111 return resultobj;
31112 fail:
31113 return NULL;
31114 }
31115
31116
31117 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31118 PyObject *resultobj = 0;
31119 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31120 size_t result;
31121 void *argp1 = 0 ;
31122 int res1 = 0 ;
31123 PyObject *swig_obj[1] ;
31124
31125 if (!args) SWIG_fail;
31126 swig_obj[0] = args;
31127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31128 if (!SWIG_IsOK(res1)) {
31129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31130 }
31131 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31135 wxPyEndAllowThreads(__tstate);
31136 if (PyErr_Occurred()) SWIG_fail;
31137 }
31138 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31139 return resultobj;
31140 fail:
31141 return NULL;
31142 }
31143
31144
31145 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31146 PyObject *resultobj = 0;
31147 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31148 PyObject *result = 0 ;
31149 void *argp1 = 0 ;
31150 int res1 = 0 ;
31151 PyObject *swig_obj[1] ;
31152
31153 if (!args) SWIG_fail;
31154 swig_obj[0] = args;
31155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31156 if (!SWIG_IsOK(res1)) {
31157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31158 }
31159 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31160 {
31161 PyThreadState* __tstate = wxPyBeginAllowThreads();
31162 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31163 wxPyEndAllowThreads(__tstate);
31164 if (PyErr_Occurred()) SWIG_fail;
31165 }
31166 resultobj = result;
31167 return resultobj;
31168 fail:
31169 return NULL;
31170 }
31171
31172
31173 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31174 PyObject *resultobj = 0;
31175 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31176 PyObject *arg2 = (PyObject *) 0 ;
31177 bool result;
31178 void *argp1 = 0 ;
31179 int res1 = 0 ;
31180 PyObject * obj0 = 0 ;
31181 PyObject * obj1 = 0 ;
31182 char * kwnames[] = {
31183 (char *) "self",(char *) "data", NULL
31184 };
31185
31186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31188 if (!SWIG_IsOK(res1)) {
31189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31190 }
31191 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31192 arg2 = obj1;
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 {
31200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31201 }
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31209 PyObject *obj;
31210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31211 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31212 return SWIG_Py_Void();
31213 }
31214
31215 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31216 return SWIG_Python_InitShadowInstance(args);
31217 }
31218
31219 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj = 0;
31221 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31222 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31223 wxPyDataObjectSimple *result = 0 ;
31224 void *argp1 = 0 ;
31225 int res1 = 0 ;
31226 PyObject * obj0 = 0 ;
31227 char * kwnames[] = {
31228 (char *) "format", NULL
31229 };
31230
31231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31232 if (obj0) {
31233 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31234 if (!SWIG_IsOK(res1)) {
31235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31236 }
31237 if (!argp1) {
31238 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31239 }
31240 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31241 }
31242 {
31243 PyThreadState* __tstate = wxPyBeginAllowThreads();
31244 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31245 wxPyEndAllowThreads(__tstate);
31246 if (PyErr_Occurred()) SWIG_fail;
31247 }
31248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31249 return resultobj;
31250 fail:
31251 return NULL;
31252 }
31253
31254
31255 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31256 PyObject *resultobj = 0;
31257 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31258 PyObject *arg2 = (PyObject *) 0 ;
31259 PyObject *arg3 = (PyObject *) 0 ;
31260 void *argp1 = 0 ;
31261 int res1 = 0 ;
31262 PyObject * obj0 = 0 ;
31263 PyObject * obj1 = 0 ;
31264 PyObject * obj2 = 0 ;
31265 char * kwnames[] = {
31266 (char *) "self",(char *) "self",(char *) "_class", NULL
31267 };
31268
31269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31271 if (!SWIG_IsOK(res1)) {
31272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31273 }
31274 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31275 arg2 = obj1;
31276 arg3 = obj2;
31277 {
31278 PyThreadState* __tstate = wxPyBeginAllowThreads();
31279 (arg1)->_setCallbackInfo(arg2,arg3);
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_Py_Void();
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31291 PyObject *obj;
31292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31293 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31294 return SWIG_Py_Void();
31295 }
31296
31297 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31298 return SWIG_Python_InitShadowInstance(args);
31299 }
31300
31301 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31302 PyObject *resultobj = 0;
31303 wxDataObjectComposite *result = 0 ;
31304
31305 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31306 {
31307 PyThreadState* __tstate = wxPyBeginAllowThreads();
31308 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31309 wxPyEndAllowThreads(__tstate);
31310 if (PyErr_Occurred()) SWIG_fail;
31311 }
31312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31313 return resultobj;
31314 fail:
31315 return NULL;
31316 }
31317
31318
31319 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31320 PyObject *resultobj = 0;
31321 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31322 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31323 bool arg3 = (bool) false ;
31324 void *argp1 = 0 ;
31325 int res1 = 0 ;
31326 int res2 = 0 ;
31327 bool val3 ;
31328 int ecode3 = 0 ;
31329 PyObject * obj0 = 0 ;
31330 PyObject * obj1 = 0 ;
31331 PyObject * obj2 = 0 ;
31332 char * kwnames[] = {
31333 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31334 };
31335
31336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31338 if (!SWIG_IsOK(res1)) {
31339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31340 }
31341 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31342 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31343 if (!SWIG_IsOK(res2)) {
31344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31345 }
31346 if (obj2) {
31347 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31348 if (!SWIG_IsOK(ecode3)) {
31349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31350 }
31351 arg3 = static_cast< bool >(val3);
31352 }
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 (arg1)->Add(arg2,arg3);
31356 wxPyEndAllowThreads(__tstate);
31357 if (PyErr_Occurred()) SWIG_fail;
31358 }
31359 resultobj = SWIG_Py_Void();
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31367 PyObject *resultobj = 0;
31368 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31369 SwigValueWrapper<wxDataFormat > result;
31370 void *argp1 = 0 ;
31371 int res1 = 0 ;
31372 PyObject *swig_obj[1] ;
31373
31374 if (!args) SWIG_fail;
31375 swig_obj[0] = args;
31376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31377 if (!SWIG_IsOK(res1)) {
31378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31379 }
31380 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31381 {
31382 PyThreadState* __tstate = wxPyBeginAllowThreads();
31383 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31384 wxPyEndAllowThreads(__tstate);
31385 if (PyErr_Occurred()) SWIG_fail;
31386 }
31387 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31395 PyObject *obj;
31396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31397 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31398 return SWIG_Py_Void();
31399 }
31400
31401 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31402 return SWIG_Python_InitShadowInstance(args);
31403 }
31404
31405 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31406 PyObject *resultobj = 0;
31407 wxString const &arg1_defvalue = wxPyEmptyString ;
31408 wxString *arg1 = (wxString *) &arg1_defvalue ;
31409 wxTextDataObject *result = 0 ;
31410 bool temp1 = false ;
31411 PyObject * obj0 = 0 ;
31412 char * kwnames[] = {
31413 (char *) "text", NULL
31414 };
31415
31416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31417 if (obj0) {
31418 {
31419 arg1 = wxString_in_helper(obj0);
31420 if (arg1 == NULL) SWIG_fail;
31421 temp1 = true;
31422 }
31423 }
31424 {
31425 PyThreadState* __tstate = wxPyBeginAllowThreads();
31426 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31427 wxPyEndAllowThreads(__tstate);
31428 if (PyErr_Occurred()) SWIG_fail;
31429 }
31430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31431 {
31432 if (temp1)
31433 delete arg1;
31434 }
31435 return resultobj;
31436 fail:
31437 {
31438 if (temp1)
31439 delete arg1;
31440 }
31441 return NULL;
31442 }
31443
31444
31445 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31446 PyObject *resultobj = 0;
31447 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31448 size_t result;
31449 void *argp1 = 0 ;
31450 int res1 = 0 ;
31451 PyObject *swig_obj[1] ;
31452
31453 if (!args) SWIG_fail;
31454 swig_obj[0] = args;
31455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31456 if (!SWIG_IsOK(res1)) {
31457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31458 }
31459 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 result = (size_t)(arg1)->GetTextLength();
31463 wxPyEndAllowThreads(__tstate);
31464 if (PyErr_Occurred()) SWIG_fail;
31465 }
31466 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31474 PyObject *resultobj = 0;
31475 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31476 wxString result;
31477 void *argp1 = 0 ;
31478 int res1 = 0 ;
31479 PyObject *swig_obj[1] ;
31480
31481 if (!args) SWIG_fail;
31482 swig_obj[0] = args;
31483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31484 if (!SWIG_IsOK(res1)) {
31485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31486 }
31487 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31488 {
31489 PyThreadState* __tstate = wxPyBeginAllowThreads();
31490 result = (arg1)->GetText();
31491 wxPyEndAllowThreads(__tstate);
31492 if (PyErr_Occurred()) SWIG_fail;
31493 }
31494 {
31495 #if wxUSE_UNICODE
31496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31497 #else
31498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31499 #endif
31500 }
31501 return resultobj;
31502 fail:
31503 return NULL;
31504 }
31505
31506
31507 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31508 PyObject *resultobj = 0;
31509 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31510 wxString *arg2 = 0 ;
31511 void *argp1 = 0 ;
31512 int res1 = 0 ;
31513 bool temp2 = false ;
31514 PyObject * obj0 = 0 ;
31515 PyObject * obj1 = 0 ;
31516 char * kwnames[] = {
31517 (char *) "self",(char *) "text", NULL
31518 };
31519
31520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31522 if (!SWIG_IsOK(res1)) {
31523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31524 }
31525 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31526 {
31527 arg2 = wxString_in_helper(obj1);
31528 if (arg2 == NULL) SWIG_fail;
31529 temp2 = true;
31530 }
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 (arg1)->SetText((wxString const &)*arg2);
31534 wxPyEndAllowThreads(__tstate);
31535 if (PyErr_Occurred()) SWIG_fail;
31536 }
31537 resultobj = SWIG_Py_Void();
31538 {
31539 if (temp2)
31540 delete arg2;
31541 }
31542 return resultobj;
31543 fail:
31544 {
31545 if (temp2)
31546 delete arg2;
31547 }
31548 return NULL;
31549 }
31550
31551
31552 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31553 PyObject *obj;
31554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31555 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31556 return SWIG_Py_Void();
31557 }
31558
31559 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 return SWIG_Python_InitShadowInstance(args);
31561 }
31562
31563 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31564 PyObject *resultobj = 0;
31565 wxString const &arg1_defvalue = wxPyEmptyString ;
31566 wxString *arg1 = (wxString *) &arg1_defvalue ;
31567 wxPyTextDataObject *result = 0 ;
31568 bool temp1 = false ;
31569 PyObject * obj0 = 0 ;
31570 char * kwnames[] = {
31571 (char *) "text", NULL
31572 };
31573
31574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31575 if (obj0) {
31576 {
31577 arg1 = wxString_in_helper(obj0);
31578 if (arg1 == NULL) SWIG_fail;
31579 temp1 = true;
31580 }
31581 }
31582 {
31583 PyThreadState* __tstate = wxPyBeginAllowThreads();
31584 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31585 wxPyEndAllowThreads(__tstate);
31586 if (PyErr_Occurred()) SWIG_fail;
31587 }
31588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31589 {
31590 if (temp1)
31591 delete arg1;
31592 }
31593 return resultobj;
31594 fail:
31595 {
31596 if (temp1)
31597 delete arg1;
31598 }
31599 return NULL;
31600 }
31601
31602
31603 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31604 PyObject *resultobj = 0;
31605 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31606 PyObject *arg2 = (PyObject *) 0 ;
31607 PyObject *arg3 = (PyObject *) 0 ;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 PyObject * obj0 = 0 ;
31611 PyObject * obj1 = 0 ;
31612 PyObject * obj2 = 0 ;
31613 char * kwnames[] = {
31614 (char *) "self",(char *) "self",(char *) "_class", NULL
31615 };
31616
31617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31619 if (!SWIG_IsOK(res1)) {
31620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31621 }
31622 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31623 arg2 = obj1;
31624 arg3 = obj2;
31625 {
31626 PyThreadState* __tstate = wxPyBeginAllowThreads();
31627 (arg1)->_setCallbackInfo(arg2,arg3);
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 resultobj = SWIG_Py_Void();
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31639 PyObject *obj;
31640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31641 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31642 return SWIG_Py_Void();
31643 }
31644
31645 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31646 return SWIG_Python_InitShadowInstance(args);
31647 }
31648
31649 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31650 PyObject *resultobj = 0;
31651 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31652 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31653 wxBitmapDataObject *result = 0 ;
31654 void *argp1 = 0 ;
31655 int res1 = 0 ;
31656 PyObject * obj0 = 0 ;
31657 char * kwnames[] = {
31658 (char *) "bitmap", NULL
31659 };
31660
31661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31662 if (obj0) {
31663 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31664 if (!SWIG_IsOK(res1)) {
31665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31666 }
31667 if (!argp1) {
31668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31669 }
31670 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31671 }
31672 {
31673 PyThreadState* __tstate = wxPyBeginAllowThreads();
31674 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31675 wxPyEndAllowThreads(__tstate);
31676 if (PyErr_Occurred()) SWIG_fail;
31677 }
31678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31679 return resultobj;
31680 fail:
31681 return NULL;
31682 }
31683
31684
31685 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31686 PyObject *resultobj = 0;
31687 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31688 wxBitmap result;
31689 void *argp1 = 0 ;
31690 int res1 = 0 ;
31691 PyObject *swig_obj[1] ;
31692
31693 if (!args) SWIG_fail;
31694 swig_obj[0] = args;
31695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31696 if (!SWIG_IsOK(res1)) {
31697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31698 }
31699 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31700 {
31701 PyThreadState* __tstate = wxPyBeginAllowThreads();
31702 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31703 wxPyEndAllowThreads(__tstate);
31704 if (PyErr_Occurred()) SWIG_fail;
31705 }
31706 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31707 return resultobj;
31708 fail:
31709 return NULL;
31710 }
31711
31712
31713 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31714 PyObject *resultobj = 0;
31715 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31716 wxBitmap *arg2 = 0 ;
31717 void *argp1 = 0 ;
31718 int res1 = 0 ;
31719 void *argp2 = 0 ;
31720 int res2 = 0 ;
31721 PyObject * obj0 = 0 ;
31722 PyObject * obj1 = 0 ;
31723 char * kwnames[] = {
31724 (char *) "self",(char *) "bitmap", NULL
31725 };
31726
31727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31729 if (!SWIG_IsOK(res1)) {
31730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31731 }
31732 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31733 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31734 if (!SWIG_IsOK(res2)) {
31735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31736 }
31737 if (!argp2) {
31738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31739 }
31740 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31741 {
31742 PyThreadState* __tstate = wxPyBeginAllowThreads();
31743 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31744 wxPyEndAllowThreads(__tstate);
31745 if (PyErr_Occurred()) SWIG_fail;
31746 }
31747 resultobj = SWIG_Py_Void();
31748 return resultobj;
31749 fail:
31750 return NULL;
31751 }
31752
31753
31754 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31755 PyObject *obj;
31756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31757 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31758 return SWIG_Py_Void();
31759 }
31760
31761 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 return SWIG_Python_InitShadowInstance(args);
31763 }
31764
31765 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31766 PyObject *resultobj = 0;
31767 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31768 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31769 wxPyBitmapDataObject *result = 0 ;
31770 void *argp1 = 0 ;
31771 int res1 = 0 ;
31772 PyObject * obj0 = 0 ;
31773 char * kwnames[] = {
31774 (char *) "bitmap", NULL
31775 };
31776
31777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31778 if (obj0) {
31779 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31780 if (!SWIG_IsOK(res1)) {
31781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31782 }
31783 if (!argp1) {
31784 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31785 }
31786 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31787 }
31788 {
31789 PyThreadState* __tstate = wxPyBeginAllowThreads();
31790 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31791 wxPyEndAllowThreads(__tstate);
31792 if (PyErr_Occurred()) SWIG_fail;
31793 }
31794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31795 return resultobj;
31796 fail:
31797 return NULL;
31798 }
31799
31800
31801 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31802 PyObject *resultobj = 0;
31803 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31804 PyObject *arg2 = (PyObject *) 0 ;
31805 PyObject *arg3 = (PyObject *) 0 ;
31806 void *argp1 = 0 ;
31807 int res1 = 0 ;
31808 PyObject * obj0 = 0 ;
31809 PyObject * obj1 = 0 ;
31810 PyObject * obj2 = 0 ;
31811 char * kwnames[] = {
31812 (char *) "self",(char *) "self",(char *) "_class", NULL
31813 };
31814
31815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31817 if (!SWIG_IsOK(res1)) {
31818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31819 }
31820 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31821 arg2 = obj1;
31822 arg3 = obj2;
31823 {
31824 PyThreadState* __tstate = wxPyBeginAllowThreads();
31825 (arg1)->_setCallbackInfo(arg2,arg3);
31826 wxPyEndAllowThreads(__tstate);
31827 if (PyErr_Occurred()) SWIG_fail;
31828 }
31829 resultobj = SWIG_Py_Void();
31830 return resultobj;
31831 fail:
31832 return NULL;
31833 }
31834
31835
31836 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31837 PyObject *obj;
31838 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31839 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31840 return SWIG_Py_Void();
31841 }
31842
31843 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31844 return SWIG_Python_InitShadowInstance(args);
31845 }
31846
31847 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31848 PyObject *resultobj = 0;
31849 wxFileDataObject *result = 0 ;
31850
31851 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 result = (wxFileDataObject *)new wxFileDataObject();
31855 wxPyEndAllowThreads(__tstate);
31856 if (PyErr_Occurred()) SWIG_fail;
31857 }
31858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31859 return resultobj;
31860 fail:
31861 return NULL;
31862 }
31863
31864
31865 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31866 PyObject *resultobj = 0;
31867 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31868 wxArrayString *result = 0 ;
31869 void *argp1 = 0 ;
31870 int res1 = 0 ;
31871 PyObject *swig_obj[1] ;
31872
31873 if (!args) SWIG_fail;
31874 swig_obj[0] = args;
31875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31876 if (!SWIG_IsOK(res1)) {
31877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31878 }
31879 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 {
31883 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31884 result = (wxArrayString *) &_result_ref;
31885 }
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 {
31890 resultobj = wxArrayString2PyList_helper(*result);
31891 }
31892 return resultobj;
31893 fail:
31894 return NULL;
31895 }
31896
31897
31898 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31899 PyObject *resultobj = 0;
31900 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31901 wxString *arg2 = 0 ;
31902 void *argp1 = 0 ;
31903 int res1 = 0 ;
31904 bool temp2 = false ;
31905 PyObject * obj0 = 0 ;
31906 PyObject * obj1 = 0 ;
31907 char * kwnames[] = {
31908 (char *) "self",(char *) "filename", NULL
31909 };
31910
31911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31913 if (!SWIG_IsOK(res1)) {
31914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31915 }
31916 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31917 {
31918 arg2 = wxString_in_helper(obj1);
31919 if (arg2 == NULL) SWIG_fail;
31920 temp2 = true;
31921 }
31922 {
31923 PyThreadState* __tstate = wxPyBeginAllowThreads();
31924 (arg1)->AddFile((wxString const &)*arg2);
31925 wxPyEndAllowThreads(__tstate);
31926 if (PyErr_Occurred()) SWIG_fail;
31927 }
31928 resultobj = SWIG_Py_Void();
31929 {
31930 if (temp2)
31931 delete arg2;
31932 }
31933 return resultobj;
31934 fail:
31935 {
31936 if (temp2)
31937 delete arg2;
31938 }
31939 return NULL;
31940 }
31941
31942
31943 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31944 PyObject *obj;
31945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31946 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31947 return SWIG_Py_Void();
31948 }
31949
31950 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31951 return SWIG_Python_InitShadowInstance(args);
31952 }
31953
31954 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31955 PyObject *resultobj = 0;
31956 wxDataFormat *arg1 = 0 ;
31957 wxCustomDataObject *result = 0 ;
31958 void *argp1 = 0 ;
31959 int res1 = 0 ;
31960
31961 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31963 if (!SWIG_IsOK(res1)) {
31964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31965 }
31966 if (!argp1) {
31967 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31968 }
31969 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31977 return resultobj;
31978 fail:
31979 return NULL;
31980 }
31981
31982
31983 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31984 PyObject *resultobj = 0;
31985 wxString *arg1 = 0 ;
31986 wxCustomDataObject *result = 0 ;
31987 bool temp1 = false ;
31988
31989 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31990 {
31991 arg1 = wxString_in_helper(swig_obj[0]);
31992 if (arg1 == NULL) SWIG_fail;
31993 temp1 = true;
31994 }
31995 {
31996 PyThreadState* __tstate = wxPyBeginAllowThreads();
31997 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32002 {
32003 if (temp1)
32004 delete arg1;
32005 }
32006 return resultobj;
32007 fail:
32008 {
32009 if (temp1)
32010 delete arg1;
32011 }
32012 return NULL;
32013 }
32014
32015
32016 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32017 PyObject *resultobj = 0;
32018 wxCustomDataObject *result = 0 ;
32019
32020 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32021 {
32022 PyThreadState* __tstate = wxPyBeginAllowThreads();
32023 result = (wxCustomDataObject *)new wxCustomDataObject();
32024 wxPyEndAllowThreads(__tstate);
32025 if (PyErr_Occurred()) SWIG_fail;
32026 }
32027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32028 return resultobj;
32029 fail:
32030 return NULL;
32031 }
32032
32033
32034 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32035 int argc;
32036 PyObject *argv[2];
32037
32038 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32039 --argc;
32040 if (argc == 0) {
32041 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32042 }
32043 if (argc == 1) {
32044 int _v = 0;
32045 {
32046 {
32047 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32048 }
32049 }
32050 if (!_v) goto check_2;
32051 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32052 }
32053 check_2:
32054
32055 if (argc == 1) {
32056 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32057 }
32058
32059 fail:
32060 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32061 return NULL;
32062 }
32063
32064
32065 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32066 PyObject *resultobj = 0;
32067 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32068 PyObject *arg2 = (PyObject *) 0 ;
32069 bool result;
32070 void *argp1 = 0 ;
32071 int res1 = 0 ;
32072 PyObject * obj0 = 0 ;
32073 PyObject * obj1 = 0 ;
32074 char * kwnames[] = {
32075 (char *) "self",(char *) "data", NULL
32076 };
32077
32078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32080 if (!SWIG_IsOK(res1)) {
32081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32082 }
32083 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32084 arg2 = obj1;
32085 {
32086 PyThreadState* __tstate = wxPyBeginAllowThreads();
32087 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32088 wxPyEndAllowThreads(__tstate);
32089 if (PyErr_Occurred()) SWIG_fail;
32090 }
32091 {
32092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32093 }
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32101 PyObject *resultobj = 0;
32102 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32103 size_t result;
32104 void *argp1 = 0 ;
32105 int res1 = 0 ;
32106 PyObject *swig_obj[1] ;
32107
32108 if (!args) SWIG_fail;
32109 swig_obj[0] = args;
32110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32111 if (!SWIG_IsOK(res1)) {
32112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32113 }
32114 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = (size_t)(arg1)->GetSize();
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32129 PyObject *resultobj = 0;
32130 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32131 PyObject *result = 0 ;
32132 void *argp1 = 0 ;
32133 int res1 = 0 ;
32134 PyObject *swig_obj[1] ;
32135
32136 if (!args) SWIG_fail;
32137 swig_obj[0] = args;
32138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32139 if (!SWIG_IsOK(res1)) {
32140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32141 }
32142 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32143 {
32144 PyThreadState* __tstate = wxPyBeginAllowThreads();
32145 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32146 wxPyEndAllowThreads(__tstate);
32147 if (PyErr_Occurred()) SWIG_fail;
32148 }
32149 resultobj = result;
32150 return resultobj;
32151 fail:
32152 return NULL;
32153 }
32154
32155
32156 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32157 PyObject *obj;
32158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32159 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32160 return SWIG_Py_Void();
32161 }
32162
32163 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32164 return SWIG_Python_InitShadowInstance(args);
32165 }
32166
32167 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32168 PyObject *resultobj = 0;
32169 wxURLDataObject *result = 0 ;
32170
32171 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32172 {
32173 PyThreadState* __tstate = wxPyBeginAllowThreads();
32174 result = (wxURLDataObject *)new wxURLDataObject();
32175 wxPyEndAllowThreads(__tstate);
32176 if (PyErr_Occurred()) SWIG_fail;
32177 }
32178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32179 return resultobj;
32180 fail:
32181 return NULL;
32182 }
32183
32184
32185 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32186 PyObject *resultobj = 0;
32187 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32188 wxString result;
32189 void *argp1 = 0 ;
32190 int res1 = 0 ;
32191 PyObject *swig_obj[1] ;
32192
32193 if (!args) SWIG_fail;
32194 swig_obj[0] = args;
32195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32196 if (!SWIG_IsOK(res1)) {
32197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32198 }
32199 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32200 {
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 result = (arg1)->GetURL();
32203 wxPyEndAllowThreads(__tstate);
32204 if (PyErr_Occurred()) SWIG_fail;
32205 }
32206 {
32207 #if wxUSE_UNICODE
32208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32209 #else
32210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32211 #endif
32212 }
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32220 PyObject *resultobj = 0;
32221 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32222 wxString *arg2 = 0 ;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 bool temp2 = false ;
32226 PyObject * obj0 = 0 ;
32227 PyObject * obj1 = 0 ;
32228 char * kwnames[] = {
32229 (char *) "self",(char *) "url", NULL
32230 };
32231
32232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32234 if (!SWIG_IsOK(res1)) {
32235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32236 }
32237 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32238 {
32239 arg2 = wxString_in_helper(obj1);
32240 if (arg2 == NULL) SWIG_fail;
32241 temp2 = true;
32242 }
32243 {
32244 PyThreadState* __tstate = wxPyBeginAllowThreads();
32245 (arg1)->SetURL((wxString const &)*arg2);
32246 wxPyEndAllowThreads(__tstate);
32247 if (PyErr_Occurred()) SWIG_fail;
32248 }
32249 resultobj = SWIG_Py_Void();
32250 {
32251 if (temp2)
32252 delete arg2;
32253 }
32254 return resultobj;
32255 fail:
32256 {
32257 if (temp2)
32258 delete arg2;
32259 }
32260 return NULL;
32261 }
32262
32263
32264 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32265 PyObject *obj;
32266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32267 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32268 return SWIG_Py_Void();
32269 }
32270
32271 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32272 return SWIG_Python_InitShadowInstance(args);
32273 }
32274
32275 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32276 PyObject *resultobj = 0;
32277 wxMetafileDataObject *result = 0 ;
32278
32279 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32280 {
32281 PyThreadState* __tstate = wxPyBeginAllowThreads();
32282 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32283 wxPyEndAllowThreads(__tstate);
32284 if (PyErr_Occurred()) SWIG_fail;
32285 }
32286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32287 return resultobj;
32288 fail:
32289 return NULL;
32290 }
32291
32292
32293 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32294 PyObject *obj;
32295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32296 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32297 return SWIG_Py_Void();
32298 }
32299
32300 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32301 return SWIG_Python_InitShadowInstance(args);
32302 }
32303
32304 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32305 PyObject *resultobj = 0;
32306 wxDragResult arg1 ;
32307 bool result;
32308 int val1 ;
32309 int ecode1 = 0 ;
32310 PyObject * obj0 = 0 ;
32311 char * kwnames[] = {
32312 (char *) "res", NULL
32313 };
32314
32315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32316 ecode1 = SWIG_AsVal_int(obj0, &val1);
32317 if (!SWIG_IsOK(ecode1)) {
32318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32319 }
32320 arg1 = static_cast< wxDragResult >(val1);
32321 {
32322 PyThreadState* __tstate = wxPyBeginAllowThreads();
32323 result = (bool)wxIsDragResultOk(arg1);
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 {
32328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32329 }
32330 return resultobj;
32331 fail:
32332 return NULL;
32333 }
32334
32335
32336 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32337 PyObject *resultobj = 0;
32338 wxWindow *arg1 = (wxWindow *) 0 ;
32339 wxIcon const &arg2_defvalue = wxNullIcon ;
32340 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32341 wxIcon const &arg3_defvalue = wxNullIcon ;
32342 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32343 wxIcon const &arg4_defvalue = wxNullIcon ;
32344 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32345 wxPyDropSource *result = 0 ;
32346 void *argp1 = 0 ;
32347 int res1 = 0 ;
32348 void *argp2 = 0 ;
32349 int res2 = 0 ;
32350 void *argp3 = 0 ;
32351 int res3 = 0 ;
32352 void *argp4 = 0 ;
32353 int res4 = 0 ;
32354 PyObject * obj0 = 0 ;
32355 PyObject * obj1 = 0 ;
32356 PyObject * obj2 = 0 ;
32357 PyObject * obj3 = 0 ;
32358 char * kwnames[] = {
32359 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32360 };
32361
32362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32364 if (!SWIG_IsOK(res1)) {
32365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32366 }
32367 arg1 = reinterpret_cast< wxWindow * >(argp1);
32368 if (obj1) {
32369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32370 if (!SWIG_IsOK(res2)) {
32371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32372 }
32373 if (!argp2) {
32374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32375 }
32376 arg2 = reinterpret_cast< wxIcon * >(argp2);
32377 }
32378 if (obj2) {
32379 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32380 if (!SWIG_IsOK(res3)) {
32381 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32382 }
32383 if (!argp3) {
32384 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32385 }
32386 arg3 = reinterpret_cast< wxIcon * >(argp3);
32387 }
32388 if (obj3) {
32389 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32390 if (!SWIG_IsOK(res4)) {
32391 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32392 }
32393 if (!argp4) {
32394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32395 }
32396 arg4 = reinterpret_cast< wxIcon * >(argp4);
32397 }
32398 {
32399 PyThreadState* __tstate = wxPyBeginAllowThreads();
32400 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32405 return resultobj;
32406 fail:
32407 return NULL;
32408 }
32409
32410
32411 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32412 PyObject *resultobj = 0;
32413 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32414 PyObject *arg2 = (PyObject *) 0 ;
32415 PyObject *arg3 = (PyObject *) 0 ;
32416 int arg4 ;
32417 void *argp1 = 0 ;
32418 int res1 = 0 ;
32419 int val4 ;
32420 int ecode4 = 0 ;
32421 PyObject * obj0 = 0 ;
32422 PyObject * obj1 = 0 ;
32423 PyObject * obj2 = 0 ;
32424 PyObject * obj3 = 0 ;
32425 char * kwnames[] = {
32426 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32427 };
32428
32429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32431 if (!SWIG_IsOK(res1)) {
32432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32433 }
32434 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32435 arg2 = obj1;
32436 arg3 = obj2;
32437 ecode4 = SWIG_AsVal_int(obj3, &val4);
32438 if (!SWIG_IsOK(ecode4)) {
32439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32440 }
32441 arg4 = static_cast< int >(val4);
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 resultobj = SWIG_Py_Void();
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 PyObject *resultobj = 0;
32457 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32458 void *argp1 = 0 ;
32459 int res1 = 0 ;
32460 PyObject *swig_obj[1] ;
32461
32462 if (!args) SWIG_fail;
32463 swig_obj[0] = args;
32464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32465 if (!SWIG_IsOK(res1)) {
32466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32467 }
32468 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 delete arg1;
32472
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 resultobj = SWIG_Py_Void();
32477 return resultobj;
32478 fail:
32479 return NULL;
32480 }
32481
32482
32483 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32484 PyObject *resultobj = 0;
32485 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32486 wxDataObject *arg2 = 0 ;
32487 void *argp1 = 0 ;
32488 int res1 = 0 ;
32489 void *argp2 = 0 ;
32490 int res2 = 0 ;
32491 PyObject * obj0 = 0 ;
32492 PyObject * obj1 = 0 ;
32493 char * kwnames[] = {
32494 (char *) "self",(char *) "data", NULL
32495 };
32496
32497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32499 if (!SWIG_IsOK(res1)) {
32500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32501 }
32502 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32503 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32504 if (!SWIG_IsOK(res2)) {
32505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32506 }
32507 if (!argp2) {
32508 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32509 }
32510 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32511 {
32512 PyThreadState* __tstate = wxPyBeginAllowThreads();
32513 (arg1)->SetData(*arg2);
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 resultobj = SWIG_Py_Void();
32518 return resultobj;
32519 fail:
32520 return NULL;
32521 }
32522
32523
32524 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32525 PyObject *resultobj = 0;
32526 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32527 wxDataObject *result = 0 ;
32528 void *argp1 = 0 ;
32529 int res1 = 0 ;
32530 PyObject *swig_obj[1] ;
32531
32532 if (!args) SWIG_fail;
32533 swig_obj[0] = args;
32534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32535 if (!SWIG_IsOK(res1)) {
32536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32537 }
32538 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 result = (wxDataObject *)(arg1)->GetDataObject();
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32546 return resultobj;
32547 fail:
32548 return NULL;
32549 }
32550
32551
32552 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32553 PyObject *resultobj = 0;
32554 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32555 wxDragResult arg2 ;
32556 wxCursor *arg3 = 0 ;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 int val2 ;
32560 int ecode2 = 0 ;
32561 void *argp3 = 0 ;
32562 int res3 = 0 ;
32563 PyObject * obj0 = 0 ;
32564 PyObject * obj1 = 0 ;
32565 PyObject * obj2 = 0 ;
32566 char * kwnames[] = {
32567 (char *) "self",(char *) "res",(char *) "cursor", NULL
32568 };
32569
32570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32572 if (!SWIG_IsOK(res1)) {
32573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32574 }
32575 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32576 ecode2 = SWIG_AsVal_int(obj1, &val2);
32577 if (!SWIG_IsOK(ecode2)) {
32578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32579 }
32580 arg2 = static_cast< wxDragResult >(val2);
32581 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32582 if (!SWIG_IsOK(res3)) {
32583 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32584 }
32585 if (!argp3) {
32586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32587 }
32588 arg3 = reinterpret_cast< wxCursor * >(argp3);
32589 {
32590 PyThreadState* __tstate = wxPyBeginAllowThreads();
32591 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 resultobj = SWIG_Py_Void();
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32603 PyObject *resultobj = 0;
32604 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32605 int arg2 = (int) wxDrag_CopyOnly ;
32606 wxDragResult result;
32607 void *argp1 = 0 ;
32608 int res1 = 0 ;
32609 int val2 ;
32610 int ecode2 = 0 ;
32611 PyObject * obj0 = 0 ;
32612 PyObject * obj1 = 0 ;
32613 char * kwnames[] = {
32614 (char *) "self",(char *) "flags", NULL
32615 };
32616
32617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32619 if (!SWIG_IsOK(res1)) {
32620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32621 }
32622 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32623 if (obj1) {
32624 ecode2 = SWIG_AsVal_int(obj1, &val2);
32625 if (!SWIG_IsOK(ecode2)) {
32626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32627 }
32628 arg2 = static_cast< int >(val2);
32629 }
32630 {
32631 PyThreadState* __tstate = wxPyBeginAllowThreads();
32632 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32633 wxPyEndAllowThreads(__tstate);
32634 if (PyErr_Occurred()) SWIG_fail;
32635 }
32636 resultobj = SWIG_From_int(static_cast< int >(result));
32637 return resultobj;
32638 fail:
32639 return NULL;
32640 }
32641
32642
32643 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32644 PyObject *resultobj = 0;
32645 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32646 wxDragResult arg2 ;
32647 bool result;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 int val2 ;
32651 int ecode2 = 0 ;
32652 PyObject * obj0 = 0 ;
32653 PyObject * obj1 = 0 ;
32654 char * kwnames[] = {
32655 (char *) "self",(char *) "effect", NULL
32656 };
32657
32658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32660 if (!SWIG_IsOK(res1)) {
32661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32662 }
32663 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32664 ecode2 = SWIG_AsVal_int(obj1, &val2);
32665 if (!SWIG_IsOK(ecode2)) {
32666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32667 }
32668 arg2 = static_cast< wxDragResult >(val2);
32669 {
32670 PyThreadState* __tstate = wxPyBeginAllowThreads();
32671 result = (bool)(arg1)->GiveFeedback(arg2);
32672 wxPyEndAllowThreads(__tstate);
32673 if (PyErr_Occurred()) SWIG_fail;
32674 }
32675 {
32676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32677 }
32678 return resultobj;
32679 fail:
32680 return NULL;
32681 }
32682
32683
32684 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32685 PyObject *obj;
32686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32687 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32688 return SWIG_Py_Void();
32689 }
32690
32691 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32692 return SWIG_Python_InitShadowInstance(args);
32693 }
32694
32695 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32696 PyObject *resultobj = 0;
32697 wxDataObject *arg1 = (wxDataObject *) NULL ;
32698 wxPyDropTarget *result = 0 ;
32699 int res1 = 0 ;
32700 PyObject * obj0 = 0 ;
32701 char * kwnames[] = {
32702 (char *) "dataObject", NULL
32703 };
32704
32705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32706 if (obj0) {
32707 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32708 if (!SWIG_IsOK(res1)) {
32709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32710 }
32711 }
32712 {
32713 PyThreadState* __tstate = wxPyBeginAllowThreads();
32714 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32726 PyObject *resultobj = 0;
32727 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32728 PyObject *arg2 = (PyObject *) 0 ;
32729 PyObject *arg3 = (PyObject *) 0 ;
32730 void *argp1 = 0 ;
32731 int res1 = 0 ;
32732 PyObject * obj0 = 0 ;
32733 PyObject * obj1 = 0 ;
32734 PyObject * obj2 = 0 ;
32735 char * kwnames[] = {
32736 (char *) "self",(char *) "self",(char *) "_class", NULL
32737 };
32738
32739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32741 if (!SWIG_IsOK(res1)) {
32742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32743 }
32744 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32745 arg2 = obj1;
32746 arg3 = obj2;
32747 {
32748 PyThreadState* __tstate = wxPyBeginAllowThreads();
32749 (arg1)->_setCallbackInfo(arg2,arg3);
32750 wxPyEndAllowThreads(__tstate);
32751 if (PyErr_Occurred()) SWIG_fail;
32752 }
32753 resultobj = SWIG_Py_Void();
32754 return resultobj;
32755 fail:
32756 return NULL;
32757 }
32758
32759
32760 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32761 PyObject *resultobj = 0;
32762 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32763 void *argp1 = 0 ;
32764 int res1 = 0 ;
32765 PyObject *swig_obj[1] ;
32766
32767 if (!args) SWIG_fail;
32768 swig_obj[0] = args;
32769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32770 if (!SWIG_IsOK(res1)) {
32771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32772 }
32773 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32774 {
32775 PyThreadState* __tstate = wxPyBeginAllowThreads();
32776 delete arg1;
32777
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 resultobj = SWIG_Py_Void();
32782 return resultobj;
32783 fail:
32784 return NULL;
32785 }
32786
32787
32788 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32789 PyObject *resultobj = 0;
32790 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32791 wxDataObject *result = 0 ;
32792 void *argp1 = 0 ;
32793 int res1 = 0 ;
32794 PyObject *swig_obj[1] ;
32795
32796 if (!args) SWIG_fail;
32797 swig_obj[0] = args;
32798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32799 if (!SWIG_IsOK(res1)) {
32800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32801 }
32802 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 result = (wxDataObject *)(arg1)->GetDataObject();
32806 wxPyEndAllowThreads(__tstate);
32807 if (PyErr_Occurred()) SWIG_fail;
32808 }
32809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32817 PyObject *resultobj = 0;
32818 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32819 wxDataObject *arg2 = (wxDataObject *) 0 ;
32820 void *argp1 = 0 ;
32821 int res1 = 0 ;
32822 int res2 = 0 ;
32823 PyObject * obj0 = 0 ;
32824 PyObject * obj1 = 0 ;
32825 char * kwnames[] = {
32826 (char *) "self",(char *) "dataObject", NULL
32827 };
32828
32829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32831 if (!SWIG_IsOK(res1)) {
32832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32833 }
32834 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32835 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32836 if (!SWIG_IsOK(res2)) {
32837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32838 }
32839 {
32840 PyThreadState* __tstate = wxPyBeginAllowThreads();
32841 (arg1)->SetDataObject(arg2);
32842 wxPyEndAllowThreads(__tstate);
32843 if (PyErr_Occurred()) SWIG_fail;
32844 }
32845 resultobj = SWIG_Py_Void();
32846 return resultobj;
32847 fail:
32848 return NULL;
32849 }
32850
32851
32852 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32853 PyObject *resultobj = 0;
32854 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32855 int arg2 ;
32856 int arg3 ;
32857 wxDragResult arg4 ;
32858 wxDragResult result;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 int val2 ;
32862 int ecode2 = 0 ;
32863 int val3 ;
32864 int ecode3 = 0 ;
32865 int val4 ;
32866 int ecode4 = 0 ;
32867 PyObject * obj0 = 0 ;
32868 PyObject * obj1 = 0 ;
32869 PyObject * obj2 = 0 ;
32870 PyObject * obj3 = 0 ;
32871 char * kwnames[] = {
32872 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32873 };
32874
32875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32877 if (!SWIG_IsOK(res1)) {
32878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32879 }
32880 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32881 ecode2 = SWIG_AsVal_int(obj1, &val2);
32882 if (!SWIG_IsOK(ecode2)) {
32883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32884 }
32885 arg2 = static_cast< int >(val2);
32886 ecode3 = SWIG_AsVal_int(obj2, &val3);
32887 if (!SWIG_IsOK(ecode3)) {
32888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32889 }
32890 arg3 = static_cast< int >(val3);
32891 ecode4 = SWIG_AsVal_int(obj3, &val4);
32892 if (!SWIG_IsOK(ecode4)) {
32893 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32894 }
32895 arg4 = static_cast< wxDragResult >(val4);
32896 {
32897 PyThreadState* __tstate = wxPyBeginAllowThreads();
32898 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32899 wxPyEndAllowThreads(__tstate);
32900 if (PyErr_Occurred()) SWIG_fail;
32901 }
32902 resultobj = SWIG_From_int(static_cast< int >(result));
32903 return resultobj;
32904 fail:
32905 return NULL;
32906 }
32907
32908
32909 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32910 PyObject *resultobj = 0;
32911 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32912 int arg2 ;
32913 int arg3 ;
32914 wxDragResult arg4 ;
32915 wxDragResult result;
32916 void *argp1 = 0 ;
32917 int res1 = 0 ;
32918 int val2 ;
32919 int ecode2 = 0 ;
32920 int val3 ;
32921 int ecode3 = 0 ;
32922 int val4 ;
32923 int ecode4 = 0 ;
32924 PyObject * obj0 = 0 ;
32925 PyObject * obj1 = 0 ;
32926 PyObject * obj2 = 0 ;
32927 PyObject * obj3 = 0 ;
32928 char * kwnames[] = {
32929 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32930 };
32931
32932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32934 if (!SWIG_IsOK(res1)) {
32935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32936 }
32937 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32938 ecode2 = SWIG_AsVal_int(obj1, &val2);
32939 if (!SWIG_IsOK(ecode2)) {
32940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32941 }
32942 arg2 = static_cast< int >(val2);
32943 ecode3 = SWIG_AsVal_int(obj2, &val3);
32944 if (!SWIG_IsOK(ecode3)) {
32945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32946 }
32947 arg3 = static_cast< int >(val3);
32948 ecode4 = SWIG_AsVal_int(obj3, &val4);
32949 if (!SWIG_IsOK(ecode4)) {
32950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32951 }
32952 arg4 = static_cast< wxDragResult >(val4);
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 resultobj = SWIG_From_int(static_cast< int >(result));
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32969 void *argp1 = 0 ;
32970 int res1 = 0 ;
32971 PyObject *swig_obj[1] ;
32972
32973 if (!args) SWIG_fail;
32974 swig_obj[0] = args;
32975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32976 if (!SWIG_IsOK(res1)) {
32977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32978 }
32979 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32980 {
32981 PyThreadState* __tstate = wxPyBeginAllowThreads();
32982 (arg1)->OnLeave();
32983 wxPyEndAllowThreads(__tstate);
32984 if (PyErr_Occurred()) SWIG_fail;
32985 }
32986 resultobj = SWIG_Py_Void();
32987 return resultobj;
32988 fail:
32989 return NULL;
32990 }
32991
32992
32993 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32994 PyObject *resultobj = 0;
32995 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32996 int arg2 ;
32997 int arg3 ;
32998 bool result;
32999 void *argp1 = 0 ;
33000 int res1 = 0 ;
33001 int val2 ;
33002 int ecode2 = 0 ;
33003 int val3 ;
33004 int ecode3 = 0 ;
33005 PyObject * obj0 = 0 ;
33006 PyObject * obj1 = 0 ;
33007 PyObject * obj2 = 0 ;
33008 char * kwnames[] = {
33009 (char *) "self",(char *) "x",(char *) "y", NULL
33010 };
33011
33012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33014 if (!SWIG_IsOK(res1)) {
33015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33016 }
33017 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33018 ecode2 = SWIG_AsVal_int(obj1, &val2);
33019 if (!SWIG_IsOK(ecode2)) {
33020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33021 }
33022 arg2 = static_cast< int >(val2);
33023 ecode3 = SWIG_AsVal_int(obj2, &val3);
33024 if (!SWIG_IsOK(ecode3)) {
33025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33026 }
33027 arg3 = static_cast< int >(val3);
33028 {
33029 PyThreadState* __tstate = wxPyBeginAllowThreads();
33030 result = (bool)(arg1)->OnDrop(arg2,arg3);
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 {
33035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33036 }
33037 return resultobj;
33038 fail:
33039 return NULL;
33040 }
33041
33042
33043 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33044 PyObject *resultobj = 0;
33045 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33046 bool result;
33047 void *argp1 = 0 ;
33048 int res1 = 0 ;
33049 PyObject *swig_obj[1] ;
33050
33051 if (!args) SWIG_fail;
33052 swig_obj[0] = args;
33053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33054 if (!SWIG_IsOK(res1)) {
33055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33056 }
33057 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33058 {
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 result = (bool)(arg1)->GetData();
33061 wxPyEndAllowThreads(__tstate);
33062 if (PyErr_Occurred()) SWIG_fail;
33063 }
33064 {
33065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33066 }
33067 return resultobj;
33068 fail:
33069 return NULL;
33070 }
33071
33072
33073 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33074 PyObject *resultobj = 0;
33075 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33076 wxDragResult arg2 ;
33077 void *argp1 = 0 ;
33078 int res1 = 0 ;
33079 int val2 ;
33080 int ecode2 = 0 ;
33081 PyObject * obj0 = 0 ;
33082 PyObject * obj1 = 0 ;
33083 char * kwnames[] = {
33084 (char *) "self",(char *) "action", NULL
33085 };
33086
33087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33089 if (!SWIG_IsOK(res1)) {
33090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33091 }
33092 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33093 ecode2 = SWIG_AsVal_int(obj1, &val2);
33094 if (!SWIG_IsOK(ecode2)) {
33095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33096 }
33097 arg2 = static_cast< wxDragResult >(val2);
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 (arg1)->SetDefaultAction(arg2);
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 resultobj = SWIG_Py_Void();
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33112 PyObject *resultobj = 0;
33113 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33114 wxDragResult result;
33115 void *argp1 = 0 ;
33116 int res1 = 0 ;
33117 PyObject *swig_obj[1] ;
33118
33119 if (!args) SWIG_fail;
33120 swig_obj[0] = args;
33121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33122 if (!SWIG_IsOK(res1)) {
33123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33124 }
33125 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33126 {
33127 PyThreadState* __tstate = wxPyBeginAllowThreads();
33128 result = (wxDragResult)(arg1)->GetDefaultAction();
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 resultobj = SWIG_From_int(static_cast< int >(result));
33133 return resultobj;
33134 fail:
33135 return NULL;
33136 }
33137
33138
33139 SWIGINTERN PyObject *DropTarget_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_wxPyDropTarget, SWIG_NewClientData(obj));
33143 return SWIG_Py_Void();
33144 }
33145
33146 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33147 return SWIG_Python_InitShadowInstance(args);
33148 }
33149
33150 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33151 PyObject *resultobj = 0;
33152 wxPyTextDropTarget *result = 0 ;
33153
33154 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33162 return resultobj;
33163 fail:
33164 return NULL;
33165 }
33166
33167
33168 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33169 PyObject *resultobj = 0;
33170 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33171 PyObject *arg2 = (PyObject *) 0 ;
33172 PyObject *arg3 = (PyObject *) 0 ;
33173 void *argp1 = 0 ;
33174 int res1 = 0 ;
33175 PyObject * obj0 = 0 ;
33176 PyObject * obj1 = 0 ;
33177 PyObject * obj2 = 0 ;
33178 char * kwnames[] = {
33179 (char *) "self",(char *) "self",(char *) "_class", NULL
33180 };
33181
33182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33184 if (!SWIG_IsOK(res1)) {
33185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33186 }
33187 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33188 arg2 = obj1;
33189 arg3 = obj2;
33190 {
33191 PyThreadState* __tstate = wxPyBeginAllowThreads();
33192 (arg1)->_setCallbackInfo(arg2,arg3);
33193 wxPyEndAllowThreads(__tstate);
33194 if (PyErr_Occurred()) SWIG_fail;
33195 }
33196 resultobj = SWIG_Py_Void();
33197 return resultobj;
33198 fail:
33199 return NULL;
33200 }
33201
33202
33203 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33204 PyObject *resultobj = 0;
33205 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33206 int arg2 ;
33207 int arg3 ;
33208 wxString *arg4 = 0 ;
33209 bool result;
33210 void *argp1 = 0 ;
33211 int res1 = 0 ;
33212 int val2 ;
33213 int ecode2 = 0 ;
33214 int val3 ;
33215 int ecode3 = 0 ;
33216 bool temp4 = false ;
33217 PyObject * obj0 = 0 ;
33218 PyObject * obj1 = 0 ;
33219 PyObject * obj2 = 0 ;
33220 PyObject * obj3 = 0 ;
33221 char * kwnames[] = {
33222 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33223 };
33224
33225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33227 if (!SWIG_IsOK(res1)) {
33228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33229 }
33230 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33231 ecode2 = SWIG_AsVal_int(obj1, &val2);
33232 if (!SWIG_IsOK(ecode2)) {
33233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33234 }
33235 arg2 = static_cast< int >(val2);
33236 ecode3 = SWIG_AsVal_int(obj2, &val3);
33237 if (!SWIG_IsOK(ecode3)) {
33238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33239 }
33240 arg3 = static_cast< int >(val3);
33241 {
33242 arg4 = wxString_in_helper(obj3);
33243 if (arg4 == NULL) SWIG_fail;
33244 temp4 = true;
33245 }
33246 {
33247 PyThreadState* __tstate = wxPyBeginAllowThreads();
33248 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33249 wxPyEndAllowThreads(__tstate);
33250 if (PyErr_Occurred()) SWIG_fail;
33251 }
33252 {
33253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33254 }
33255 {
33256 if (temp4)
33257 delete arg4;
33258 }
33259 return resultobj;
33260 fail:
33261 {
33262 if (temp4)
33263 delete arg4;
33264 }
33265 return NULL;
33266 }
33267
33268
33269 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33270 PyObject *resultobj = 0;
33271 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33272 int arg2 ;
33273 int arg3 ;
33274 wxDragResult arg4 ;
33275 wxDragResult result;
33276 void *argp1 = 0 ;
33277 int res1 = 0 ;
33278 int val2 ;
33279 int ecode2 = 0 ;
33280 int val3 ;
33281 int ecode3 = 0 ;
33282 int val4 ;
33283 int ecode4 = 0 ;
33284 PyObject * obj0 = 0 ;
33285 PyObject * obj1 = 0 ;
33286 PyObject * obj2 = 0 ;
33287 PyObject * obj3 = 0 ;
33288 char * kwnames[] = {
33289 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33290 };
33291
33292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33294 if (!SWIG_IsOK(res1)) {
33295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33296 }
33297 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33298 ecode2 = SWIG_AsVal_int(obj1, &val2);
33299 if (!SWIG_IsOK(ecode2)) {
33300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33301 }
33302 arg2 = static_cast< int >(val2);
33303 ecode3 = SWIG_AsVal_int(obj2, &val3);
33304 if (!SWIG_IsOK(ecode3)) {
33305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33306 }
33307 arg3 = static_cast< int >(val3);
33308 ecode4 = SWIG_AsVal_int(obj3, &val4);
33309 if (!SWIG_IsOK(ecode4)) {
33310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33311 }
33312 arg4 = static_cast< wxDragResult >(val4);
33313 {
33314 PyThreadState* __tstate = wxPyBeginAllowThreads();
33315 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33316 wxPyEndAllowThreads(__tstate);
33317 if (PyErr_Occurred()) SWIG_fail;
33318 }
33319 resultobj = SWIG_From_int(static_cast< int >(result));
33320 return resultobj;
33321 fail:
33322 return NULL;
33323 }
33324
33325
33326 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33327 PyObject *resultobj = 0;
33328 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33329 int arg2 ;
33330 int arg3 ;
33331 wxDragResult arg4 ;
33332 wxDragResult result;
33333 void *argp1 = 0 ;
33334 int res1 = 0 ;
33335 int val2 ;
33336 int ecode2 = 0 ;
33337 int val3 ;
33338 int ecode3 = 0 ;
33339 int val4 ;
33340 int ecode4 = 0 ;
33341 PyObject * obj0 = 0 ;
33342 PyObject * obj1 = 0 ;
33343 PyObject * obj2 = 0 ;
33344 PyObject * obj3 = 0 ;
33345 char * kwnames[] = {
33346 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33347 };
33348
33349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33351 if (!SWIG_IsOK(res1)) {
33352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33353 }
33354 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33355 ecode2 = SWIG_AsVal_int(obj1, &val2);
33356 if (!SWIG_IsOK(ecode2)) {
33357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33358 }
33359 arg2 = static_cast< int >(val2);
33360 ecode3 = SWIG_AsVal_int(obj2, &val3);
33361 if (!SWIG_IsOK(ecode3)) {
33362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33363 }
33364 arg3 = static_cast< int >(val3);
33365 ecode4 = SWIG_AsVal_int(obj3, &val4);
33366 if (!SWIG_IsOK(ecode4)) {
33367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33368 }
33369 arg4 = static_cast< wxDragResult >(val4);
33370 {
33371 PyThreadState* __tstate = wxPyBeginAllowThreads();
33372 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33373 wxPyEndAllowThreads(__tstate);
33374 if (PyErr_Occurred()) SWIG_fail;
33375 }
33376 resultobj = SWIG_From_int(static_cast< int >(result));
33377 return resultobj;
33378 fail:
33379 return NULL;
33380 }
33381
33382
33383 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33384 PyObject *resultobj = 0;
33385 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 PyObject *swig_obj[1] ;
33389
33390 if (!args) SWIG_fail;
33391 swig_obj[0] = args;
33392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33393 if (!SWIG_IsOK(res1)) {
33394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33395 }
33396 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33397 {
33398 PyThreadState* __tstate = wxPyBeginAllowThreads();
33399 (arg1)->OnLeave();
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 resultobj = SWIG_Py_Void();
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33411 PyObject *resultobj = 0;
33412 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33413 int arg2 ;
33414 int arg3 ;
33415 bool result;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 int val2 ;
33419 int ecode2 = 0 ;
33420 int val3 ;
33421 int ecode3 = 0 ;
33422 PyObject * obj0 = 0 ;
33423 PyObject * obj1 = 0 ;
33424 PyObject * obj2 = 0 ;
33425 char * kwnames[] = {
33426 (char *) "self",(char *) "x",(char *) "y", NULL
33427 };
33428
33429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33431 if (!SWIG_IsOK(res1)) {
33432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33433 }
33434 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33435 ecode2 = SWIG_AsVal_int(obj1, &val2);
33436 if (!SWIG_IsOK(ecode2)) {
33437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33438 }
33439 arg2 = static_cast< int >(val2);
33440 ecode3 = SWIG_AsVal_int(obj2, &val3);
33441 if (!SWIG_IsOK(ecode3)) {
33442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33443 }
33444 arg3 = static_cast< int >(val3);
33445 {
33446 PyThreadState* __tstate = wxPyBeginAllowThreads();
33447 result = (bool)(arg1)->OnDrop(arg2,arg3);
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 {
33452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33453 }
33454 return resultobj;
33455 fail:
33456 return NULL;
33457 }
33458
33459
33460 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33461 PyObject *resultobj = 0;
33462 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33463 int arg2 ;
33464 int arg3 ;
33465 wxDragResult arg4 ;
33466 wxDragResult result;
33467 void *argp1 = 0 ;
33468 int res1 = 0 ;
33469 int val2 ;
33470 int ecode2 = 0 ;
33471 int val3 ;
33472 int ecode3 = 0 ;
33473 int val4 ;
33474 int ecode4 = 0 ;
33475 PyObject * obj0 = 0 ;
33476 PyObject * obj1 = 0 ;
33477 PyObject * obj2 = 0 ;
33478 PyObject * obj3 = 0 ;
33479 char * kwnames[] = {
33480 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33481 };
33482
33483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33485 if (!SWIG_IsOK(res1)) {
33486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33487 }
33488 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33489 ecode2 = SWIG_AsVal_int(obj1, &val2);
33490 if (!SWIG_IsOK(ecode2)) {
33491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33492 }
33493 arg2 = static_cast< int >(val2);
33494 ecode3 = SWIG_AsVal_int(obj2, &val3);
33495 if (!SWIG_IsOK(ecode3)) {
33496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33497 }
33498 arg3 = static_cast< int >(val3);
33499 ecode4 = SWIG_AsVal_int(obj3, &val4);
33500 if (!SWIG_IsOK(ecode4)) {
33501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33502 }
33503 arg4 = static_cast< wxDragResult >(val4);
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 resultobj = SWIG_From_int(static_cast< int >(result));
33511 return resultobj;
33512 fail:
33513 return NULL;
33514 }
33515
33516
33517 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33518 PyObject *obj;
33519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33520 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33521 return SWIG_Py_Void();
33522 }
33523
33524 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33525 return SWIG_Python_InitShadowInstance(args);
33526 }
33527
33528 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33529 PyObject *resultobj = 0;
33530 wxPyFileDropTarget *result = 0 ;
33531
33532 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33533 {
33534 PyThreadState* __tstate = wxPyBeginAllowThreads();
33535 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33536 wxPyEndAllowThreads(__tstate);
33537 if (PyErr_Occurred()) SWIG_fail;
33538 }
33539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33540 return resultobj;
33541 fail:
33542 return NULL;
33543 }
33544
33545
33546 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33547 PyObject *resultobj = 0;
33548 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33549 PyObject *arg2 = (PyObject *) 0 ;
33550 PyObject *arg3 = (PyObject *) 0 ;
33551 void *argp1 = 0 ;
33552 int res1 = 0 ;
33553 PyObject * obj0 = 0 ;
33554 PyObject * obj1 = 0 ;
33555 PyObject * obj2 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "self",(char *) "_class", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33564 }
33565 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33566 arg2 = obj1;
33567 arg3 = obj2;
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 (arg1)->_setCallbackInfo(arg2,arg3);
33571 wxPyEndAllowThreads(__tstate);
33572 if (PyErr_Occurred()) SWIG_fail;
33573 }
33574 resultobj = SWIG_Py_Void();
33575 return resultobj;
33576 fail:
33577 return NULL;
33578 }
33579
33580
33581 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33582 PyObject *resultobj = 0;
33583 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33584 int arg2 ;
33585 int arg3 ;
33586 wxArrayString *arg4 = 0 ;
33587 bool result;
33588 void *argp1 = 0 ;
33589 int res1 = 0 ;
33590 int val2 ;
33591 int ecode2 = 0 ;
33592 int val3 ;
33593 int ecode3 = 0 ;
33594 bool temp4 = false ;
33595 PyObject * obj0 = 0 ;
33596 PyObject * obj1 = 0 ;
33597 PyObject * obj2 = 0 ;
33598 PyObject * obj3 = 0 ;
33599 char * kwnames[] = {
33600 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33601 };
33602
33603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33605 if (!SWIG_IsOK(res1)) {
33606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33607 }
33608 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33609 ecode2 = SWIG_AsVal_int(obj1, &val2);
33610 if (!SWIG_IsOK(ecode2)) {
33611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33612 }
33613 arg2 = static_cast< int >(val2);
33614 ecode3 = SWIG_AsVal_int(obj2, &val3);
33615 if (!SWIG_IsOK(ecode3)) {
33616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33617 }
33618 arg3 = static_cast< int >(val3);
33619 {
33620 if (! PySequence_Check(obj3)) {
33621 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33622 SWIG_fail;
33623 }
33624 arg4 = new wxArrayString;
33625 temp4 = true;
33626 int i, len=PySequence_Length(obj3);
33627 for (i=0; i<len; i++) {
33628 PyObject* item = PySequence_GetItem(obj3, i);
33629 wxString* s = wxString_in_helper(item);
33630 if (PyErr_Occurred()) SWIG_fail;
33631 arg4->Add(*s);
33632 delete s;
33633 Py_DECREF(item);
33634 }
33635 }
33636 {
33637 PyThreadState* __tstate = wxPyBeginAllowThreads();
33638 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33639 wxPyEndAllowThreads(__tstate);
33640 if (PyErr_Occurred()) SWIG_fail;
33641 }
33642 {
33643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33644 }
33645 {
33646 if (temp4) delete arg4;
33647 }
33648 return resultobj;
33649 fail:
33650 {
33651 if (temp4) delete arg4;
33652 }
33653 return NULL;
33654 }
33655
33656
33657 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33658 PyObject *resultobj = 0;
33659 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33660 int arg2 ;
33661 int arg3 ;
33662 wxDragResult arg4 ;
33663 wxDragResult result;
33664 void *argp1 = 0 ;
33665 int res1 = 0 ;
33666 int val2 ;
33667 int ecode2 = 0 ;
33668 int val3 ;
33669 int ecode3 = 0 ;
33670 int val4 ;
33671 int ecode4 = 0 ;
33672 PyObject * obj0 = 0 ;
33673 PyObject * obj1 = 0 ;
33674 PyObject * obj2 = 0 ;
33675 PyObject * obj3 = 0 ;
33676 char * kwnames[] = {
33677 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33678 };
33679
33680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33682 if (!SWIG_IsOK(res1)) {
33683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33684 }
33685 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33686 ecode2 = SWIG_AsVal_int(obj1, &val2);
33687 if (!SWIG_IsOK(ecode2)) {
33688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33689 }
33690 arg2 = static_cast< int >(val2);
33691 ecode3 = SWIG_AsVal_int(obj2, &val3);
33692 if (!SWIG_IsOK(ecode3)) {
33693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33694 }
33695 arg3 = static_cast< int >(val3);
33696 ecode4 = SWIG_AsVal_int(obj3, &val4);
33697 if (!SWIG_IsOK(ecode4)) {
33698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33699 }
33700 arg4 = static_cast< wxDragResult >(val4);
33701 {
33702 PyThreadState* __tstate = wxPyBeginAllowThreads();
33703 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33704 wxPyEndAllowThreads(__tstate);
33705 if (PyErr_Occurred()) SWIG_fail;
33706 }
33707 resultobj = SWIG_From_int(static_cast< int >(result));
33708 return resultobj;
33709 fail:
33710 return NULL;
33711 }
33712
33713
33714 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33715 PyObject *resultobj = 0;
33716 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33717 int arg2 ;
33718 int arg3 ;
33719 wxDragResult arg4 ;
33720 wxDragResult result;
33721 void *argp1 = 0 ;
33722 int res1 = 0 ;
33723 int val2 ;
33724 int ecode2 = 0 ;
33725 int val3 ;
33726 int ecode3 = 0 ;
33727 int val4 ;
33728 int ecode4 = 0 ;
33729 PyObject * obj0 = 0 ;
33730 PyObject * obj1 = 0 ;
33731 PyObject * obj2 = 0 ;
33732 PyObject * obj3 = 0 ;
33733 char * kwnames[] = {
33734 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33735 };
33736
33737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33739 if (!SWIG_IsOK(res1)) {
33740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33741 }
33742 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33743 ecode2 = SWIG_AsVal_int(obj1, &val2);
33744 if (!SWIG_IsOK(ecode2)) {
33745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33746 }
33747 arg2 = static_cast< int >(val2);
33748 ecode3 = SWIG_AsVal_int(obj2, &val3);
33749 if (!SWIG_IsOK(ecode3)) {
33750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33751 }
33752 arg3 = static_cast< int >(val3);
33753 ecode4 = SWIG_AsVal_int(obj3, &val4);
33754 if (!SWIG_IsOK(ecode4)) {
33755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33756 }
33757 arg4 = static_cast< wxDragResult >(val4);
33758 {
33759 PyThreadState* __tstate = wxPyBeginAllowThreads();
33760 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 resultobj = SWIG_From_int(static_cast< int >(result));
33765 return resultobj;
33766 fail:
33767 return NULL;
33768 }
33769
33770
33771 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33772 PyObject *resultobj = 0;
33773 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33774 void *argp1 = 0 ;
33775 int res1 = 0 ;
33776 PyObject *swig_obj[1] ;
33777
33778 if (!args) SWIG_fail;
33779 swig_obj[0] = args;
33780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33781 if (!SWIG_IsOK(res1)) {
33782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33783 }
33784 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33785 {
33786 PyThreadState* __tstate = wxPyBeginAllowThreads();
33787 (arg1)->OnLeave();
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 resultobj = SWIG_Py_Void();
33792 return resultobj;
33793 fail:
33794 return NULL;
33795 }
33796
33797
33798 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33799 PyObject *resultobj = 0;
33800 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33801 int arg2 ;
33802 int arg3 ;
33803 bool result;
33804 void *argp1 = 0 ;
33805 int res1 = 0 ;
33806 int val2 ;
33807 int ecode2 = 0 ;
33808 int val3 ;
33809 int ecode3 = 0 ;
33810 PyObject * obj0 = 0 ;
33811 PyObject * obj1 = 0 ;
33812 PyObject * obj2 = 0 ;
33813 char * kwnames[] = {
33814 (char *) "self",(char *) "x",(char *) "y", NULL
33815 };
33816
33817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33819 if (!SWIG_IsOK(res1)) {
33820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33821 }
33822 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33823 ecode2 = SWIG_AsVal_int(obj1, &val2);
33824 if (!SWIG_IsOK(ecode2)) {
33825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33826 }
33827 arg2 = static_cast< int >(val2);
33828 ecode3 = SWIG_AsVal_int(obj2, &val3);
33829 if (!SWIG_IsOK(ecode3)) {
33830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33831 }
33832 arg3 = static_cast< int >(val3);
33833 {
33834 PyThreadState* __tstate = wxPyBeginAllowThreads();
33835 result = (bool)(arg1)->OnDrop(arg2,arg3);
33836 wxPyEndAllowThreads(__tstate);
33837 if (PyErr_Occurred()) SWIG_fail;
33838 }
33839 {
33840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33841 }
33842 return resultobj;
33843 fail:
33844 return NULL;
33845 }
33846
33847
33848 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33849 PyObject *resultobj = 0;
33850 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33851 int arg2 ;
33852 int arg3 ;
33853 wxDragResult arg4 ;
33854 wxDragResult result;
33855 void *argp1 = 0 ;
33856 int res1 = 0 ;
33857 int val2 ;
33858 int ecode2 = 0 ;
33859 int val3 ;
33860 int ecode3 = 0 ;
33861 int val4 ;
33862 int ecode4 = 0 ;
33863 PyObject * obj0 = 0 ;
33864 PyObject * obj1 = 0 ;
33865 PyObject * obj2 = 0 ;
33866 PyObject * obj3 = 0 ;
33867 char * kwnames[] = {
33868 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33869 };
33870
33871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33873 if (!SWIG_IsOK(res1)) {
33874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33875 }
33876 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33877 ecode2 = SWIG_AsVal_int(obj1, &val2);
33878 if (!SWIG_IsOK(ecode2)) {
33879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33880 }
33881 arg2 = static_cast< int >(val2);
33882 ecode3 = SWIG_AsVal_int(obj2, &val3);
33883 if (!SWIG_IsOK(ecode3)) {
33884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33885 }
33886 arg3 = static_cast< int >(val3);
33887 ecode4 = SWIG_AsVal_int(obj3, &val4);
33888 if (!SWIG_IsOK(ecode4)) {
33889 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33890 }
33891 arg4 = static_cast< wxDragResult >(val4);
33892 {
33893 PyThreadState* __tstate = wxPyBeginAllowThreads();
33894 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33895 wxPyEndAllowThreads(__tstate);
33896 if (PyErr_Occurred()) SWIG_fail;
33897 }
33898 resultobj = SWIG_From_int(static_cast< int >(result));
33899 return resultobj;
33900 fail:
33901 return NULL;
33902 }
33903
33904
33905 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33906 PyObject *obj;
33907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33908 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33909 return SWIG_Py_Void();
33910 }
33911
33912 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33913 return SWIG_Python_InitShadowInstance(args);
33914 }
33915
33916 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33917 PyObject *resultobj = 0;
33918 wxClipboard *result = 0 ;
33919
33920 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33921 {
33922 PyThreadState* __tstate = wxPyBeginAllowThreads();
33923 result = (wxClipboard *)new wxClipboard();
33924 wxPyEndAllowThreads(__tstate);
33925 if (PyErr_Occurred()) SWIG_fail;
33926 }
33927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33928 return resultobj;
33929 fail:
33930 return NULL;
33931 }
33932
33933
33934 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33935 PyObject *resultobj = 0;
33936 wxClipboard *arg1 = (wxClipboard *) 0 ;
33937 void *argp1 = 0 ;
33938 int res1 = 0 ;
33939 PyObject *swig_obj[1] ;
33940
33941 if (!args) SWIG_fail;
33942 swig_obj[0] = args;
33943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33944 if (!SWIG_IsOK(res1)) {
33945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33946 }
33947 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33948 {
33949 PyThreadState* __tstate = wxPyBeginAllowThreads();
33950 delete arg1;
33951
33952 wxPyEndAllowThreads(__tstate);
33953 if (PyErr_Occurred()) SWIG_fail;
33954 }
33955 resultobj = SWIG_Py_Void();
33956 return resultobj;
33957 fail:
33958 return NULL;
33959 }
33960
33961
33962 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33963 PyObject *resultobj = 0;
33964 wxClipboard *arg1 = (wxClipboard *) 0 ;
33965 bool result;
33966 void *argp1 = 0 ;
33967 int res1 = 0 ;
33968 PyObject *swig_obj[1] ;
33969
33970 if (!args) SWIG_fail;
33971 swig_obj[0] = args;
33972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33973 if (!SWIG_IsOK(res1)) {
33974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
33975 }
33976 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33977 {
33978 PyThreadState* __tstate = wxPyBeginAllowThreads();
33979 result = (bool)(arg1)->Open();
33980 wxPyEndAllowThreads(__tstate);
33981 if (PyErr_Occurred()) SWIG_fail;
33982 }
33983 {
33984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33985 }
33986 return resultobj;
33987 fail:
33988 return NULL;
33989 }
33990
33991
33992 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33993 PyObject *resultobj = 0;
33994 wxClipboard *arg1 = (wxClipboard *) 0 ;
33995 void *argp1 = 0 ;
33996 int res1 = 0 ;
33997 PyObject *swig_obj[1] ;
33998
33999 if (!args) SWIG_fail;
34000 swig_obj[0] = args;
34001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34002 if (!SWIG_IsOK(res1)) {
34003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34004 }
34005 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34006 {
34007 PyThreadState* __tstate = wxPyBeginAllowThreads();
34008 (arg1)->Close();
34009 wxPyEndAllowThreads(__tstate);
34010 if (PyErr_Occurred()) SWIG_fail;
34011 }
34012 resultobj = SWIG_Py_Void();
34013 return resultobj;
34014 fail:
34015 return NULL;
34016 }
34017
34018
34019 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34020 PyObject *resultobj = 0;
34021 wxClipboard *arg1 = (wxClipboard *) 0 ;
34022 bool result;
34023 void *argp1 = 0 ;
34024 int res1 = 0 ;
34025 PyObject *swig_obj[1] ;
34026
34027 if (!args) SWIG_fail;
34028 swig_obj[0] = args;
34029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34032 }
34033 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34034 {
34035 PyThreadState* __tstate = wxPyBeginAllowThreads();
34036 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34037 wxPyEndAllowThreads(__tstate);
34038 if (PyErr_Occurred()) SWIG_fail;
34039 }
34040 {
34041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34042 }
34043 return resultobj;
34044 fail:
34045 return NULL;
34046 }
34047
34048
34049 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34050 PyObject *resultobj = 0;
34051 wxClipboard *arg1 = (wxClipboard *) 0 ;
34052 wxDataObject *arg2 = (wxDataObject *) 0 ;
34053 bool result;
34054 void *argp1 = 0 ;
34055 int res1 = 0 ;
34056 int res2 = 0 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 char * kwnames[] = {
34060 (char *) "self",(char *) "data", NULL
34061 };
34062
34063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34065 if (!SWIG_IsOK(res1)) {
34066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34067 }
34068 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34069 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34070 if (!SWIG_IsOK(res2)) {
34071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34072 }
34073 {
34074 PyThreadState* __tstate = wxPyBeginAllowThreads();
34075 result = (bool)(arg1)->AddData(arg2);
34076 wxPyEndAllowThreads(__tstate);
34077 if (PyErr_Occurred()) SWIG_fail;
34078 }
34079 {
34080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34081 }
34082 return resultobj;
34083 fail:
34084 return NULL;
34085 }
34086
34087
34088 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34089 PyObject *resultobj = 0;
34090 wxClipboard *arg1 = (wxClipboard *) 0 ;
34091 wxDataObject *arg2 = (wxDataObject *) 0 ;
34092 bool result;
34093 void *argp1 = 0 ;
34094 int res1 = 0 ;
34095 int res2 = 0 ;
34096 PyObject * obj0 = 0 ;
34097 PyObject * obj1 = 0 ;
34098 char * kwnames[] = {
34099 (char *) "self",(char *) "data", NULL
34100 };
34101
34102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34104 if (!SWIG_IsOK(res1)) {
34105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34106 }
34107 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34108 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34109 if (!SWIG_IsOK(res2)) {
34110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34111 }
34112 {
34113 PyThreadState* __tstate = wxPyBeginAllowThreads();
34114 result = (bool)(arg1)->SetData(arg2);
34115 wxPyEndAllowThreads(__tstate);
34116 if (PyErr_Occurred()) SWIG_fail;
34117 }
34118 {
34119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34120 }
34121 return resultobj;
34122 fail:
34123 return NULL;
34124 }
34125
34126
34127 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34128 PyObject *resultobj = 0;
34129 wxClipboard *arg1 = (wxClipboard *) 0 ;
34130 wxDataFormat *arg2 = 0 ;
34131 bool result;
34132 void *argp1 = 0 ;
34133 int res1 = 0 ;
34134 void *argp2 = 0 ;
34135 int res2 = 0 ;
34136 PyObject * obj0 = 0 ;
34137 PyObject * obj1 = 0 ;
34138 char * kwnames[] = {
34139 (char *) "self",(char *) "format", NULL
34140 };
34141
34142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34144 if (!SWIG_IsOK(res1)) {
34145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34146 }
34147 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34148 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34149 if (!SWIG_IsOK(res2)) {
34150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34151 }
34152 if (!argp2) {
34153 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34154 }
34155 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34156 {
34157 PyThreadState* __tstate = wxPyBeginAllowThreads();
34158 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34159 wxPyEndAllowThreads(__tstate);
34160 if (PyErr_Occurred()) SWIG_fail;
34161 }
34162 {
34163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34164 }
34165 return resultobj;
34166 fail:
34167 return NULL;
34168 }
34169
34170
34171 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34172 PyObject *resultobj = 0;
34173 wxClipboard *arg1 = (wxClipboard *) 0 ;
34174 wxDataObject *arg2 = 0 ;
34175 bool result;
34176 void *argp1 = 0 ;
34177 int res1 = 0 ;
34178 void *argp2 = 0 ;
34179 int res2 = 0 ;
34180 PyObject * obj0 = 0 ;
34181 PyObject * obj1 = 0 ;
34182 char * kwnames[] = {
34183 (char *) "self",(char *) "data", NULL
34184 };
34185
34186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34188 if (!SWIG_IsOK(res1)) {
34189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34190 }
34191 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34192 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34193 if (!SWIG_IsOK(res2)) {
34194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34195 }
34196 if (!argp2) {
34197 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34198 }
34199 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34200 {
34201 PyThreadState* __tstate = wxPyBeginAllowThreads();
34202 result = (bool)(arg1)->GetData(*arg2);
34203 wxPyEndAllowThreads(__tstate);
34204 if (PyErr_Occurred()) SWIG_fail;
34205 }
34206 {
34207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34208 }
34209 return resultobj;
34210 fail:
34211 return NULL;
34212 }
34213
34214
34215 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34216 PyObject *resultobj = 0;
34217 wxClipboard *arg1 = (wxClipboard *) 0 ;
34218 void *argp1 = 0 ;
34219 int res1 = 0 ;
34220 PyObject *swig_obj[1] ;
34221
34222 if (!args) SWIG_fail;
34223 swig_obj[0] = args;
34224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34225 if (!SWIG_IsOK(res1)) {
34226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34227 }
34228 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34229 {
34230 PyThreadState* __tstate = wxPyBeginAllowThreads();
34231 (arg1)->Clear();
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 resultobj = SWIG_Py_Void();
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34243 PyObject *resultobj = 0;
34244 wxClipboard *arg1 = (wxClipboard *) 0 ;
34245 bool result;
34246 void *argp1 = 0 ;
34247 int res1 = 0 ;
34248 PyObject *swig_obj[1] ;
34249
34250 if (!args) SWIG_fail;
34251 swig_obj[0] = args;
34252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34253 if (!SWIG_IsOK(res1)) {
34254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34255 }
34256 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34257 {
34258 PyThreadState* __tstate = wxPyBeginAllowThreads();
34259 result = (bool)(arg1)->Flush();
34260 wxPyEndAllowThreads(__tstate);
34261 if (PyErr_Occurred()) SWIG_fail;
34262 }
34263 {
34264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34265 }
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34273 PyObject *resultobj = 0;
34274 wxClipboard *arg1 = (wxClipboard *) 0 ;
34275 bool arg2 = (bool) true ;
34276 void *argp1 = 0 ;
34277 int res1 = 0 ;
34278 bool val2 ;
34279 int ecode2 = 0 ;
34280 PyObject * obj0 = 0 ;
34281 PyObject * obj1 = 0 ;
34282 char * kwnames[] = {
34283 (char *) "self",(char *) "primary", NULL
34284 };
34285
34286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34288 if (!SWIG_IsOK(res1)) {
34289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34290 }
34291 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34292 if (obj1) {
34293 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34294 if (!SWIG_IsOK(ecode2)) {
34295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34296 }
34297 arg2 = static_cast< bool >(val2);
34298 }
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 (arg1)->UsePrimarySelection(arg2);
34302 wxPyEndAllowThreads(__tstate);
34303 if (PyErr_Occurred()) SWIG_fail;
34304 }
34305 resultobj = SWIG_Py_Void();
34306 return resultobj;
34307 fail:
34308 return NULL;
34309 }
34310
34311
34312 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34313 PyObject *resultobj = 0;
34314 wxClipboard *result = 0 ;
34315
34316 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34317 {
34318 PyThreadState* __tstate = wxPyBeginAllowThreads();
34319 result = (wxClipboard *)wxClipboard::Get();
34320 wxPyEndAllowThreads(__tstate);
34321 if (PyErr_Occurred()) SWIG_fail;
34322 }
34323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34324 return resultobj;
34325 fail:
34326 return NULL;
34327 }
34328
34329
34330 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34331 PyObject *obj;
34332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34333 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34334 return SWIG_Py_Void();
34335 }
34336
34337 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34338 return SWIG_Python_InitShadowInstance(args);
34339 }
34340
34341 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34342 PyObject *resultobj = 0;
34343 wxClipboard *arg1 = (wxClipboard *) NULL ;
34344 wxClipboardLocker *result = 0 ;
34345 void *argp1 = 0 ;
34346 int res1 = 0 ;
34347 PyObject * obj0 = 0 ;
34348 char * kwnames[] = {
34349 (char *) "clipboard", NULL
34350 };
34351
34352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34353 if (obj0) {
34354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34355 if (!SWIG_IsOK(res1)) {
34356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34357 }
34358 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34359 }
34360 {
34361 PyThreadState* __tstate = wxPyBeginAllowThreads();
34362 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34363 wxPyEndAllowThreads(__tstate);
34364 if (PyErr_Occurred()) SWIG_fail;
34365 }
34366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34367 return resultobj;
34368 fail:
34369 return NULL;
34370 }
34371
34372
34373 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34374 PyObject *resultobj = 0;
34375 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34376 void *argp1 = 0 ;
34377 int res1 = 0 ;
34378 PyObject *swig_obj[1] ;
34379
34380 if (!args) SWIG_fail;
34381 swig_obj[0] = args;
34382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34383 if (!SWIG_IsOK(res1)) {
34384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34385 }
34386 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34387 {
34388 PyThreadState* __tstate = wxPyBeginAllowThreads();
34389 delete arg1;
34390
34391 wxPyEndAllowThreads(__tstate);
34392 if (PyErr_Occurred()) SWIG_fail;
34393 }
34394 resultobj = SWIG_Py_Void();
34395 return resultobj;
34396 fail:
34397 return NULL;
34398 }
34399
34400
34401 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34402 PyObject *resultobj = 0;
34403 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34404 bool result;
34405 void *argp1 = 0 ;
34406 int res1 = 0 ;
34407 PyObject *swig_obj[1] ;
34408
34409 if (!args) SWIG_fail;
34410 swig_obj[0] = args;
34411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34412 if (!SWIG_IsOK(res1)) {
34413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34414 }
34415 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34416 {
34417 PyThreadState* __tstate = wxPyBeginAllowThreads();
34418 result = (bool)wxClipboardLocker___nonzero__(arg1);
34419 wxPyEndAllowThreads(__tstate);
34420 if (PyErr_Occurred()) SWIG_fail;
34421 }
34422 {
34423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34424 }
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *obj;
34433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34434 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34435 return SWIG_Py_Void();
34436 }
34437
34438 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34439 return SWIG_Python_InitShadowInstance(args);
34440 }
34441
34442 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34443 PyObject *resultobj = 0;
34444 int arg1 = (int) 0 ;
34445 int arg2 = (int) 0 ;
34446 int arg3 = (int) 0 ;
34447 int arg4 = (int) 0 ;
34448 wxVideoMode *result = 0 ;
34449 int val1 ;
34450 int ecode1 = 0 ;
34451 int val2 ;
34452 int ecode2 = 0 ;
34453 int val3 ;
34454 int ecode3 = 0 ;
34455 int val4 ;
34456 int ecode4 = 0 ;
34457 PyObject * obj0 = 0 ;
34458 PyObject * obj1 = 0 ;
34459 PyObject * obj2 = 0 ;
34460 PyObject * obj3 = 0 ;
34461 char * kwnames[] = {
34462 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34463 };
34464
34465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34466 if (obj0) {
34467 ecode1 = SWIG_AsVal_int(obj0, &val1);
34468 if (!SWIG_IsOK(ecode1)) {
34469 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34470 }
34471 arg1 = static_cast< int >(val1);
34472 }
34473 if (obj1) {
34474 ecode2 = SWIG_AsVal_int(obj1, &val2);
34475 if (!SWIG_IsOK(ecode2)) {
34476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34477 }
34478 arg2 = static_cast< int >(val2);
34479 }
34480 if (obj2) {
34481 ecode3 = SWIG_AsVal_int(obj2, &val3);
34482 if (!SWIG_IsOK(ecode3)) {
34483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34484 }
34485 arg3 = static_cast< int >(val3);
34486 }
34487 if (obj3) {
34488 ecode4 = SWIG_AsVal_int(obj3, &val4);
34489 if (!SWIG_IsOK(ecode4)) {
34490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34491 }
34492 arg4 = static_cast< int >(val4);
34493 }
34494 {
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34497 wxPyEndAllowThreads(__tstate);
34498 if (PyErr_Occurred()) SWIG_fail;
34499 }
34500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34501 return resultobj;
34502 fail:
34503 return NULL;
34504 }
34505
34506
34507 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34508 PyObject *resultobj = 0;
34509 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34510 void *argp1 = 0 ;
34511 int res1 = 0 ;
34512 PyObject *swig_obj[1] ;
34513
34514 if (!args) SWIG_fail;
34515 swig_obj[0] = args;
34516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34517 if (!SWIG_IsOK(res1)) {
34518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34519 }
34520 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34521 {
34522 PyThreadState* __tstate = wxPyBeginAllowThreads();
34523 delete arg1;
34524
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 resultobj = SWIG_Py_Void();
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34536 PyObject *resultobj = 0;
34537 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34538 wxVideoMode *arg2 = 0 ;
34539 bool result;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 void *argp2 = 0 ;
34543 int res2 = 0 ;
34544 PyObject * obj0 = 0 ;
34545 PyObject * obj1 = 0 ;
34546 char * kwnames[] = {
34547 (char *) "self",(char *) "other", NULL
34548 };
34549
34550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34552 if (!SWIG_IsOK(res1)) {
34553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34554 }
34555 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34556 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34557 if (!SWIG_IsOK(res2)) {
34558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34559 }
34560 if (!argp2) {
34561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34562 }
34563 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34564 {
34565 PyThreadState* __tstate = wxPyBeginAllowThreads();
34566 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34567 wxPyEndAllowThreads(__tstate);
34568 if (PyErr_Occurred()) SWIG_fail;
34569 }
34570 {
34571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34572 }
34573 return resultobj;
34574 fail:
34575 return NULL;
34576 }
34577
34578
34579 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34580 PyObject *resultobj = 0;
34581 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34582 int result;
34583 void *argp1 = 0 ;
34584 int res1 = 0 ;
34585 PyObject *swig_obj[1] ;
34586
34587 if (!args) SWIG_fail;
34588 swig_obj[0] = args;
34589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34590 if (!SWIG_IsOK(res1)) {
34591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34592 }
34593 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34597 wxPyEndAllowThreads(__tstate);
34598 if (PyErr_Occurred()) SWIG_fail;
34599 }
34600 resultobj = SWIG_From_int(static_cast< int >(result));
34601 return resultobj;
34602 fail:
34603 return NULL;
34604 }
34605
34606
34607 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34608 PyObject *resultobj = 0;
34609 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34610 int result;
34611 void *argp1 = 0 ;
34612 int res1 = 0 ;
34613 PyObject *swig_obj[1] ;
34614
34615 if (!args) SWIG_fail;
34616 swig_obj[0] = args;
34617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34618 if (!SWIG_IsOK(res1)) {
34619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34620 }
34621 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34625 wxPyEndAllowThreads(__tstate);
34626 if (PyErr_Occurred()) SWIG_fail;
34627 }
34628 resultobj = SWIG_From_int(static_cast< int >(result));
34629 return resultobj;
34630 fail:
34631 return NULL;
34632 }
34633
34634
34635 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34636 PyObject *resultobj = 0;
34637 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34638 int result;
34639 void *argp1 = 0 ;
34640 int res1 = 0 ;
34641 PyObject *swig_obj[1] ;
34642
34643 if (!args) SWIG_fail;
34644 swig_obj[0] = args;
34645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34646 if (!SWIG_IsOK(res1)) {
34647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34648 }
34649 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34653 wxPyEndAllowThreads(__tstate);
34654 if (PyErr_Occurred()) SWIG_fail;
34655 }
34656 resultobj = SWIG_From_int(static_cast< int >(result));
34657 return resultobj;
34658 fail:
34659 return NULL;
34660 }
34661
34662
34663 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34664 PyObject *resultobj = 0;
34665 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34666 bool result;
34667 void *argp1 = 0 ;
34668 int res1 = 0 ;
34669 PyObject *swig_obj[1] ;
34670
34671 if (!args) SWIG_fail;
34672 swig_obj[0] = args;
34673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34674 if (!SWIG_IsOK(res1)) {
34675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34676 }
34677 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34678 {
34679 PyThreadState* __tstate = wxPyBeginAllowThreads();
34680 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34681 wxPyEndAllowThreads(__tstate);
34682 if (PyErr_Occurred()) SWIG_fail;
34683 }
34684 {
34685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34686 }
34687 return resultobj;
34688 fail:
34689 return NULL;
34690 }
34691
34692
34693 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34694 PyObject *resultobj = 0;
34695 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34696 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34697 bool result;
34698 void *argp1 = 0 ;
34699 int res1 = 0 ;
34700 void *argp2 = 0 ;
34701 int res2 = 0 ;
34702 PyObject * obj0 = 0 ;
34703 PyObject * obj1 = 0 ;
34704 char * kwnames[] = {
34705 (char *) "self",(char *) "other", NULL
34706 };
34707
34708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34710 if (!SWIG_IsOK(res1)) {
34711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34712 }
34713 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34715 if (!SWIG_IsOK(res2)) {
34716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34717 }
34718 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34719 {
34720 PyThreadState* __tstate = wxPyBeginAllowThreads();
34721 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34722 wxPyEndAllowThreads(__tstate);
34723 if (PyErr_Occurred()) SWIG_fail;
34724 }
34725 {
34726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34727 }
34728 return resultobj;
34729 fail:
34730 return NULL;
34731 }
34732
34733
34734 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34735 PyObject *resultobj = 0;
34736 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34737 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34738 bool result;
34739 void *argp1 = 0 ;
34740 int res1 = 0 ;
34741 void *argp2 = 0 ;
34742 int res2 = 0 ;
34743 PyObject * obj0 = 0 ;
34744 PyObject * obj1 = 0 ;
34745 char * kwnames[] = {
34746 (char *) "self",(char *) "other", NULL
34747 };
34748
34749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34751 if (!SWIG_IsOK(res1)) {
34752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34753 }
34754 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34756 if (!SWIG_IsOK(res2)) {
34757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34758 }
34759 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34760 {
34761 PyThreadState* __tstate = wxPyBeginAllowThreads();
34762 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34763 wxPyEndAllowThreads(__tstate);
34764 if (PyErr_Occurred()) SWIG_fail;
34765 }
34766 {
34767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34768 }
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34776 PyObject *resultobj = 0;
34777 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34778 int arg2 ;
34779 void *argp1 = 0 ;
34780 int res1 = 0 ;
34781 int val2 ;
34782 int ecode2 = 0 ;
34783 PyObject *swig_obj[2] ;
34784
34785 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34787 if (!SWIG_IsOK(res1)) {
34788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34789 }
34790 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34791 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34792 if (!SWIG_IsOK(ecode2)) {
34793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34794 }
34795 arg2 = static_cast< int >(val2);
34796 if (arg1) (arg1)->w = arg2;
34797
34798 resultobj = SWIG_Py_Void();
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34806 PyObject *resultobj = 0;
34807 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34808 int result;
34809 void *argp1 = 0 ;
34810 int res1 = 0 ;
34811 PyObject *swig_obj[1] ;
34812
34813 if (!args) SWIG_fail;
34814 swig_obj[0] = args;
34815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34816 if (!SWIG_IsOK(res1)) {
34817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34818 }
34819 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34820 result = (int) ((arg1)->w);
34821 resultobj = SWIG_From_int(static_cast< int >(result));
34822 return resultobj;
34823 fail:
34824 return NULL;
34825 }
34826
34827
34828 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34829 PyObject *resultobj = 0;
34830 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34831 int arg2 ;
34832 void *argp1 = 0 ;
34833 int res1 = 0 ;
34834 int val2 ;
34835 int ecode2 = 0 ;
34836 PyObject *swig_obj[2] ;
34837
34838 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34840 if (!SWIG_IsOK(res1)) {
34841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34842 }
34843 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34844 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34845 if (!SWIG_IsOK(ecode2)) {
34846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34847 }
34848 arg2 = static_cast< int >(val2);
34849 if (arg1) (arg1)->h = arg2;
34850
34851 resultobj = SWIG_Py_Void();
34852 return resultobj;
34853 fail:
34854 return NULL;
34855 }
34856
34857
34858 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34859 PyObject *resultobj = 0;
34860 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34861 int result;
34862 void *argp1 = 0 ;
34863 int res1 = 0 ;
34864 PyObject *swig_obj[1] ;
34865
34866 if (!args) SWIG_fail;
34867 swig_obj[0] = args;
34868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34869 if (!SWIG_IsOK(res1)) {
34870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34871 }
34872 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34873 result = (int) ((arg1)->h);
34874 resultobj = SWIG_From_int(static_cast< int >(result));
34875 return resultobj;
34876 fail:
34877 return NULL;
34878 }
34879
34880
34881 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34882 PyObject *resultobj = 0;
34883 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34884 int arg2 ;
34885 void *argp1 = 0 ;
34886 int res1 = 0 ;
34887 int val2 ;
34888 int ecode2 = 0 ;
34889 PyObject *swig_obj[2] ;
34890
34891 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34893 if (!SWIG_IsOK(res1)) {
34894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34895 }
34896 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34897 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34898 if (!SWIG_IsOK(ecode2)) {
34899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34900 }
34901 arg2 = static_cast< int >(val2);
34902 if (arg1) (arg1)->bpp = arg2;
34903
34904 resultobj = SWIG_Py_Void();
34905 return resultobj;
34906 fail:
34907 return NULL;
34908 }
34909
34910
34911 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34912 PyObject *resultobj = 0;
34913 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34914 int result;
34915 void *argp1 = 0 ;
34916 int res1 = 0 ;
34917 PyObject *swig_obj[1] ;
34918
34919 if (!args) SWIG_fail;
34920 swig_obj[0] = args;
34921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34922 if (!SWIG_IsOK(res1)) {
34923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34924 }
34925 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34926 result = (int) ((arg1)->bpp);
34927 resultobj = SWIG_From_int(static_cast< int >(result));
34928 return resultobj;
34929 fail:
34930 return NULL;
34931 }
34932
34933
34934 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34935 PyObject *resultobj = 0;
34936 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34937 int arg2 ;
34938 void *argp1 = 0 ;
34939 int res1 = 0 ;
34940 int val2 ;
34941 int ecode2 = 0 ;
34942 PyObject *swig_obj[2] ;
34943
34944 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
34945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34946 if (!SWIG_IsOK(res1)) {
34947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34948 }
34949 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34950 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34951 if (!SWIG_IsOK(ecode2)) {
34952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34953 }
34954 arg2 = static_cast< int >(val2);
34955 if (arg1) (arg1)->refresh = arg2;
34956
34957 resultobj = SWIG_Py_Void();
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34965 PyObject *resultobj = 0;
34966 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34967 int result;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 PyObject *swig_obj[1] ;
34971
34972 if (!args) SWIG_fail;
34973 swig_obj[0] = args;
34974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34975 if (!SWIG_IsOK(res1)) {
34976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34977 }
34978 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34979 result = (int) ((arg1)->refresh);
34980 resultobj = SWIG_From_int(static_cast< int >(result));
34981 return resultobj;
34982 fail:
34983 return NULL;
34984 }
34985
34986
34987 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34988 PyObject *obj;
34989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34990 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
34991 return SWIG_Py_Void();
34992 }
34993
34994 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34995 return SWIG_Python_InitShadowInstance(args);
34996 }
34997
34998 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
34999 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35000 return 1;
35001 }
35002
35003
35004 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35005 PyObject *pyobj = 0;
35006
35007 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35008 return pyobj;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35013 PyObject *resultobj = 0;
35014 size_t arg1 = (size_t) 0 ;
35015 wxDisplay *result = 0 ;
35016 size_t val1 ;
35017 int ecode1 = 0 ;
35018 PyObject * obj0 = 0 ;
35019 char * kwnames[] = {
35020 (char *) "index", NULL
35021 };
35022
35023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35024 if (obj0) {
35025 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35026 if (!SWIG_IsOK(ecode1)) {
35027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35028 }
35029 arg1 = static_cast< size_t >(val1);
35030 }
35031 {
35032 PyThreadState* __tstate = wxPyBeginAllowThreads();
35033 result = (wxDisplay *)new wxDisplay(arg1);
35034 wxPyEndAllowThreads(__tstate);
35035 if (PyErr_Occurred()) SWIG_fail;
35036 }
35037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35038 return resultobj;
35039 fail:
35040 return NULL;
35041 }
35042
35043
35044 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35045 PyObject *resultobj = 0;
35046 wxDisplay *arg1 = (wxDisplay *) 0 ;
35047 void *argp1 = 0 ;
35048 int res1 = 0 ;
35049 PyObject *swig_obj[1] ;
35050
35051 if (!args) SWIG_fail;
35052 swig_obj[0] = args;
35053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35054 if (!SWIG_IsOK(res1)) {
35055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35056 }
35057 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35058 {
35059 PyThreadState* __tstate = wxPyBeginAllowThreads();
35060 delete arg1;
35061
35062 wxPyEndAllowThreads(__tstate);
35063 if (PyErr_Occurred()) SWIG_fail;
35064 }
35065 resultobj = SWIG_Py_Void();
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35073 PyObject *resultobj = 0;
35074 size_t result;
35075
35076 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35077 {
35078 PyThreadState* __tstate = wxPyBeginAllowThreads();
35079 result = (size_t)wxDisplay::GetCount();
35080 wxPyEndAllowThreads(__tstate);
35081 if (PyErr_Occurred()) SWIG_fail;
35082 }
35083 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35084 return resultobj;
35085 fail:
35086 return NULL;
35087 }
35088
35089
35090 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35091 PyObject *resultobj = 0;
35092 wxPoint *arg1 = 0 ;
35093 int result;
35094 wxPoint temp1 ;
35095 PyObject * obj0 = 0 ;
35096 char * kwnames[] = {
35097 (char *) "pt", NULL
35098 };
35099
35100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35101 {
35102 arg1 = &temp1;
35103 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35104 }
35105 {
35106 PyThreadState* __tstate = wxPyBeginAllowThreads();
35107 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35108 wxPyEndAllowThreads(__tstate);
35109 if (PyErr_Occurred()) SWIG_fail;
35110 }
35111 resultobj = SWIG_From_int(static_cast< int >(result));
35112 return resultobj;
35113 fail:
35114 return NULL;
35115 }
35116
35117
35118 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35119 PyObject *resultobj = 0;
35120 wxWindow *arg1 = (wxWindow *) 0 ;
35121 int result;
35122 void *argp1 = 0 ;
35123 int res1 = 0 ;
35124 PyObject * obj0 = 0 ;
35125 char * kwnames[] = {
35126 (char *) "window", NULL
35127 };
35128
35129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35131 if (!SWIG_IsOK(res1)) {
35132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35133 }
35134 arg1 = reinterpret_cast< wxWindow * >(argp1);
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 result = (int)wxDisplay::GetFromWindow(arg1);
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 resultobj = SWIG_From_int(static_cast< int >(result));
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35149 PyObject *resultobj = 0;
35150 wxDisplay *arg1 = (wxDisplay *) 0 ;
35151 bool result;
35152 void *argp1 = 0 ;
35153 int res1 = 0 ;
35154 PyObject *swig_obj[1] ;
35155
35156 if (!args) SWIG_fail;
35157 swig_obj[0] = args;
35158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35159 if (!SWIG_IsOK(res1)) {
35160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35161 }
35162 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35163 {
35164 PyThreadState* __tstate = wxPyBeginAllowThreads();
35165 result = (bool)((wxDisplay const *)arg1)->IsOk();
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 {
35170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35171 }
35172 return resultobj;
35173 fail:
35174 return NULL;
35175 }
35176
35177
35178 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35179 PyObject *resultobj = 0;
35180 wxDisplay *arg1 = (wxDisplay *) 0 ;
35181 wxRect result;
35182 void *argp1 = 0 ;
35183 int res1 = 0 ;
35184 PyObject *swig_obj[1] ;
35185
35186 if (!args) SWIG_fail;
35187 swig_obj[0] = args;
35188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35189 if (!SWIG_IsOK(res1)) {
35190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35191 }
35192 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35193 {
35194 PyThreadState* __tstate = wxPyBeginAllowThreads();
35195 result = ((wxDisplay const *)arg1)->GetGeometry();
35196 wxPyEndAllowThreads(__tstate);
35197 if (PyErr_Occurred()) SWIG_fail;
35198 }
35199 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35200 return resultobj;
35201 fail:
35202 return NULL;
35203 }
35204
35205
35206 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35207 PyObject *resultobj = 0;
35208 wxDisplay *arg1 = (wxDisplay *) 0 ;
35209 wxRect result;
35210 void *argp1 = 0 ;
35211 int res1 = 0 ;
35212 PyObject *swig_obj[1] ;
35213
35214 if (!args) SWIG_fail;
35215 swig_obj[0] = args;
35216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35217 if (!SWIG_IsOK(res1)) {
35218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35219 }
35220 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35221 {
35222 PyThreadState* __tstate = wxPyBeginAllowThreads();
35223 result = ((wxDisplay const *)arg1)->GetClientArea();
35224 wxPyEndAllowThreads(__tstate);
35225 if (PyErr_Occurred()) SWIG_fail;
35226 }
35227 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35228 return resultobj;
35229 fail:
35230 return NULL;
35231 }
35232
35233
35234 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35235 PyObject *resultobj = 0;
35236 wxDisplay *arg1 = (wxDisplay *) 0 ;
35237 wxString result;
35238 void *argp1 = 0 ;
35239 int res1 = 0 ;
35240 PyObject *swig_obj[1] ;
35241
35242 if (!args) SWIG_fail;
35243 swig_obj[0] = args;
35244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35245 if (!SWIG_IsOK(res1)) {
35246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35247 }
35248 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35249 {
35250 PyThreadState* __tstate = wxPyBeginAllowThreads();
35251 result = ((wxDisplay const *)arg1)->GetName();
35252 wxPyEndAllowThreads(__tstate);
35253 if (PyErr_Occurred()) SWIG_fail;
35254 }
35255 {
35256 #if wxUSE_UNICODE
35257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35258 #else
35259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35260 #endif
35261 }
35262 return resultobj;
35263 fail:
35264 return NULL;
35265 }
35266
35267
35268 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35269 PyObject *resultobj = 0;
35270 wxDisplay *arg1 = (wxDisplay *) 0 ;
35271 bool result;
35272 void *argp1 = 0 ;
35273 int res1 = 0 ;
35274 PyObject *swig_obj[1] ;
35275
35276 if (!args) SWIG_fail;
35277 swig_obj[0] = args;
35278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35279 if (!SWIG_IsOK(res1)) {
35280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35281 }
35282 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35286 wxPyEndAllowThreads(__tstate);
35287 if (PyErr_Occurred()) SWIG_fail;
35288 }
35289 {
35290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35291 }
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj = 0;
35300 wxDisplay *arg1 = (wxDisplay *) 0 ;
35301 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35302 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35303 PyObject *result = 0 ;
35304 void *argp1 = 0 ;
35305 int res1 = 0 ;
35306 void *argp2 = 0 ;
35307 int res2 = 0 ;
35308 PyObject * obj0 = 0 ;
35309 PyObject * obj1 = 0 ;
35310 char * kwnames[] = {
35311 (char *) "self",(char *) "mode", NULL
35312 };
35313
35314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35316 if (!SWIG_IsOK(res1)) {
35317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35318 }
35319 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35320 if (obj1) {
35321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35322 if (!SWIG_IsOK(res2)) {
35323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35324 }
35325 if (!argp2) {
35326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35327 }
35328 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35329 }
35330 {
35331 PyThreadState* __tstate = wxPyBeginAllowThreads();
35332 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 resultobj = result;
35337 return resultobj;
35338 fail:
35339 return NULL;
35340 }
35341
35342
35343 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35344 PyObject *resultobj = 0;
35345 wxDisplay *arg1 = (wxDisplay *) 0 ;
35346 wxVideoMode result;
35347 void *argp1 = 0 ;
35348 int res1 = 0 ;
35349 PyObject *swig_obj[1] ;
35350
35351 if (!args) SWIG_fail;
35352 swig_obj[0] = args;
35353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35354 if (!SWIG_IsOK(res1)) {
35355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35356 }
35357 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35365 return resultobj;
35366 fail:
35367 return NULL;
35368 }
35369
35370
35371 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35372 PyObject *resultobj = 0;
35373 wxDisplay *arg1 = (wxDisplay *) 0 ;
35374 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35375 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35376 bool result;
35377 void *argp1 = 0 ;
35378 int res1 = 0 ;
35379 void *argp2 = 0 ;
35380 int res2 = 0 ;
35381 PyObject * obj0 = 0 ;
35382 PyObject * obj1 = 0 ;
35383 char * kwnames[] = {
35384 (char *) "self",(char *) "mode", NULL
35385 };
35386
35387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35389 if (!SWIG_IsOK(res1)) {
35390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35391 }
35392 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35393 if (obj1) {
35394 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35395 if (!SWIG_IsOK(res2)) {
35396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35397 }
35398 if (!argp2) {
35399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35400 }
35401 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35402 }
35403 {
35404 PyThreadState* __tstate = wxPyBeginAllowThreads();
35405 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35406 wxPyEndAllowThreads(__tstate);
35407 if (PyErr_Occurred()) SWIG_fail;
35408 }
35409 {
35410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35411 }
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35419 PyObject *resultobj = 0;
35420 wxDisplay *arg1 = (wxDisplay *) 0 ;
35421 void *argp1 = 0 ;
35422 int res1 = 0 ;
35423 PyObject *swig_obj[1] ;
35424
35425 if (!args) SWIG_fail;
35426 swig_obj[0] = args;
35427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35430 }
35431 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35432 {
35433 PyThreadState* __tstate = wxPyBeginAllowThreads();
35434 wxDisplay_ResetMode(arg1);
35435 wxPyEndAllowThreads(__tstate);
35436 if (PyErr_Occurred()) SWIG_fail;
35437 }
35438 resultobj = SWIG_Py_Void();
35439 return resultobj;
35440 fail:
35441 return NULL;
35442 }
35443
35444
35445 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35446 PyObject *obj;
35447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35448 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35449 return SWIG_Py_Void();
35450 }
35451
35452 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35453 return SWIG_Python_InitShadowInstance(args);
35454 }
35455
35456 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35457 PyObject *resultobj = 0;
35458 wxStandardPaths *result = 0 ;
35459
35460 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35461 {
35462 PyThreadState* __tstate = wxPyBeginAllowThreads();
35463 result = (wxStandardPaths *)wxStandardPaths_Get();
35464 wxPyEndAllowThreads(__tstate);
35465 if (PyErr_Occurred()) SWIG_fail;
35466 }
35467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35468 return resultobj;
35469 fail:
35470 return NULL;
35471 }
35472
35473
35474 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35475 PyObject *resultobj = 0;
35476 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35477 wxString result;
35478 void *argp1 = 0 ;
35479 int res1 = 0 ;
35480 PyObject *swig_obj[1] ;
35481
35482 if (!args) SWIG_fail;
35483 swig_obj[0] = args;
35484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35485 if (!SWIG_IsOK(res1)) {
35486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35487 }
35488 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35489 {
35490 PyThreadState* __tstate = wxPyBeginAllowThreads();
35491 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35492 wxPyEndAllowThreads(__tstate);
35493 if (PyErr_Occurred()) SWIG_fail;
35494 }
35495 {
35496 #if wxUSE_UNICODE
35497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35498 #else
35499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35500 #endif
35501 }
35502 return resultobj;
35503 fail:
35504 return NULL;
35505 }
35506
35507
35508 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35509 PyObject *resultobj = 0;
35510 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35511 wxString result;
35512 void *argp1 = 0 ;
35513 int res1 = 0 ;
35514 PyObject *swig_obj[1] ;
35515
35516 if (!args) SWIG_fail;
35517 swig_obj[0] = args;
35518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35519 if (!SWIG_IsOK(res1)) {
35520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35521 }
35522 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35523 {
35524 PyThreadState* __tstate = wxPyBeginAllowThreads();
35525 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35526 wxPyEndAllowThreads(__tstate);
35527 if (PyErr_Occurred()) SWIG_fail;
35528 }
35529 {
35530 #if wxUSE_UNICODE
35531 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35532 #else
35533 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35534 #endif
35535 }
35536 return resultobj;
35537 fail:
35538 return NULL;
35539 }
35540
35541
35542 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35543 PyObject *resultobj = 0;
35544 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35545 wxString result;
35546 void *argp1 = 0 ;
35547 int res1 = 0 ;
35548 PyObject *swig_obj[1] ;
35549
35550 if (!args) SWIG_fail;
35551 swig_obj[0] = args;
35552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35553 if (!SWIG_IsOK(res1)) {
35554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35555 }
35556 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35557 {
35558 PyThreadState* __tstate = wxPyBeginAllowThreads();
35559 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35560 wxPyEndAllowThreads(__tstate);
35561 if (PyErr_Occurred()) SWIG_fail;
35562 }
35563 {
35564 #if wxUSE_UNICODE
35565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35566 #else
35567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35568 #endif
35569 }
35570 return resultobj;
35571 fail:
35572 return NULL;
35573 }
35574
35575
35576 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35577 PyObject *resultobj = 0;
35578 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35579 wxString result;
35580 void *argp1 = 0 ;
35581 int res1 = 0 ;
35582 PyObject *swig_obj[1] ;
35583
35584 if (!args) SWIG_fail;
35585 swig_obj[0] = args;
35586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35587 if (!SWIG_IsOK(res1)) {
35588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35589 }
35590 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35591 {
35592 PyThreadState* __tstate = wxPyBeginAllowThreads();
35593 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 {
35598 #if wxUSE_UNICODE
35599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35600 #else
35601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35602 #endif
35603 }
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35611 PyObject *resultobj = 0;
35612 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35613 wxString result;
35614 void *argp1 = 0 ;
35615 int res1 = 0 ;
35616 PyObject *swig_obj[1] ;
35617
35618 if (!args) SWIG_fail;
35619 swig_obj[0] = args;
35620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35621 if (!SWIG_IsOK(res1)) {
35622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35623 }
35624 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35625 {
35626 PyThreadState* __tstate = wxPyBeginAllowThreads();
35627 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 {
35632 #if wxUSE_UNICODE
35633 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35634 #else
35635 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35636 #endif
35637 }
35638 return resultobj;
35639 fail:
35640 return NULL;
35641 }
35642
35643
35644 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35645 PyObject *resultobj = 0;
35646 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35647 wxString result;
35648 void *argp1 = 0 ;
35649 int res1 = 0 ;
35650 PyObject *swig_obj[1] ;
35651
35652 if (!args) SWIG_fail;
35653 swig_obj[0] = args;
35654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35657 }
35658 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35659 {
35660 PyThreadState* __tstate = wxPyBeginAllowThreads();
35661 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 {
35666 #if wxUSE_UNICODE
35667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35668 #else
35669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35670 #endif
35671 }
35672 return resultobj;
35673 fail:
35674 return NULL;
35675 }
35676
35677
35678 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35679 PyObject *resultobj = 0;
35680 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35681 wxString result;
35682 void *argp1 = 0 ;
35683 int res1 = 0 ;
35684 PyObject *swig_obj[1] ;
35685
35686 if (!args) SWIG_fail;
35687 swig_obj[0] = args;
35688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35689 if (!SWIG_IsOK(res1)) {
35690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35691 }
35692 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35693 {
35694 PyThreadState* __tstate = wxPyBeginAllowThreads();
35695 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35696 wxPyEndAllowThreads(__tstate);
35697 if (PyErr_Occurred()) SWIG_fail;
35698 }
35699 {
35700 #if wxUSE_UNICODE
35701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35702 #else
35703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35704 #endif
35705 }
35706 return resultobj;
35707 fail:
35708 return NULL;
35709 }
35710
35711
35712 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35713 PyObject *resultobj = 0;
35714 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35715 wxString result;
35716 void *argp1 = 0 ;
35717 int res1 = 0 ;
35718 PyObject *swig_obj[1] ;
35719
35720 if (!args) SWIG_fail;
35721 swig_obj[0] = args;
35722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35723 if (!SWIG_IsOK(res1)) {
35724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35725 }
35726 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35727 {
35728 PyThreadState* __tstate = wxPyBeginAllowThreads();
35729 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35730 wxPyEndAllowThreads(__tstate);
35731 if (PyErr_Occurred()) SWIG_fail;
35732 }
35733 {
35734 #if wxUSE_UNICODE
35735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35736 #else
35737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35738 #endif
35739 }
35740 return resultobj;
35741 fail:
35742 return NULL;
35743 }
35744
35745
35746 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35747 PyObject *resultobj = 0;
35748 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35749 wxString *arg2 = 0 ;
35750 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35751 wxString result;
35752 void *argp1 = 0 ;
35753 int res1 = 0 ;
35754 bool temp2 = false ;
35755 int val3 ;
35756 int ecode3 = 0 ;
35757 PyObject * obj0 = 0 ;
35758 PyObject * obj1 = 0 ;
35759 PyObject * obj2 = 0 ;
35760 char * kwnames[] = {
35761 (char *) "self",(char *) "lang",(char *) "category", NULL
35762 };
35763
35764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35766 if (!SWIG_IsOK(res1)) {
35767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35768 }
35769 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35770 {
35771 arg2 = wxString_in_helper(obj1);
35772 if (arg2 == NULL) SWIG_fail;
35773 temp2 = true;
35774 }
35775 if (obj2) {
35776 ecode3 = SWIG_AsVal_int(obj2, &val3);
35777 if (!SWIG_IsOK(ecode3)) {
35778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35779 }
35780 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35781 }
35782 {
35783 PyThreadState* __tstate = wxPyBeginAllowThreads();
35784 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35785 wxPyEndAllowThreads(__tstate);
35786 if (PyErr_Occurred()) SWIG_fail;
35787 }
35788 {
35789 #if wxUSE_UNICODE
35790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35791 #else
35792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35793 #endif
35794 }
35795 {
35796 if (temp2)
35797 delete arg2;
35798 }
35799 return resultobj;
35800 fail:
35801 {
35802 if (temp2)
35803 delete arg2;
35804 }
35805 return NULL;
35806 }
35807
35808
35809 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35810 PyObject *resultobj = 0;
35811 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35812 wxString result;
35813 void *argp1 = 0 ;
35814 int res1 = 0 ;
35815 PyObject *swig_obj[1] ;
35816
35817 if (!args) SWIG_fail;
35818 swig_obj[0] = args;
35819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35820 if (!SWIG_IsOK(res1)) {
35821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35822 }
35823 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35824 {
35825 PyThreadState* __tstate = wxPyBeginAllowThreads();
35826 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35827 wxPyEndAllowThreads(__tstate);
35828 if (PyErr_Occurred()) SWIG_fail;
35829 }
35830 {
35831 #if wxUSE_UNICODE
35832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35833 #else
35834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35835 #endif
35836 }
35837 return resultobj;
35838 fail:
35839 return NULL;
35840 }
35841
35842
35843 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35844 PyObject *resultobj = 0;
35845 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35846 wxString *arg2 = 0 ;
35847 void *argp1 = 0 ;
35848 int res1 = 0 ;
35849 bool temp2 = false ;
35850 PyObject * obj0 = 0 ;
35851 PyObject * obj1 = 0 ;
35852 char * kwnames[] = {
35853 (char *) "self",(char *) "prefix", NULL
35854 };
35855
35856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35858 if (!SWIG_IsOK(res1)) {
35859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35860 }
35861 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35862 {
35863 arg2 = wxString_in_helper(obj1);
35864 if (arg2 == NULL) SWIG_fail;
35865 temp2 = true;
35866 }
35867 {
35868 PyThreadState* __tstate = wxPyBeginAllowThreads();
35869 (arg1)->SetInstallPrefix((wxString const &)*arg2);
35870 wxPyEndAllowThreads(__tstate);
35871 if (PyErr_Occurred()) SWIG_fail;
35872 }
35873 resultobj = SWIG_Py_Void();
35874 {
35875 if (temp2)
35876 delete arg2;
35877 }
35878 return resultobj;
35879 fail:
35880 {
35881 if (temp2)
35882 delete arg2;
35883 }
35884 return NULL;
35885 }
35886
35887
35888 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35889 PyObject *resultobj = 0;
35890 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35891 wxString result;
35892 void *argp1 = 0 ;
35893 int res1 = 0 ;
35894 PyObject *swig_obj[1] ;
35895
35896 if (!args) SWIG_fail;
35897 swig_obj[0] = args;
35898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35899 if (!SWIG_IsOK(res1)) {
35900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35901 }
35902 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35903 {
35904 PyThreadState* __tstate = wxPyBeginAllowThreads();
35905 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
35906 wxPyEndAllowThreads(__tstate);
35907 if (PyErr_Occurred()) SWIG_fail;
35908 }
35909 {
35910 #if wxUSE_UNICODE
35911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35912 #else
35913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35914 #endif
35915 }
35916 return resultobj;
35917 fail:
35918 return NULL;
35919 }
35920
35921
35922 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35923 PyObject *obj;
35924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35925 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35926 return SWIG_Py_Void();
35927 }
35928
35929 static PyMethodDef SwigMethods[] = {
35930 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
35931 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35932 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
35933 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
35934 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
35935 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
35936 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
35937 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
35938 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35939 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35940 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35941 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35942 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
35943 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
35944 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
35945 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
35946 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
35947 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
35948 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
35949 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
35950 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35951 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35952 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
35953 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
35954 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
35955 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
35956 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
35957 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
35958 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
35959 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
35960 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
35961 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
35962 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
35963 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
35964 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35965 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35966 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
35967 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
35968 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
35969 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
35970 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
35971 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
35972 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
35973 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
35974 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
35975 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
35976 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
35977 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35978 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35979 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35980 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35981 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35982 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35983 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
35984 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35985 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
35986 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
35987 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
35988 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
35989 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
35990 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
35991 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
35992 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
35993 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
35994 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
35995 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35996 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
35997 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35998 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
35999 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36000 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36001 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36002 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36003 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36004 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36005 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36006 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36007 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36008 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36009 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36010 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36011 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36012 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36013 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36014 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36015 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36016 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36017 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36018 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36019 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36020 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36021 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36022 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36023 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36024 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36025 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36026 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36027 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36028 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36029 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36030 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36031 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36032 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36033 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36034 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36035 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36036 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36037 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36038 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36039 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36040 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36041 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36042 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36043 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36044 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36045 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36046 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36047 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36048 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36049 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36050 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36051 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36052 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36053 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36054 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36055 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36056 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36057 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36058 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36059 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36060 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36061 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36062 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36063 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36064 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36065 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36066 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36067 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36068 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36069 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36070 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36071 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36072 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36073 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36074 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36075 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36076 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36077 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36078 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36079 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36080 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36081 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36082 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36083 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36084 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36085 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36086 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36087 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36088 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36089 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36090 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36091 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36092 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36093 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36094 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36095 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36096 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36097 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36098 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36099 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36100 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36101 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36102 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36103 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36104 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36105 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36106 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36107 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36108 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36109 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36110 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36111 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36112 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36113 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36114 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36115 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36116 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36117 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36118 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36119 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36120 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36121 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36122 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36123 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36124 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36125 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36126 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36127 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36128 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36129 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36130 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36131 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36132 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36133 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36134 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36135 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36136 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36137 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36138 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36139 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36140 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36141 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36142 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36143 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36144 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36145 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36146 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36147 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36148 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36149 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36150 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36151 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36152 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36153 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36154 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36156 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36157 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36160 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36161 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36162 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36163 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36164 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36165 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36167 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36168 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36169 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36170 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36171 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36172 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36173 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36174 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36175 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36177 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36178 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36179 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36180 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36181 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36182 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36183 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36184 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36185 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36186 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36187 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36188 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36189 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36190 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36191 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36192 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36193 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36194 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36195 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36196 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36197 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36198 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36199 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36200 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36201 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36202 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36203 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36204 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36205 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36206 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36207 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36209 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36210 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36211 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36213 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36214 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36215 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36216 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36217 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36218 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36219 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36220 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36221 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36222 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36223 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36224 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36225 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36226 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36227 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36228 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36229 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36230 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36231 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36232 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36233 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36234 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36235 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36236 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36237 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36238 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36239 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36240 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36241 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36243 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36244 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36245 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36246 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36247 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36248 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36249 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36250 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36253 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36254 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36255 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36256 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36257 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36258 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36259 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36260 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36261 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36262 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36263 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36264 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36265 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36266 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36267 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36268 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36269 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36270 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36271 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36272 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36273 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36274 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36275 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36276 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36277 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36278 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36279 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36280 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36281 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36282 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36283 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36284 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36285 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36286 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36287 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36288 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36289 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36290 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36291 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36292 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36293 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36294 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36295 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36296 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36297 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36298 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36300 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36301 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36302 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36303 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36304 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36309 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36310 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36311 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36312 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36316 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36317 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36320 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36323 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36326 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36327 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36328 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36331 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36332 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36334 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36335 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36336 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36337 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36338 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36339 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36340 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36341 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36342 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36343 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36344 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36345 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36347 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36348 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36349 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36350 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36351 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36352 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36353 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36354 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36357 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36358 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36359 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36361 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36362 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36364 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36366 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36371 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36375 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36376 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36377 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36378 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36379 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36382 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36386 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36387 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36388 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36389 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36390 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36392 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36393 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36394 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36396 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36397 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36398 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36399 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36402 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36410 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36411 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36412 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36413 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36414 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36419 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36420 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36422 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36424 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36425 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36426 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36427 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36431 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36432 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36434 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36435 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36436 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36437 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36438 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36439 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36440 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36442 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36443 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36444 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36445 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36447 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36448 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36449 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36450 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36451 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36453 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36454 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36455 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36458 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36459 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36463 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36464 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36465 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36466 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36468 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36472 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36473 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36478 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36479 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36480 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36481 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36483 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36495 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36496 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36500 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36501 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36502 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36503 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36504 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36505 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36506 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36507 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36508 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36510 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36511 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36514 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36515 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36518 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36519 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36525 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36526 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36534 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36535 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36540 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36541 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36545 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36546 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36547 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36548 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36561 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36562 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36563 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36564 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36565 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36566 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36568 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36570 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36572 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36573 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36574 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36576 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36577 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36578 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36579 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36580 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36584 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36585 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36589 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36593 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36595 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36596 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36600 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36601 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36602 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36606 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36607 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36608 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36609 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36610 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36611 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36613 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36614 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36616 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36617 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36618 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36619 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36620 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36621 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36622 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36623 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36624 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36629 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36630 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36631 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36632 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36633 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36636 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36640 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36648 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36649 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36650 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36651 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36652 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36653 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36656 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36657 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36658 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36659 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36660 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36661 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36662 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36663 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36664 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36665 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36669 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36670 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36673 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36674 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36675 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36676 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36677 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36678 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36679 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36680 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36681 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36682 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36683 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36684 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36685 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36686 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36688 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36689 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36690 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36691 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36692 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36693 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36695 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36696 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36699 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36700 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36702 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36704 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36705 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36708 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36709 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36710 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36711 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36713 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36714 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36715 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36716 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36717 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36718 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36719 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36720 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36721 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36722 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36723 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36724 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36725 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36726 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36727 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36728 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36732 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36734 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36737 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36738 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36739 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36742 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36743 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36747 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36749 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36751 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36752 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36753 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36754 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36759 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36762 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36763 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36764 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36765 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36769 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36770 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36771 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36772 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36773 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36774 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36775 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36776 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36777 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36778 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36781 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36782 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36783 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36784 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36786 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36787 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36788 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36789 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36790 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36791 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36792 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36793 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36795 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36797 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36798 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36799 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36800 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36803 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36804 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36805 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36806 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36807 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36808 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36809 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36810 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36811 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36812 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36814 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36815 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36818 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36819 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36820 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36821 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36822 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36824 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36825 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36826 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36827 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36828 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36829 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36830 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36831 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36832 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36833 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36834 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36835 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36836 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
36837 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
36838 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
36839 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36841 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36842 { NULL, NULL, 0, NULL }
36843 };
36844
36845
36846 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
36847
36848 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
36849 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
36850 }
36851 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
36852 return (void *)((wxEvent *) ((wxMenuEvent *) x));
36853 }
36854 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
36855 return (void *)((wxEvent *) ((wxCloseEvent *) x));
36856 }
36857 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
36858 return (void *)((wxEvent *) ((wxMouseEvent *) x));
36859 }
36860 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
36861 return (void *)((wxEvent *) ((wxEraseEvent *) x));
36862 }
36863 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
36864 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
36865 }
36866 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
36867 return (void *)((wxEvent *) ((wxTimerEvent *) x));
36868 }
36869 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
36870 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
36871 }
36872 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
36873 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
36874 }
36875 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
36876 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
36877 }
36878 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
36879 return (void *)((wxEvent *) ((wxPyEvent *) x));
36880 }
36881 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
36882 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
36883 }
36884 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
36885 return (void *)((wxEvent *) ((wxIdleEvent *) x));
36886 }
36887 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
36888 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
36889 }
36890 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
36891 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
36892 }
36893 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
36894 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
36895 }
36896 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
36897 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
36898 }
36899 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
36900 return (void *)((wxEvent *) ((wxActivateEvent *) x));
36901 }
36902 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
36903 return (void *)((wxEvent *) ((wxSizeEvent *) x));
36904 }
36905 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
36906 return (void *)((wxEvent *) ((wxMoveEvent *) x));
36907 }
36908 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
36909 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
36910 }
36911 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
36912 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
36913 }
36914 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
36915 return (void *)((wxEvent *) ((wxPaintEvent *) x));
36916 }
36917 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
36918 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
36919 }
36920 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
36921 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
36922 }
36923 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
36924 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
36925 }
36926 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
36927 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
36928 }
36929 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
36930 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36931 }
36932 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
36933 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
36934 }
36935 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
36936 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
36937 }
36938 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
36939 return (void *)((wxEvent *) ((wxFocusEvent *) x));
36940 }
36941 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
36942 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
36943 }
36944 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
36945 return (void *)((wxEvent *) ((wxProcessEvent *) x));
36946 }
36947 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
36948 return (void *)((wxEvent *) ((wxShowEvent *) x));
36949 }
36950 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
36951 return (void *)((wxEvent *) ((wxCommandEvent *) x));
36952 }
36953 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
36954 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
36955 }
36956 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
36957 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
36958 }
36959 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
36960 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
36961 }
36962 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
36963 return (void *)((wxEvent *) ((wxKeyEvent *) x));
36964 }
36965 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
36966 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
36967 }
36968 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
36969 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
36970 }
36971 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
36972 return (void *)((wxConfigBase *) ((wxConfig *) x));
36973 }
36974 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
36975 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36976 }
36977 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
36978 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
36979 }
36980 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
36981 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
36982 }
36983 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
36984 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36985 }
36986 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
36987 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
36988 }
36989 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
36990 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
36991 }
36992 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
36993 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
36994 }
36995 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
36996 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36997 }
36998 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
36999 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37000 }
37001 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37002 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37003 }
37004 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37005 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37006 }
37007 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37008 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37009 }
37010 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37011 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37012 }
37013 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37014 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37015 }
37016 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37017 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37018 }
37019 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37020 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37021 }
37022 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37023 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37024 }
37025 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37026 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37027 }
37028 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37029 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37030 }
37031 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37032 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37033 }
37034 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37035 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37036 }
37037 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37038 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37039 }
37040 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37041 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37042 }
37043 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37044 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37045 }
37046 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37047 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37048 }
37049 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37050 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37051 }
37052 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37053 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37054 }
37055 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37056 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37057 }
37058 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37059 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37060 }
37061 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37062 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37063 }
37064 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37065 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37066 }
37067 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37068 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37069 }
37070 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37071 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37072 }
37073 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37074 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37075 }
37076 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37077 return (void *)((wxObject *) ((wxSizerItem *) x));
37078 }
37079 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37080 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37081 }
37082 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37083 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37084 }
37085 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37086 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37087 }
37088 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37089 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37090 }
37091 static void *_p_wxSizerTo_p_wxObject(void *x) {
37092 return (void *)((wxObject *) ((wxSizer *) x));
37093 }
37094 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37095 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37096 }
37097 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37098 return (void *)((wxObject *) ((wxFileHistory *) x));
37099 }
37100 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37101 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37102 }
37103 static void *_p_wxEventTo_p_wxObject(void *x) {
37104 return (void *)((wxObject *) ((wxEvent *) x));
37105 }
37106 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37107 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37108 }
37109 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37110 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37111 }
37112 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37113 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37114 }
37115 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37116 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37117 }
37118 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37119 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37120 }
37121 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37122 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37123 }
37124 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37125 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37126 }
37127 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37128 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37129 }
37130 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37131 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37132 }
37133 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37134 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37135 }
37136 static void *_p_wxControlTo_p_wxObject(void *x) {
37137 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37138 }
37139 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37140 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37141 }
37142 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37143 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37144 }
37145 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37146 return (void *)((wxObject *) ((wxFSFile *) x));
37147 }
37148 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37149 return (void *)((wxObject *) ((wxClipboard *) x));
37150 }
37151 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37152 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37153 }
37154 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37155 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37156 }
37157 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37158 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37159 }
37160 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37161 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37162 }
37163 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37164 return (void *)((wxObject *) ((wxToolTip *) x));
37165 }
37166 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37167 return (void *)((wxObject *) ((wxMenuItem *) x));
37168 }
37169 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37170 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37171 }
37172 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37173 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37174 }
37175 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37176 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37177 }
37178 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37179 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37180 }
37181 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37182 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37183 }
37184 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37185 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37186 }
37187 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37188 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37189 }
37190 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37191 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37192 }
37193 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37194 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37195 }
37196 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37197 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37198 }
37199 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37200 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37201 }
37202 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37203 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37204 }
37205 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37206 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37207 }
37208 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37209 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37210 }
37211 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37212 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37213 }
37214 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37215 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37216 }
37217 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37218 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37219 }
37220 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37221 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37222 }
37223 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37224 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37225 }
37226 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37227 return (void *)((wxObject *) ((wxImageHandler *) x));
37228 }
37229 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37230 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37231 }
37232 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37233 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37234 }
37235 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37236 return (void *)((wxObject *) ((wxEvtHandler *) x));
37237 }
37238 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37239 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37240 }
37241 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37242 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37243 }
37244 static void *_p_wxImageTo_p_wxObject(void *x) {
37245 return (void *)((wxObject *) ((wxImage *) x));
37246 }
37247 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37248 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37249 }
37250 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37251 return (void *)((wxObject *) ((wxSystemOptions *) x));
37252 }
37253 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37254 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37255 }
37256 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37257 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37258 }
37259 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37260 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37261 }
37262 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37263 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37264 }
37265 static void *_p_wxWindowTo_p_wxObject(void *x) {
37266 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37267 }
37268 static void *_p_wxMenuTo_p_wxObject(void *x) {
37269 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37270 }
37271 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37272 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37273 }
37274 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37275 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37276 }
37277 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37278 return (void *)((wxObject *) ((wxFileSystem *) x));
37279 }
37280 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37281 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37282 }
37283 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37284 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37285 }
37286 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37287 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37288 }
37289 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37290 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37291 }
37292 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37293 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37294 }
37295 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37296 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37297 }
37298 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37299 return (void *)((wxObject *) ((wxBusyInfo *) x));
37300 }
37301 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37302 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37303 }
37304 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37305 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37306 }
37307 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37308 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37309 }
37310 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37311 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37312 }
37313 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37314 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37315 }
37316 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37317 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37318 }
37319 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37320 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37321 }
37322 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37323 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37324 }
37325 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37326 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37327 }
37328 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37329 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37330 }
37331 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37332 return (void *)((wxLog *) ((wxLogBuffer *) x));
37333 }
37334 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37335 return (void *)((wxLog *) ((wxLogStderr *) x));
37336 }
37337 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37338 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37339 }
37340 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37341 return (void *)((wxLog *) ((wxLogWindow *) x));
37342 }
37343 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37344 return (void *)((wxLog *) ((wxLogChain *) x));
37345 }
37346 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37347 return (void *)((wxLog *) ((wxLogGui *) x));
37348 }
37349 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37350 return (void *)((wxLog *) ((wxPyLog *) x));
37351 }
37352 static void *_p_wxControlTo_p_wxWindow(void *x) {
37353 return (void *)((wxWindow *) ((wxControl *) x));
37354 }
37355 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37356 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37357 }
37358 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37359 return (void *)((wxWindow *) ((wxMenuBar *) x));
37360 }
37361 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37362 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37363 }
37364 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37365 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37366 }
37367 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37368 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};
37369 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37370 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37371 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37372 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37373 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37374 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37375 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37376 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37377 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37378 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37379 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37380 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37381 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37382 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37383 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37384 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37385 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37386 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37387 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37388 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37389 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37390 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37391 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37392 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37393 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37394 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37395 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37396 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37397 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37398 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37399 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37400 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37401 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37402 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37403 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37404 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37405 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37406 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37407 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37408 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37409 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37410 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37411 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37412 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37413 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37414 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37415 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37416 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37417 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37418 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37419 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37420 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37421 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37422 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37423 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37424 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37425 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37426 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37427 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37428 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37429 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37430 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37431 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37432 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37433 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37434 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37435 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37436 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37437 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37438 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37439 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37440 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37441 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37442 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37443 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37444 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37445 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37446 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37447 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37448 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37449 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37450 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37451 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37452 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37453 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37454 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37455 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37456 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37457 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37458 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37459 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37460 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37461 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37462 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37463 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37464 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37465 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37466 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37467 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37468 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37469 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37470 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37471 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37472 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37473 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37474 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37475 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37476 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37477 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37478 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37479 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37480 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37481 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37482 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37483 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37484 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37485 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37486 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37487 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37488 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37489 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37490 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37491 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37492 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37493 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37494 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37495 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37496 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37497 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37498 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37499 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37500 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37501 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37502 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37503 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37504 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37505 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37506 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37507 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37508 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37509 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37510 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37511 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37512 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37513 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37514 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37515 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37516 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37517 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37518 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37519 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37520 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37521 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37522 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37523 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37524 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37525 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37526 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37527 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37528 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37529 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37530 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37531 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37532 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37533 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37534 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37535 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37536 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37537
37538 static swig_type_info *swig_type_initial[] = {
37539 &_swigt__p_char,
37540 &_swigt__p_form_ops_t,
37541 &_swigt__p_int,
37542 &_swigt__p_unsigned_char,
37543 &_swigt__p_unsigned_int,
37544 &_swigt__p_unsigned_long,
37545 &_swigt__p_void,
37546 &_swigt__p_wxANIHandler,
37547 &_swigt__p_wxAcceleratorTable,
37548 &_swigt__p_wxActivateEvent,
37549 &_swigt__p_wxArrayString,
37550 &_swigt__p_wxBMPHandler,
37551 &_swigt__p_wxBitmap,
37552 &_swigt__p_wxBitmapDataObject,
37553 &_swigt__p_wxBoxSizer,
37554 &_swigt__p_wxBusyCursor,
37555 &_swigt__p_wxBusyInfo,
37556 &_swigt__p_wxCURHandler,
37557 &_swigt__p_wxCaret,
37558 &_swigt__p_wxChar,
37559 &_swigt__p_wxChildFocusEvent,
37560 &_swigt__p_wxClipboard,
37561 &_swigt__p_wxClipboardLocker,
37562 &_swigt__p_wxClipboardTextEvent,
37563 &_swigt__p_wxCloseEvent,
37564 &_swigt__p_wxColour,
37565 &_swigt__p_wxCommandEvent,
37566 &_swigt__p_wxConfig,
37567 &_swigt__p_wxConfigBase,
37568 &_swigt__p_wxConfigPathChanger,
37569 &_swigt__p_wxContextMenuEvent,
37570 &_swigt__p_wxControl,
37571 &_swigt__p_wxControlWithItems,
37572 &_swigt__p_wxCursor,
37573 &_swigt__p_wxCustomDataObject,
37574 &_swigt__p_wxDC,
37575 &_swigt__p_wxDataFormat,
37576 &_swigt__p_wxDataObject,
37577 &_swigt__p_wxDataObjectComposite,
37578 &_swigt__p_wxDataObjectSimple,
37579 &_swigt__p_wxDateEvent,
37580 &_swigt__p_wxDateSpan,
37581 &_swigt__p_wxDateTime,
37582 &_swigt__p_wxDateTime__TimeZone,
37583 &_swigt__p_wxDisplay,
37584 &_swigt__p_wxDisplayChangedEvent,
37585 &_swigt__p_wxDropFilesEvent,
37586 &_swigt__p_wxDuplexMode,
37587 &_swigt__p_wxEraseEvent,
37588 &_swigt__p_wxEvent,
37589 &_swigt__p_wxEvtHandler,
37590 &_swigt__p_wxFSFile,
37591 &_swigt__p_wxFileConfig,
37592 &_swigt__p_wxFileDataObject,
37593 &_swigt__p_wxFileHistory,
37594 &_swigt__p_wxFileSystem,
37595 &_swigt__p_wxFileType,
37596 &_swigt__p_wxFileTypeInfo,
37597 &_swigt__p_wxFlexGridSizer,
37598 &_swigt__p_wxFocusEvent,
37599 &_swigt__p_wxFont,
37600 &_swigt__p_wxFrame,
37601 &_swigt__p_wxGBSizerItem,
37602 &_swigt__p_wxGIFHandler,
37603 &_swigt__p_wxGridBagSizer,
37604 &_swigt__p_wxGridSizer,
37605 &_swigt__p_wxICOHandler,
37606 &_swigt__p_wxIcon,
37607 &_swigt__p_wxIconizeEvent,
37608 &_swigt__p_wxIdleEvent,
37609 &_swigt__p_wxImage,
37610 &_swigt__p_wxImageHandler,
37611 &_swigt__p_wxIndividualLayoutConstraint,
37612 &_swigt__p_wxInitDialogEvent,
37613 &_swigt__p_wxJPEGHandler,
37614 &_swigt__p_wxJoystick,
37615 &_swigt__p_wxJoystickEvent,
37616 &_swigt__p_wxKeyEvent,
37617 &_swigt__p_wxKillError,
37618 &_swigt__p_wxLayoutConstraints,
37619 &_swigt__p_wxLog,
37620 &_swigt__p_wxLogBuffer,
37621 &_swigt__p_wxLogChain,
37622 &_swigt__p_wxLogGui,
37623 &_swigt__p_wxLogNull,
37624 &_swigt__p_wxLogStderr,
37625 &_swigt__p_wxLogTextCtrl,
37626 &_swigt__p_wxLogWindow,
37627 &_swigt__p_wxMaximizeEvent,
37628 &_swigt__p_wxMemorySize,
37629 &_swigt__p_wxMenu,
37630 &_swigt__p_wxMenuBar,
37631 &_swigt__p_wxMenuEvent,
37632 &_swigt__p_wxMenuItem,
37633 &_swigt__p_wxMetafileDataObject,
37634 &_swigt__p_wxMimeTypesManager,
37635 &_swigt__p_wxMouseCaptureChangedEvent,
37636 &_swigt__p_wxMouseEvent,
37637 &_swigt__p_wxMouseState,
37638 &_swigt__p_wxMoveEvent,
37639 &_swigt__p_wxMutexGuiLocker,
37640 &_swigt__p_wxNavigationKeyEvent,
37641 &_swigt__p_wxNcPaintEvent,
37642 &_swigt__p_wxNotifyEvent,
37643 &_swigt__p_wxObject,
37644 &_swigt__p_wxOutputStream,
37645 &_swigt__p_wxPCXHandler,
37646 &_swigt__p_wxPNGHandler,
37647 &_swigt__p_wxPNMHandler,
37648 &_swigt__p_wxPaintEvent,
37649 &_swigt__p_wxPaletteChangedEvent,
37650 &_swigt__p_wxPaperSize,
37651 &_swigt__p_wxPoint,
37652 &_swigt__p_wxProcessEvent,
37653 &_swigt__p_wxPyApp,
37654 &_swigt__p_wxPyArtProvider,
37655 &_swigt__p_wxPyBitmapDataObject,
37656 &_swigt__p_wxPyCommandEvent,
37657 &_swigt__p_wxPyDataObjectSimple,
37658 &_swigt__p_wxPyDropSource,
37659 &_swigt__p_wxPyDropTarget,
37660 &_swigt__p_wxPyEvent,
37661 &_swigt__p_wxPyFileDropTarget,
37662 &_swigt__p_wxPyImageHandler,
37663 &_swigt__p_wxPyLog,
37664 &_swigt__p_wxPyProcess,
37665 &_swigt__p_wxPySizer,
37666 &_swigt__p_wxPyTextDataObject,
37667 &_swigt__p_wxPyTextDropTarget,
37668 &_swigt__p_wxPyTimer,
37669 &_swigt__p_wxPyTipProvider,
37670 &_swigt__p_wxPyValidator,
37671 &_swigt__p_wxQueryNewPaletteEvent,
37672 &_swigt__p_wxRect,
37673 &_swigt__p_wxScrollEvent,
37674 &_swigt__p_wxScrollWinEvent,
37675 &_swigt__p_wxSetCursorEvent,
37676 &_swigt__p_wxShowEvent,
37677 &_swigt__p_wxSingleInstanceChecker,
37678 &_swigt__p_wxSize,
37679 &_swigt__p_wxSizeEvent,
37680 &_swigt__p_wxSizer,
37681 &_swigt__p_wxSizerItem,
37682 &_swigt__p_wxSound,
37683 &_swigt__p_wxStandardPaths,
37684 &_swigt__p_wxStaticBoxSizer,
37685 &_swigt__p_wxStdDialogButtonSizer,
37686 &_swigt__p_wxStopWatch,
37687 &_swigt__p_wxString,
37688 &_swigt__p_wxSysColourChangedEvent,
37689 &_swigt__p_wxSystemOptions,
37690 &_swigt__p_wxSystemSettings,
37691 &_swigt__p_wxTIFFHandler,
37692 &_swigt__p_wxTextCtrl,
37693 &_swigt__p_wxTextDataObject,
37694 &_swigt__p_wxTimeSpan,
37695 &_swigt__p_wxTimer,
37696 &_swigt__p_wxTimerEvent,
37697 &_swigt__p_wxTimerRunner,
37698 &_swigt__p_wxTipProvider,
37699 &_swigt__p_wxToolTip,
37700 &_swigt__p_wxURLDataObject,
37701 &_swigt__p_wxUpdateUIEvent,
37702 &_swigt__p_wxValidator,
37703 &_swigt__p_wxVideoMode,
37704 &_swigt__p_wxWindow,
37705 &_swigt__p_wxWindowCreateEvent,
37706 &_swigt__p_wxWindowDestroyEvent,
37707 &_swigt__p_wxWindowDisabler,
37708 &_swigt__p_wxXPMHandler,
37709 };
37710
37711 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37712 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37713 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37714 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37715 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37716 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37717 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37718 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37719 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37720 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}};
37721 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37722 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37723 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37724 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37725 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37726 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37727 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37728 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37729 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}};
37730 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37731 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37732 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37733 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37734 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37735 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}};
37736 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37737 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}};
37738 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37739 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37740 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37741 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37742 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37743 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37744 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37745 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37746 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37747 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37748 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37749 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37750 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37751 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37752 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37753 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37754 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37755 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37756 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37757 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37758 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37759 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37760 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37761 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37762 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
37763 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37764 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37765 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37766 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37767 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37768 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37769 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37770 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37771 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37772 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37773 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37774 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37775 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37776 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37777 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37778 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37779 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37780 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_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_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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}};
37781 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37782 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37783 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37784 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37785 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37786 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37787 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}};
37788 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37789 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37790 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37791 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37792 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37793 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37794 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37795 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37796 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37797 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37798 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37799 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}};
37800 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37801 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37802 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37803 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37804 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37805 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37806 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37807 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37808 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37809 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37810 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37811 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37812 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37813 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37814 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37815 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37816 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37817 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37818 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37819 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37820 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37821 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37822 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37823 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37824 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37825 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37826 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37827 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37828 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37829 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37830 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37831 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
37832 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
37833 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
37834 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
37835 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
37836 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
37837 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
37838 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
37839 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
37840 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
37841 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
37842 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
37843 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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_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_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_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_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}};
37844 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
37845 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
37846 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
37847 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
37848 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
37849 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
37850 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
37851 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
37852 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}};
37853 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37854 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
37855 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
37856 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
37857 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37858 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
37859 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
37860 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
37861 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
37862 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
37863 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
37864 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
37865 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
37866 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
37867 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
37868 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
37869 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37870 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}};
37871 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
37872 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
37873 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
37874 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
37875 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}};
37876 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
37877 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
37878 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
37879 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}};
37880 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
37881
37882 static swig_cast_info *swig_cast_initial[] = {
37883 _swigc__p_char,
37884 _swigc__p_form_ops_t,
37885 _swigc__p_int,
37886 _swigc__p_unsigned_char,
37887 _swigc__p_unsigned_int,
37888 _swigc__p_unsigned_long,
37889 _swigc__p_void,
37890 _swigc__p_wxANIHandler,
37891 _swigc__p_wxAcceleratorTable,
37892 _swigc__p_wxActivateEvent,
37893 _swigc__p_wxArrayString,
37894 _swigc__p_wxBMPHandler,
37895 _swigc__p_wxBitmap,
37896 _swigc__p_wxBitmapDataObject,
37897 _swigc__p_wxBoxSizer,
37898 _swigc__p_wxBusyCursor,
37899 _swigc__p_wxBusyInfo,
37900 _swigc__p_wxCURHandler,
37901 _swigc__p_wxCaret,
37902 _swigc__p_wxChar,
37903 _swigc__p_wxChildFocusEvent,
37904 _swigc__p_wxClipboard,
37905 _swigc__p_wxClipboardLocker,
37906 _swigc__p_wxClipboardTextEvent,
37907 _swigc__p_wxCloseEvent,
37908 _swigc__p_wxColour,
37909 _swigc__p_wxCommandEvent,
37910 _swigc__p_wxConfig,
37911 _swigc__p_wxConfigBase,
37912 _swigc__p_wxConfigPathChanger,
37913 _swigc__p_wxContextMenuEvent,
37914 _swigc__p_wxControl,
37915 _swigc__p_wxControlWithItems,
37916 _swigc__p_wxCursor,
37917 _swigc__p_wxCustomDataObject,
37918 _swigc__p_wxDC,
37919 _swigc__p_wxDataFormat,
37920 _swigc__p_wxDataObject,
37921 _swigc__p_wxDataObjectComposite,
37922 _swigc__p_wxDataObjectSimple,
37923 _swigc__p_wxDateEvent,
37924 _swigc__p_wxDateSpan,
37925 _swigc__p_wxDateTime,
37926 _swigc__p_wxDateTime__TimeZone,
37927 _swigc__p_wxDisplay,
37928 _swigc__p_wxDisplayChangedEvent,
37929 _swigc__p_wxDropFilesEvent,
37930 _swigc__p_wxDuplexMode,
37931 _swigc__p_wxEraseEvent,
37932 _swigc__p_wxEvent,
37933 _swigc__p_wxEvtHandler,
37934 _swigc__p_wxFSFile,
37935 _swigc__p_wxFileConfig,
37936 _swigc__p_wxFileDataObject,
37937 _swigc__p_wxFileHistory,
37938 _swigc__p_wxFileSystem,
37939 _swigc__p_wxFileType,
37940 _swigc__p_wxFileTypeInfo,
37941 _swigc__p_wxFlexGridSizer,
37942 _swigc__p_wxFocusEvent,
37943 _swigc__p_wxFont,
37944 _swigc__p_wxFrame,
37945 _swigc__p_wxGBSizerItem,
37946 _swigc__p_wxGIFHandler,
37947 _swigc__p_wxGridBagSizer,
37948 _swigc__p_wxGridSizer,
37949 _swigc__p_wxICOHandler,
37950 _swigc__p_wxIcon,
37951 _swigc__p_wxIconizeEvent,
37952 _swigc__p_wxIdleEvent,
37953 _swigc__p_wxImage,
37954 _swigc__p_wxImageHandler,
37955 _swigc__p_wxIndividualLayoutConstraint,
37956 _swigc__p_wxInitDialogEvent,
37957 _swigc__p_wxJPEGHandler,
37958 _swigc__p_wxJoystick,
37959 _swigc__p_wxJoystickEvent,
37960 _swigc__p_wxKeyEvent,
37961 _swigc__p_wxKillError,
37962 _swigc__p_wxLayoutConstraints,
37963 _swigc__p_wxLog,
37964 _swigc__p_wxLogBuffer,
37965 _swigc__p_wxLogChain,
37966 _swigc__p_wxLogGui,
37967 _swigc__p_wxLogNull,
37968 _swigc__p_wxLogStderr,
37969 _swigc__p_wxLogTextCtrl,
37970 _swigc__p_wxLogWindow,
37971 _swigc__p_wxMaximizeEvent,
37972 _swigc__p_wxMemorySize,
37973 _swigc__p_wxMenu,
37974 _swigc__p_wxMenuBar,
37975 _swigc__p_wxMenuEvent,
37976 _swigc__p_wxMenuItem,
37977 _swigc__p_wxMetafileDataObject,
37978 _swigc__p_wxMimeTypesManager,
37979 _swigc__p_wxMouseCaptureChangedEvent,
37980 _swigc__p_wxMouseEvent,
37981 _swigc__p_wxMouseState,
37982 _swigc__p_wxMoveEvent,
37983 _swigc__p_wxMutexGuiLocker,
37984 _swigc__p_wxNavigationKeyEvent,
37985 _swigc__p_wxNcPaintEvent,
37986 _swigc__p_wxNotifyEvent,
37987 _swigc__p_wxObject,
37988 _swigc__p_wxOutputStream,
37989 _swigc__p_wxPCXHandler,
37990 _swigc__p_wxPNGHandler,
37991 _swigc__p_wxPNMHandler,
37992 _swigc__p_wxPaintEvent,
37993 _swigc__p_wxPaletteChangedEvent,
37994 _swigc__p_wxPaperSize,
37995 _swigc__p_wxPoint,
37996 _swigc__p_wxProcessEvent,
37997 _swigc__p_wxPyApp,
37998 _swigc__p_wxPyArtProvider,
37999 _swigc__p_wxPyBitmapDataObject,
38000 _swigc__p_wxPyCommandEvent,
38001 _swigc__p_wxPyDataObjectSimple,
38002 _swigc__p_wxPyDropSource,
38003 _swigc__p_wxPyDropTarget,
38004 _swigc__p_wxPyEvent,
38005 _swigc__p_wxPyFileDropTarget,
38006 _swigc__p_wxPyImageHandler,
38007 _swigc__p_wxPyLog,
38008 _swigc__p_wxPyProcess,
38009 _swigc__p_wxPySizer,
38010 _swigc__p_wxPyTextDataObject,
38011 _swigc__p_wxPyTextDropTarget,
38012 _swigc__p_wxPyTimer,
38013 _swigc__p_wxPyTipProvider,
38014 _swigc__p_wxPyValidator,
38015 _swigc__p_wxQueryNewPaletteEvent,
38016 _swigc__p_wxRect,
38017 _swigc__p_wxScrollEvent,
38018 _swigc__p_wxScrollWinEvent,
38019 _swigc__p_wxSetCursorEvent,
38020 _swigc__p_wxShowEvent,
38021 _swigc__p_wxSingleInstanceChecker,
38022 _swigc__p_wxSize,
38023 _swigc__p_wxSizeEvent,
38024 _swigc__p_wxSizer,
38025 _swigc__p_wxSizerItem,
38026 _swigc__p_wxSound,
38027 _swigc__p_wxStandardPaths,
38028 _swigc__p_wxStaticBoxSizer,
38029 _swigc__p_wxStdDialogButtonSizer,
38030 _swigc__p_wxStopWatch,
38031 _swigc__p_wxString,
38032 _swigc__p_wxSysColourChangedEvent,
38033 _swigc__p_wxSystemOptions,
38034 _swigc__p_wxSystemSettings,
38035 _swigc__p_wxTIFFHandler,
38036 _swigc__p_wxTextCtrl,
38037 _swigc__p_wxTextDataObject,
38038 _swigc__p_wxTimeSpan,
38039 _swigc__p_wxTimer,
38040 _swigc__p_wxTimerEvent,
38041 _swigc__p_wxTimerRunner,
38042 _swigc__p_wxTipProvider,
38043 _swigc__p_wxToolTip,
38044 _swigc__p_wxURLDataObject,
38045 _swigc__p_wxUpdateUIEvent,
38046 _swigc__p_wxValidator,
38047 _swigc__p_wxVideoMode,
38048 _swigc__p_wxWindow,
38049 _swigc__p_wxWindowCreateEvent,
38050 _swigc__p_wxWindowDestroyEvent,
38051 _swigc__p_wxWindowDisabler,
38052 _swigc__p_wxXPMHandler,
38053 };
38054
38055
38056 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38057
38058 static swig_const_info swig_const_table[] = {
38059 {0, 0, 0, 0.0, 0, 0}};
38060
38061 #ifdef __cplusplus
38062 }
38063 #endif
38064 /* -----------------------------------------------------------------------------
38065 * Type initialization:
38066 * This problem is tough by the requirement that no dynamic
38067 * memory is used. Also, since swig_type_info structures store pointers to
38068 * swig_cast_info structures and swig_cast_info structures store pointers back
38069 * to swig_type_info structures, we need some lookup code at initialization.
38070 * The idea is that swig generates all the structures that are needed.
38071 * The runtime then collects these partially filled structures.
38072 * The SWIG_InitializeModule function takes these initial arrays out of
38073 * swig_module, and does all the lookup, filling in the swig_module.types
38074 * array with the correct data and linking the correct swig_cast_info
38075 * structures together.
38076 *
38077 * The generated swig_type_info structures are assigned staticly to an initial
38078 * array. We just loop though that array, and handle each type individually.
38079 * First we lookup if this type has been already loaded, and if so, use the
38080 * loaded structure instead of the generated one. Then we have to fill in the
38081 * cast linked list. The cast data is initially stored in something like a
38082 * two-dimensional array. Each row corresponds to a type (there are the same
38083 * number of rows as there are in the swig_type_initial array). Each entry in
38084 * a column is one of the swig_cast_info structures for that type.
38085 * The cast_initial array is actually an array of arrays, because each row has
38086 * a variable number of columns. So to actually build the cast linked list,
38087 * we find the array of casts associated with the type, and loop through it
38088 * adding the casts to the list. The one last trick we need to do is making
38089 * sure the type pointer in the swig_cast_info struct is correct.
38090 *
38091 * First off, we lookup the cast->type name to see if it is already loaded.
38092 * There are three cases to handle:
38093 * 1) If the cast->type has already been loaded AND the type we are adding
38094 * casting info to has not been loaded (it is in this module), THEN we
38095 * replace the cast->type pointer with the type pointer that has already
38096 * been loaded.
38097 * 2) If BOTH types (the one we are adding casting info to, and the
38098 * cast->type) are loaded, THEN the cast info has already been loaded by
38099 * the previous module so we just ignore it.
38100 * 3) Finally, if cast->type has not already been loaded, then we add that
38101 * swig_cast_info to the linked list (because the cast->type) pointer will
38102 * be correct.
38103 * ----------------------------------------------------------------------------- */
38104
38105 #ifdef __cplusplus
38106 extern "C" {
38107 #if 0
38108 } /* c-mode */
38109 #endif
38110 #endif
38111
38112 #if 0
38113 #define SWIGRUNTIME_DEBUG
38114 #endif
38115
38116 SWIGRUNTIME void
38117 SWIG_InitializeModule(void *clientdata) {
38118 size_t i;
38119 swig_module_info *module_head;
38120 static int init_run = 0;
38121
38122 clientdata = clientdata;
38123
38124 if (init_run) return;
38125 init_run = 1;
38126
38127 /* Initialize the swig_module */
38128 swig_module.type_initial = swig_type_initial;
38129 swig_module.cast_initial = swig_cast_initial;
38130
38131 /* Try and load any already created modules */
38132 module_head = SWIG_GetModule(clientdata);
38133 if (module_head) {
38134 swig_module.next = module_head->next;
38135 module_head->next = &swig_module;
38136 } else {
38137 /* This is the first module loaded */
38138 swig_module.next = &swig_module;
38139 SWIG_SetModule(clientdata, &swig_module);
38140 }
38141
38142 /* Now work on filling in swig_module.types */
38143 #ifdef SWIGRUNTIME_DEBUG
38144 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38145 #endif
38146 for (i = 0; i < swig_module.size; ++i) {
38147 swig_type_info *type = 0;
38148 swig_type_info *ret;
38149 swig_cast_info *cast;
38150
38151 #ifdef SWIGRUNTIME_DEBUG
38152 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38153 #endif
38154
38155 /* if there is another module already loaded */
38156 if (swig_module.next != &swig_module) {
38157 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38158 }
38159 if (type) {
38160 /* Overwrite clientdata field */
38161 #ifdef SWIGRUNTIME_DEBUG
38162 printf("SWIG_InitializeModule: found type %s\n", type->name);
38163 #endif
38164 if (swig_module.type_initial[i]->clientdata) {
38165 type->clientdata = swig_module.type_initial[i]->clientdata;
38166 #ifdef SWIGRUNTIME_DEBUG
38167 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38168 #endif
38169 }
38170 } else {
38171 type = swig_module.type_initial[i];
38172 }
38173
38174 /* Insert casting types */
38175 cast = swig_module.cast_initial[i];
38176 while (cast->type) {
38177 /* Don't need to add information already in the list */
38178 ret = 0;
38179 #ifdef SWIGRUNTIME_DEBUG
38180 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38181 #endif
38182 if (swig_module.next != &swig_module) {
38183 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38184 #ifdef SWIGRUNTIME_DEBUG
38185 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38186 #endif
38187 }
38188 if (ret) {
38189 if (type == swig_module.type_initial[i]) {
38190 #ifdef SWIGRUNTIME_DEBUG
38191 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38192 #endif
38193 cast->type = ret;
38194 ret = 0;
38195 } else {
38196 /* Check for casting already in the list */
38197 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38198 #ifdef SWIGRUNTIME_DEBUG
38199 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38200 #endif
38201 if (!ocast) ret = 0;
38202 }
38203 }
38204
38205 if (!ret) {
38206 #ifdef SWIGRUNTIME_DEBUG
38207 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38208 #endif
38209 if (type->cast) {
38210 type->cast->prev = cast;
38211 cast->next = type->cast;
38212 }
38213 type->cast = cast;
38214 }
38215 cast++;
38216 }
38217 /* Set entry in modules->types array equal to the type */
38218 swig_module.types[i] = type;
38219 }
38220 swig_module.types[i] = 0;
38221
38222 #ifdef SWIGRUNTIME_DEBUG
38223 printf("**** SWIG_InitializeModule: Cast List ******\n");
38224 for (i = 0; i < swig_module.size; ++i) {
38225 int j = 0;
38226 swig_cast_info *cast = swig_module.cast_initial[i];
38227 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38228 while (cast->type) {
38229 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38230 cast++;
38231 ++j;
38232 }
38233 printf("---- Total casts: %d\n",j);
38234 }
38235 printf("**** SWIG_InitializeModule: Cast List ******\n");
38236 #endif
38237 }
38238
38239 /* This function will propagate the clientdata field of type to
38240 * any new swig_type_info structures that have been added into the list
38241 * of equivalent types. It is like calling
38242 * SWIG_TypeClientData(type, clientdata) a second time.
38243 */
38244 SWIGRUNTIME void
38245 SWIG_PropagateClientData(void) {
38246 size_t i;
38247 swig_cast_info *equiv;
38248 static int init_run = 0;
38249
38250 if (init_run) return;
38251 init_run = 1;
38252
38253 for (i = 0; i < swig_module.size; i++) {
38254 if (swig_module.types[i]->clientdata) {
38255 equiv = swig_module.types[i]->cast;
38256 while (equiv) {
38257 if (!equiv->converter) {
38258 if (equiv->type && !equiv->type->clientdata)
38259 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38260 }
38261 equiv = equiv->next;
38262 }
38263 }
38264 }
38265 }
38266
38267 #ifdef __cplusplus
38268 #if 0
38269 {
38270 /* c-mode */
38271 #endif
38272 }
38273 #endif
38274
38275
38276
38277 #ifdef __cplusplus
38278 extern "C" {
38279 #endif
38280
38281 /* Python-specific SWIG API */
38282 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38283 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38284 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38285
38286 /* -----------------------------------------------------------------------------
38287 * global variable support code.
38288 * ----------------------------------------------------------------------------- */
38289
38290 typedef struct swig_globalvar {
38291 char *name; /* Name of global variable */
38292 PyObject *(*get_attr)(void); /* Return the current value */
38293 int (*set_attr)(PyObject *); /* Set the value */
38294 struct swig_globalvar *next;
38295 } swig_globalvar;
38296
38297 typedef struct swig_varlinkobject {
38298 PyObject_HEAD
38299 swig_globalvar *vars;
38300 } swig_varlinkobject;
38301
38302 SWIGINTERN PyObject *
38303 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38304 return PyString_FromString("<Swig global variables>");
38305 }
38306
38307 SWIGINTERN PyObject *
38308 swig_varlink_str(swig_varlinkobject *v) {
38309 PyObject *str = PyString_FromString("(");
38310 swig_globalvar *var;
38311 for (var = v->vars; var; var=var->next) {
38312 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38313 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38314 }
38315 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38316 return str;
38317 }
38318
38319 SWIGINTERN int
38320 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38321 PyObject *str = swig_varlink_str(v);
38322 fprintf(fp,"Swig global variables ");
38323 fprintf(fp,"%s\n", PyString_AsString(str));
38324 Py_DECREF(str);
38325 return 0;
38326 }
38327
38328 SWIGINTERN void
38329 swig_varlink_dealloc(swig_varlinkobject *v) {
38330 swig_globalvar *var = v->vars;
38331 while (var) {
38332 swig_globalvar *n = var->next;
38333 free(var->name);
38334 free(var);
38335 var = n;
38336 }
38337 }
38338
38339 SWIGINTERN PyObject *
38340 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38341 PyObject *res = NULL;
38342 swig_globalvar *var = v->vars;
38343 while (var) {
38344 if (strcmp(var->name,n) == 0) {
38345 res = (*var->get_attr)();
38346 break;
38347 }
38348 var = var->next;
38349 }
38350 if (res == NULL && !PyErr_Occurred()) {
38351 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38352 }
38353 return res;
38354 }
38355
38356 SWIGINTERN int
38357 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38358 int res = 1;
38359 swig_globalvar *var = v->vars;
38360 while (var) {
38361 if (strcmp(var->name,n) == 0) {
38362 res = (*var->set_attr)(p);
38363 break;
38364 }
38365 var = var->next;
38366 }
38367 if (res == 1 && !PyErr_Occurred()) {
38368 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38369 }
38370 return res;
38371 }
38372
38373 SWIGINTERN PyTypeObject*
38374 swig_varlink_type(void) {
38375 static char varlink__doc__[] = "Swig var link object";
38376 static PyTypeObject varlink_type;
38377 static int type_init = 0;
38378 if (!type_init) {
38379 const PyTypeObject tmp
38380 = {
38381 PyObject_HEAD_INIT(NULL)
38382 0, /* Number of items in variable part (ob_size) */
38383 (char *)"swigvarlink", /* Type name (tp_name) */
38384 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38385 0, /* Itemsize (tp_itemsize) */
38386 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38387 (printfunc) swig_varlink_print, /* Print (tp_print) */
38388 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38389 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38390 0, /* tp_compare */
38391 (reprfunc) swig_varlink_repr, /* tp_repr */
38392 0, /* tp_as_number */
38393 0, /* tp_as_sequence */
38394 0, /* tp_as_mapping */
38395 0, /* tp_hash */
38396 0, /* tp_call */
38397 (reprfunc)swig_varlink_str, /* tp_str */
38398 0, /* tp_getattro */
38399 0, /* tp_setattro */
38400 0, /* tp_as_buffer */
38401 0, /* tp_flags */
38402 varlink__doc__, /* tp_doc */
38403 0, /* tp_traverse */
38404 0, /* tp_clear */
38405 0, /* tp_richcompare */
38406 0, /* tp_weaklistoffset */
38407 #if PY_VERSION_HEX >= 0x02020000
38408 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38409 #endif
38410 #if PY_VERSION_HEX >= 0x02030000
38411 0, /* tp_del */
38412 #endif
38413 #ifdef COUNT_ALLOCS
38414 0,0,0,0 /* tp_alloc -> tp_next */
38415 #endif
38416 };
38417 varlink_type = tmp;
38418 varlink_type.ob_type = &PyType_Type;
38419 type_init = 1;
38420 }
38421 return &varlink_type;
38422 }
38423
38424 /* Create a variable linking object for use later */
38425 SWIGINTERN PyObject *
38426 SWIG_Python_newvarlink(void) {
38427 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38428 if (result) {
38429 result->vars = 0;
38430 }
38431 return ((PyObject*) result);
38432 }
38433
38434 SWIGINTERN void
38435 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38436 swig_varlinkobject *v = (swig_varlinkobject *) p;
38437 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38438 if (gv) {
38439 size_t size = strlen(name)+1;
38440 gv->name = (char *)malloc(size);
38441 if (gv->name) {
38442 strncpy(gv->name,name,size);
38443 gv->get_attr = get_attr;
38444 gv->set_attr = set_attr;
38445 gv->next = v->vars;
38446 }
38447 }
38448 v->vars = gv;
38449 }
38450
38451 SWIGINTERN PyObject *
38452 SWIG_globals() {
38453 static PyObject *_SWIG_globals = 0;
38454 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38455 return _SWIG_globals;
38456 }
38457
38458 /* -----------------------------------------------------------------------------
38459 * constants/methods manipulation
38460 * ----------------------------------------------------------------------------- */
38461
38462 /* Install Constants */
38463 SWIGINTERN void
38464 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38465 PyObject *obj = 0;
38466 size_t i;
38467 for (i = 0; constants[i].type; ++i) {
38468 switch(constants[i].type) {
38469 case SWIG_PY_POINTER:
38470 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38471 break;
38472 case SWIG_PY_BINARY:
38473 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38474 break;
38475 default:
38476 obj = 0;
38477 break;
38478 }
38479 if (obj) {
38480 PyDict_SetItemString(d, constants[i].name, obj);
38481 Py_DECREF(obj);
38482 }
38483 }
38484 }
38485
38486 /* -----------------------------------------------------------------------------*/
38487 /* Fix SwigMethods to carry the callback ptrs when needed */
38488 /* -----------------------------------------------------------------------------*/
38489
38490 SWIGINTERN void
38491 SWIG_Python_FixMethods(PyMethodDef *methods,
38492 swig_const_info *const_table,
38493 swig_type_info **types,
38494 swig_type_info **types_initial) {
38495 size_t i;
38496 for (i = 0; methods[i].ml_name; ++i) {
38497 char *c = methods[i].ml_doc;
38498 if (c && (c = strstr(c, "swig_ptr: "))) {
38499 int j;
38500 swig_const_info *ci = 0;
38501 char *name = c + 10;
38502 for (j = 0; const_table[j].type; ++j) {
38503 if (strncmp(const_table[j].name, name,
38504 strlen(const_table[j].name)) == 0) {
38505 ci = &(const_table[j]);
38506 break;
38507 }
38508 }
38509 if (ci) {
38510 size_t shift = (ci->ptype) - types;
38511 swig_type_info *ty = types_initial[shift];
38512 size_t ldoc = (c - methods[i].ml_doc);
38513 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38514 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38515 if (ndoc) {
38516 char *buff = ndoc;
38517 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38518 if (ptr) {
38519 strncpy(buff, methods[i].ml_doc, ldoc);
38520 buff += ldoc;
38521 strncpy(buff, "swig_ptr: ", 10);
38522 buff += 10;
38523 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38524 methods[i].ml_doc = ndoc;
38525 }
38526 }
38527 }
38528 }
38529 }
38530 }
38531
38532 #ifdef __cplusplus
38533 }
38534 #endif
38535
38536 /* -----------------------------------------------------------------------------*
38537 * Partial Init method
38538 * -----------------------------------------------------------------------------*/
38539
38540 #ifdef __cplusplus
38541 extern "C"
38542 #endif
38543 SWIGEXPORT void SWIG_init(void) {
38544 PyObject *m, *d;
38545
38546 /* Fix SwigMethods to carry the callback ptrs when needed */
38547 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38548
38549 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38550 d = PyModule_GetDict(m);
38551
38552 SWIG_InitializeModule(0);
38553 SWIG_InstallConstants(d,swig_const_table);
38554
38555
38556 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38557 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38558 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38559 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38560 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38561 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38562 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38563 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38564 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38565 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38566 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38567 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38568 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38569 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38570 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38571 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38572 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38573 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38574 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38575 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38576 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38577 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38578 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38579 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38580 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38581 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38582 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38583 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38584 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38585 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38586 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38587 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38588 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38589 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38590 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38591 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38592 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38593 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38594 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38595 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38596 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38597 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38598 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38599 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38600 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38601 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38602 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38603 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38604 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38605 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38606 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38607 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38608 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38609 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38610 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38611 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38612 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38613 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38614 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38615 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38616 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38617 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38618 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38619 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38620 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38621 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38622 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38623 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38624 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38625 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38626 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38627 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38628 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38629 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38630 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38631 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38632 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38633 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38634 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38635 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38636 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38637 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38638 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38639 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38640 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38641 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38642 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38643 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38644 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38645 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38646 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38647 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38648 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38649 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38650 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38651 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38652 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38653 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38654 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38655 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38656 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38657 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38658
38659 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38660
38661 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38662 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38663 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38664 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38665 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38666 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38667 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38668 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38669 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38670 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38671 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38672 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38673 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38674 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38675 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38676 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38677 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38678 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38679 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38680 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38681 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38682 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38683 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38684 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38685 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38686 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38687 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38688 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38689 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38690 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38691 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38692 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38693 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38694 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38695 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38696 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38697 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38698 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38699 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38700 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38701 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38702 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38703 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38704 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38705 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38706 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38707 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38708 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38709 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38710 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38711 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38712 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38713 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38714
38715 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38716
38717 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38718 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38719 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38720 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38721 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38722 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38723 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38724 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38725 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38726 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38727 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38728 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38729 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38730 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38731 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38732 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38733 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38734 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38735 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38736 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38737 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38738 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38739 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38740 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38741 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38742 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38743 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38744 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38745 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38746 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38747 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38748 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38749 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38750 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38751 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38752 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38753 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38754 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38755 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38756 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38757 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38758 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38759 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38760 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38761 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38762 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38763 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38764 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38765 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38766 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38767 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38768 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38769 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38770 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38771 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38772 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38773 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38774 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38775 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38776 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38777 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38778 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38779 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38780 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38781 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38782 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38783 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38784 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38785 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38786 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38787 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38788 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38789 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38790 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38791 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38792 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38793
38794 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38795
38796 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38797 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38798 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38799 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38800 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38801 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38802 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38803 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38804 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38805 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38806 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38807 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38808 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38809 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38810 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38811 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38812 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38813 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38814 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38815 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38816 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38817 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38818 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38819 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38820 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38821 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38822 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38823 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38824 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38825 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38826 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38827 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38828 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38829 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
38830 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
38831 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
38832 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
38833 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
38834 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
38835 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
38836 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
38837 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
38838 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
38839 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
38840 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
38841 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
38842 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
38843 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
38844 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
38845 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
38846 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
38847 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
38848 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
38849 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
38850 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
38851 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
38852 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
38853 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
38854 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
38855 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
38856 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
38857 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
38858 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
38859 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
38860 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
38861 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
38862 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
38863 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
38864 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
38865 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
38866 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
38867 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
38868 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
38869 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
38870 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
38871 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
38872 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
38873 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
38874 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
38875 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
38876 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
38877 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
38878 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
38879 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
38880 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
38881 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
38882 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
38883 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
38884 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
38885 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
38886 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
38887 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
38888 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
38889 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
38890 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
38891 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
38892 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
38893 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
38894 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
38895 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
38896 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
38897 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
38898 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
38899 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
38900 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
38901 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
38902 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
38903 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
38904 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
38905 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
38906 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
38907 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
38908 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
38909 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
38910 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
38911 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
38912 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
38913 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
38914 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
38915 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
38916 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
38917 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
38918 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
38919 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
38920 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
38921 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
38922 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
38923 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
38924 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
38925 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
38926 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
38927 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
38928 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
38929 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
38930 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
38931 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
38932 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
38933 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
38934 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
38935 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
38936 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
38937 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
38938 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
38939 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
38940 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
38941 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
38942 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
38943 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
38944 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
38945 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
38946 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
38947 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
38948 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
38949 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
38950 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
38951 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
38952 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
38953 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
38954 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
38955 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
38956 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
38957 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
38958 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
38959 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
38960 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
38961 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
38962 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
38963 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
38964 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
38965 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
38966 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
38967 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
38968 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
38969 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
38970 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
38971 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
38972 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
38973 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
38974 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
38975 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
38976 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
38977 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
38978 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
38979 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
38980 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
38981 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
38982 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
38983 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
38984 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
38985 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
38986 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
38987 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
38988 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
38989 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
38990 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
38991 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
38992 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
38993 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
38994 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
38995 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
38996
38997 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
38998 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
38999 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39000 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39001
39002 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39003 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39004 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39005 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39006 }
39007
wxWidgets (Impactor)